RTEMS 4.11Annotated Report
Wed Apr 11 09:44:43 2012
020057d0 <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
20057d0: 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, "...." );
20057d4: 21 00 80 88 sethi %hi(0x2022000), %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20057d8: fa 06 20 50 ld [ %i0 + 0x50 ], %i5
20057dc: 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 ) );
20057e0: 35 00 80 89 sethi %hi(0x2022400), %i2
return;
}
puts("");
20057e4: 37 00 80 88 sethi %hi(0x2022000), %i3
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 ));
20057e8: b0 06 20 54 add %i0, 0x54, %i0
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
20057ec: a0 14 23 e0 or %l0, 0x3e0, %l0
20057f0: b8 17 21 68 or %i4, 0x168, %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20057f4: b4 16 a0 50 or %i2, 0x50, %i2
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 );
20057f8: 10 80 00 4e b 2005930 <IMFS_dump_directory+0x160>
20057fc: b6 16 e3 78 or %i3, 0x378, %i3
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
2005800: 90 10 00 10 mov %l0, %o0
2005804: 40 00 39 91 call 2013e48 <fputs>
2005808: a2 04 60 01 inc %l1
200580c: 10 80 00 03 b 2005818 <IMFS_dump_directory+0x48>
2005810: c2 07 00 00 ld [ %i4 ], %g1
2005814: 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++ )
2005818: 80 a4 40 19 cmp %l1, %i1
200581c: 04 bf ff f9 ble 2005800 <IMFS_dump_directory+0x30>
2005820: d2 00 60 08 ld [ %g1 + 8 ], %o1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
2005824: 40 00 39 89 call 2013e48 <fputs>
2005828: 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;
200582c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
2005830: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
2005834: 80 a2 a0 06 cmp %o2, 6
2005838: 38 80 00 2e bgu,a 20058f0 <IMFS_dump_directory+0x120> <== NEVER TAKEN
200583c: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
2005840: 95 2a a0 02 sll %o2, 2, %o2
2005844: 03 00 80 15 sethi %hi(0x2005400), %g1
2005848: 82 10 63 b4 or %g1, 0x3b4, %g1 ! 20057b4 <bsp_interrupt_handler_default+0x18>
200584c: c2 00 40 0a ld [ %g1 + %o2 ], %g1
2005850: 81 c0 40 00 jmp %g1
2005854: 01 00 00 00 nop
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
2005858: c2 07 00 00 ld [ %i4 ], %g1
200585c: 90 10 20 2f mov 0x2f, %o0
2005860: 40 00 39 45 call 2013d74 <fputc>
2005864: d2 00 60 08 ld [ %g1 + 8 ], %o1
2005868: 30 80 00 27 b,a 2005904 <IMFS_dump_directory+0x134>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
200586c: c2 07 00 00 ld [ %i4 ], %g1
2005870: 13 00 80 88 sethi %hi(0x2022000), %o1
2005874: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005878: 92 12 63 e8 or %o1, 0x3e8, %o1
200587c: 10 80 00 08 b 200589c <IMFS_dump_directory+0xcc>
2005880: 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)",
2005884: c2 07 00 00 ld [ %i4 ], %g1
2005888: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
200588c: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005890: d6 07 60 58 ld [ %i5 + 0x58 ], %o3
2005894: 13 00 80 89 sethi %hi(0x2022400), %o1
2005898: 92 12 60 00 mov %o1, %o1 ! 2022400 <rtems_filesystem_table+0x1734>
200589c: 40 00 39 1a call 2013d04 <fprintf>
20058a0: 01 00 00 00 nop
20058a4: 30 80 00 18 b,a 2005904 <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 ")",
20058a8: c2 07 00 00 ld [ %i4 ], %g1
20058ac: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
20058b0: d0 00 60 08 ld [ %g1 + 8 ], %o0
20058b4: 13 00 80 89 sethi %hi(0x2022400), %o1
20058b8: 40 00 39 13 call 2013d04 <fprintf>
20058bc: 92 12 60 10 or %o1, 0x10, %o1 ! 2022410 <rtems_filesystem_table+0x1744>
20058c0: 30 80 00 11 b,a 2005904 <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" );
20058c4: 11 00 80 89 sethi %hi(0x2022400), %o0
20058c8: c2 07 00 00 ld [ %i4 ], %g1
20058cc: 10 80 00 05 b 20058e0 <IMFS_dump_directory+0x110>
20058d0: 90 12 20 20 or %o0, 0x20, %o0
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
20058d4: c2 07 00 00 ld [ %i4 ], %g1
20058d8: 11 00 80 89 sethi %hi(0x2022400), %o0
20058dc: 90 12 20 38 or %o0, 0x38, %o0 ! 2022438 <rtems_filesystem_table+0x176c>
20058e0: 40 00 39 5a call 2013e48 <fputs>
20058e4: 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;
20058e8: 10 80 00 0a b 2005910 <IMFS_dump_directory+0x140>
20058ec: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20058f0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
20058f4: 40 00 39 04 call 2013d04 <fprintf> <== NOT EXECUTED
20058f8: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
20058fc: 10 80 00 05 b 2005910 <IMFS_dump_directory+0x140> <== NOT EXECUTED
2005900: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
return;
}
puts("");
2005904: 40 00 40 42 call 2015a0c <puts>
2005908: 90 10 00 1b mov %i3, %o0
200590c: 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 ) )
2005910: c2 00 40 00 ld [ %g1 ], %g1
2005914: 80 a0 60 00 cmp %g1, 0
2005918: 32 80 00 06 bne,a 2005930 <IMFS_dump_directory+0x160>
200591c: fa 07 40 00 ld [ %i5 ], %i5
IMFS_dump_directory( the_jnode, level + 1 );
2005920: 90 10 00 1d mov %i5, %o0
2005924: 7f ff ff ab call 20057d0 <IMFS_dump_directory>
2005928: 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 ) {
200592c: fa 07 40 00 ld [ %i5 ], %i5
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 );
2005930: 80 a7 40 18 cmp %i5, %i0
2005934: 12 bf ff b8 bne 2005814 <IMFS_dump_directory+0x44>
2005938: a2 10 20 00 clr %l1
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
200593c: 81 c7 e0 08 ret
2005940: 81 e8 00 00 restore
0200b8a0 <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
200b8a0: 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;
200b8a4: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
200b8a8: 90 10 00 18 mov %i0, %o0
200b8ac: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
200b8b0: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
200b8b4: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
200b8b8: ba 10 00 18 mov %i0, %i5
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;
bool access_ok = rtems_filesystem_eval_path_check_access(
200b8bc: 92 10 20 01 mov 1, %o1
200b8c0: 40 00 03 0d call 200c4f4 <rtems_filesystem_eval_path_check_access>
200b8c4: b0 10 20 01 mov 1, %i0
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
200b8c8: 80 8a 20 ff btst 0xff, %o0
200b8cc: 02 80 00 48 be 200b9ec <IMFS_eval_token+0x14c>
200b8d0: 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] == '.';
200b8d4: 12 80 00 5c bne 200ba44 <IMFS_eval_token+0x1a4>
200b8d8: 80 a6 e0 02 cmp %i3, 2
200b8dc: c2 4e 80 00 ldsb [ %i2 ], %g1
200b8e0: 80 a0 60 2e cmp %g1, 0x2e
200b8e4: 32 80 00 5b bne,a 200ba50 <IMFS_eval_token+0x1b0>
200b8e8: f2 07 20 50 ld [ %i4 + 0x50 ], %i1
200b8ec: 10 80 00 1c b 200b95c <IMFS_eval_token+0xbc>
200b8f0: b2 10 00 1c mov %i4, %i1
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200b8f4: 80 a0 60 2e cmp %g1, 0x2e
200b8f8: 32 80 00 56 bne,a 200ba50 <IMFS_eval_token+0x1b0>
200b8fc: f2 07 20 50 ld [ %i4 + 0x50 ], %i1
200b900: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
200b904: 80 a0 60 2e cmp %g1, 0x2e
200b908: 32 80 00 52 bne,a 200ba50 <IMFS_eval_token+0x1b0> <== NEVER TAKEN
200b90c: f2 07 20 50 ld [ %i4 + 0x50 ], %i1 <== NOT EXECUTED
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
return dir->Parent;
200b910: 10 80 00 13 b 200b95c <IMFS_eval_token+0xbc>
200b914: f2 07 20 08 ld [ %i4 + 8 ], %i1
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
while ( current != tail ) {
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
200b918: 92 10 00 1a mov %i2, %o1
200b91c: 40 00 15 9f call 2010f98 <strncmp>
200b920: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
200b924: 80 a2 20 00 cmp %o0, 0
200b928: 32 80 00 08 bne,a 200b948 <IMFS_eval_token+0xa8>
200b92c: f2 06 40 00 ld [ %i1 ], %i1
200b930: 82 06 40 1b add %i1, %i3, %g1
200b934: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
200b938: 80 a0 60 00 cmp %g1, 0
200b93c: 02 80 00 09 be 200b960 <IMFS_eval_token+0xc0>
200b940: 80 a6 60 00 cmp %i1, 0
200b944: f2 06 40 00 ld [ %i1 ], %i1
} 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 ) {
200b948: 80 a6 40 18 cmp %i1, %i0
200b94c: 12 bf ff f3 bne 200b918 <IMFS_eval_token+0x78>
200b950: 90 06 60 0c add %i1, 0xc, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
}
}
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
200b954: 81 c7 e0 08 ret
200b958: 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 ) {
200b95c: 80 a6 60 00 cmp %i1, 0
200b960: 02 80 00 23 be 200b9ec <IMFS_eval_token+0x14c>
200b964: b0 10 20 02 mov 2, %i0
bool terminal = !rtems_filesystem_eval_path_has_path( ctx );
200b968: c2 07 60 04 ld [ %i5 + 4 ], %g1
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
200b96c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200b970: 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;
200b974: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
200b978: b0 60 3f ff subx %g0, -1, %i0
200b97c: c2 00 40 00 ld [ %g1 ], %g1
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)) {
200b980: 80 a0 60 02 cmp %g1, 2
200b984: 12 80 00 0a bne 200b9ac <IMFS_eval_token+0x10c>
200b988: c0 27 60 0c clr [ %i5 + 0xc ]
200b98c: 80 88 a0 08 btst 8, %g2
200b990: 32 80 00 32 bne,a 200ba58 <IMFS_eval_token+0x1b8>
200b994: f2 06 60 50 ld [ %i1 + 0x50 ], %i1
200b998: 80 8e 20 ff btst 0xff, %i0
200b99c: 32 80 00 30 bne,a 200ba5c <IMFS_eval_token+0x1bc> <== ALWAYS TAKEN
200b9a0: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
entry = entry->info.hard_link.link_node;
200b9a4: 10 80 00 2d b 200ba58 <IMFS_eval_token+0x1b8> <== NOT EXECUTED
200b9a8: f2 06 60 50 ld [ %i1 + 0x50 ], %i1 <== NOT EXECUTED
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
200b9ac: 80 a0 60 03 cmp %g1, 3
200b9b0: 12 80 00 11 bne 200b9f4 <IMFS_eval_token+0x154>
200b9b4: 80 a0 60 00 cmp %g1, 0
200b9b8: 80 88 a0 10 btst 0x10, %g2
200b9bc: 12 80 00 04 bne 200b9cc <IMFS_eval_token+0x12c>
200b9c0: 80 8e 20 ff btst 0xff, %i0
200b9c4: 32 80 00 26 bne,a 200ba5c <IMFS_eval_token+0x1bc>
200b9c8: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
const char *target = entry->info.sym_link.name;
200b9cc: f8 06 60 50 ld [ %i1 + 0x50 ], %i4
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200b9d0: b0 10 20 01 mov 1, %i0
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
const char *target = entry->info.sym_link.name;
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
200b9d4: 40 00 15 40 call 2010ed4 <strlen>
200b9d8: 90 10 00 1c mov %i4, %o0
200b9dc: 92 10 00 1c mov %i4, %o1
200b9e0: 94 10 00 08 mov %o0, %o2
200b9e4: 7f ff e4 7d call 2004bd8 <rtems_filesystem_eval_path_recursive>
200b9e8: 90 10 00 1d mov %i5, %o0
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
200b9ec: 81 c7 e0 08 ret
200b9f0: 81 e8 00 00 restore
IMFS_jnode_types_t type
)
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
200b9f4: 32 80 00 1a bne,a 200ba5c <IMFS_eval_token+0x1bc>
200b9f8: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
if ( node->info.directory.mt_fs != NULL ) {
200b9fc: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
200ba00: 80 a0 60 00 cmp %g1, 0
200ba04: 02 80 00 15 be 200ba58 <IMFS_eval_token+0x1b8>
200ba08: 90 10 00 1d mov %i5, %o0
if ( !terminal ) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
access_ok = rtems_filesystem_eval_path_check_access(
200ba0c: d4 06 60 30 ld [ %i1 + 0x30 ], %o2
200ba10: d6 16 60 3c lduh [ %i1 + 0x3c ], %o3
200ba14: d8 16 60 3e lduh [ %i1 + 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;
200ba18: b8 00 60 18 add %g1, 0x18, %i4
if ( !terminal ) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
access_ok = rtems_filesystem_eval_path_check_access(
200ba1c: 92 10 20 01 mov 1, %o1
200ba20: 40 00 02 b5 call 200c4f4 <rtems_filesystem_eval_path_check_access>
200ba24: b0 10 20 01 mov 1, %i0
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
200ba28: 80 8a 20 ff btst 0xff, %o0
200ba2c: 02 bf ff f0 be 200b9ec <IMFS_eval_token+0x14c> <== NEVER TAKEN
200ba30: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
200ba34: 7f ff e4 52 call 2004b7c <rtems_filesystem_eval_path_restart>
200ba38: 92 10 00 1c mov %i4, %o1
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
200ba3c: 81 c7 e0 08 ret
200ba40: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200ba44: 22 bf ff ac be,a 200b8f4 <IMFS_eval_token+0x54>
200ba48: c2 4e 80 00 ldsb [ %i2 ], %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200ba4c: f2 07 20 50 ld [ %i4 + 0x50 ], %i1
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
return dir->Parent;
} 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 );
200ba50: 10 bf ff be b 200b948 <IMFS_eval_token+0xa8>
200ba54: b0 07 20 54 add %i4, 0x54, %i0
} else {
rtems_filesystem_global_location_t **fs_root_ptr =
IMFS_is_mount_point( entry, type );
if ( fs_root_ptr == NULL ) {
--dir->reference_count;
200ba58: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200ba5c: b0 0e 20 ff and %i0, 0xff, %i0
} else {
rtems_filesystem_global_location_t **fs_root_ptr =
IMFS_is_mount_point( entry, type );
if ( fs_root_ptr == NULL ) {
--dir->reference_count;
200ba60: 82 00 7f ff add %g1, -1, %g1
200ba64: c2 37 20 34 sth %g1, [ %i4 + 0x34 ]
++entry->reference_count;
200ba68: c2 16 60 34 lduh [ %i1 + 0x34 ], %g1
200ba6c: 82 00 60 01 inc %g1
200ba70: c2 36 60 34 sth %g1, [ %i1 + 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;
200ba74: c2 06 60 4c ld [ %i1 + 0x4c ], %g1
currentloc->node_access = entry;
200ba78: f2 27 60 20 st %i1, [ %i5 + 0x20 ]
200ba7c: c2 00 60 04 ld [ %g1 + 4 ], %g1
200ba80: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
200ba84: 81 c7 e0 08 ret
200ba88: 81 e8 00 00 restore
02003994 <IMFS_fifo_lseek>:
static off_t IMFS_fifo_lseek(
rtems_libio_t *iop,
off_t offset,
int whence
)
{
2003994: 9d e3 bf a0 save %sp, -96, %sp
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
2003998: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200399c: 92 10 00 19 mov %i1, %o1
20039a0: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
20039a4: 98 10 00 18 mov %i0, %o4
20039a8: 94 10 00 1a mov %i2, %o2
20039ac: 40 00 2a f7 call 200e588 <pipe_lseek>
20039b0: 96 10 00 1b mov %i3, %o3
20039b4: b1 3a 20 1f sra %o0, 0x1f, %i0
IMFS_FIFO_RETURN(err);
20039b8: 80 a6 20 00 cmp %i0, 0
20039bc: 16 80 00 08 bge 20039dc <IMFS_fifo_lseek+0x48> <== NEVER TAKEN
20039c0: b2 10 00 08 mov %o0, %i1
20039c4: 40 00 37 a5 call 2011858 <__errno>
20039c8: 31 3f ff ff sethi %hi(0xfffffc00), %i0
20039cc: 82 20 00 19 neg %i1, %g1
20039d0: c2 22 00 00 st %g1, [ %o0 ]
20039d4: b0 16 23 ff or %i0, 0x3ff, %i0
20039d8: b2 10 00 18 mov %i0, %i1
}
20039dc: 81 c7 e0 08 ret
20039e0: 81 e8 00 00 restore
020039e4 <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
20039e4: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
20039e8: fa 06 20 24 ld [ %i0 + 0x24 ], %i5
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
20039ec: 96 10 00 18 mov %i0, %o3
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
20039f0: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
20039f4: 92 10 00 19 mov %i1, %o1
20039f8: 40 00 2a 56 call 200e350 <pipe_write>
20039fc: 94 10 00 1a mov %i2, %o2
if (err > 0) {
2003a00: b0 92 20 00 orcc %o0, 0, %i0
2003a04: 04 80 00 09 ble 2003a28 <IMFS_fifo_write+0x44>
2003a08: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
2003a0c: 40 00 04 1d call 2004a80 <gettimeofday>
2003a10: 92 10 20 00 clr %o1
2003a14: c2 07 bf f8 ld [ %fp + -8 ], %g1
2003a18: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
2003a1c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
2003a20: 81 c7 e0 08 ret
2003a24: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
2003a28: 80 a6 20 00 cmp %i0, 0
2003a2c: 02 80 00 06 be 2003a44 <IMFS_fifo_write+0x60> <== NEVER TAKEN
2003a30: 01 00 00 00 nop
2003a34: 40 00 37 89 call 2011858 <__errno>
2003a38: b0 20 00 18 neg %i0
2003a3c: f0 22 00 00 st %i0, [ %o0 ]
2003a40: b0 10 3f ff mov -1, %i0
}
2003a44: 81 c7 e0 08 ret
2003a48: 81 e8 00 00 restore
0200bb18 <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
)
{
200bb18: 9d e3 bf 80 save %sp, -128, %sp
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
200bb1c: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
200bb20: ba 07 bf e4 add %fp, -28, %i5
200bb24: 92 10 00 1c mov %i4, %o1
200bb28: 90 10 00 1d mov %i5, %o0
200bb2c: 40 00 11 ae call 20101e4 <memcpy>
200bb30: 94 10 20 1c mov 0x1c, %o2
jnode = (IMFS_jnode_t *)loc.node_access;
200bb34: f6 07 bf ec ld [ %fp + -20 ], %i3
200bb38: c0 27 20 08 clr [ %i4 + 8 ]
200bb3c: c2 06 e0 4c ld [ %i3 + 0x4c ], %g1
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
200bb40: f8 06 e0 08 ld [ %i3 + 8 ], %i4
200bb44: 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 ) ) {
200bb48: 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;
200bb4c: f6 27 bf ec st %i3, [ %fp + -20 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200bb50: 80 a0 60 00 cmp %g1, 0
200bb54: 12 80 00 07 bne 200bb70 <IMFS_fsunmount+0x58>
200bb58: c4 27 bf f4 st %g2, [ %fp + -12 ]
200bb5c: c4 06 e0 50 ld [ %i3 + 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 );
200bb60: 82 06 e0 54 add %i3, 0x54, %g1
200bb64: 80 a0 80 01 cmp %g2, %g1
200bb68: 12 80 00 0e bne 200bba0 <IMFS_fsunmount+0x88>
200bb6c: 80 a6 e0 00 cmp %i3, 0
result = IMFS_rmnod( NULL, &loc );
200bb70: 90 10 20 00 clr %o0
200bb74: 7f ff dd 95 call 20031c8 <IMFS_rmnod>
200bb78: 92 10 00 1d mov %i5, %o1
if ( result != 0 )
200bb7c: 80 a2 20 00 cmp %o0, 0
200bb80: 22 80 00 05 be,a 200bb94 <IMFS_fsunmount+0x7c> <== ALWAYS TAKEN
200bb84: 90 10 00 1b mov %i3, %o0
rtems_fatal_error_occurred( 0xdeadbeef );
200bb88: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
200bb8c: 7f ff f0 ff call 2007f88 <rtems_fatal_error_occurred> <== NOT EXECUTED
200bb90: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
IMFS_node_destroy( jnode );
200bb94: 7f ff dc b6 call 2002e6c <IMFS_node_destroy>
200bb98: b6 10 00 1c mov %i4, %i3
jnode = next;
}
if ( jnode != NULL ) {
200bb9c: 80 a6 e0 00 cmp %i3, 0
200bba0: 02 80 00 0e be 200bbd8 <IMFS_fsunmount+0xc0>
200bba4: 01 00 00 00 nop
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
200bba8: c2 06 e0 4c ld [ %i3 + 0x4c ], %g1
if ( IMFS_is_directory( jnode ) ) {
200bbac: c2 00 40 00 ld [ %g1 ], %g1
200bbb0: 80 a0 60 00 cmp %g1, 0
200bbb4: 32 bf ff e3 bne,a 200bb40 <IMFS_fsunmount+0x28> <== NEVER TAKEN
200bbb8: c2 06 e0 4c ld [ %i3 + 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;
200bbbc: c2 06 e0 50 ld [ %i3 + 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 );
200bbc0: 84 06 e0 54 add %i3, 0x54, %g2
if ( jnode_has_children( jnode ) )
200bbc4: 80 a0 40 02 cmp %g1, %g2
200bbc8: 02 bf ff dd be 200bb3c <IMFS_fsunmount+0x24>
200bbcc: 80 a0 60 00 cmp %g1, 0
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
200bbd0: 12 bf ff db bne 200bb3c <IMFS_fsunmount+0x24> <== ALWAYS TAKEN
200bbd4: b6 10 00 01 mov %g1, %i3
200bbd8: 81 c7 e0 08 ret
200bbdc: 81 e8 00 00 restore
02002d5c <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]
)
{
2002d5c: 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 ) );
2002d60: 90 10 20 01 mov 1, %o0
2002d64: 40 00 01 bd call 2003458 <calloc>
2002d68: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
2002d6c: ba 92 20 00 orcc %o0, 0, %i5
2002d70: 02 80 00 26 be 2002e08 <IMFS_initialize_support+0xac>
2002d74: 03 00 80 75 sethi %hi(0x201d400), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
2002d78: c4 00 63 24 ld [ %g1 + 0x324 ], %g2 ! 201d724 <imfs_instance.6444>
memcpy(
2002d7c: 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++;
2002d80: c4 27 40 00 st %g2, [ %i5 ]
2002d84: 84 00 a0 01 inc %g2
memcpy(
2002d88: 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++;
2002d8c: c4 20 63 24 st %g2, [ %g1 + 0x324 ]
memcpy(
2002d90: 40 00 35 15 call 20101e4 <memcpy>
2002d94: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
2002d98: d2 07 60 08 ld [ %i5 + 8 ], %o1
2002d9c: 90 10 00 1d mov %i5, %o0
2002da0: 15 00 80 6c sethi %hi(0x201b000), %o2
2002da4: 96 10 20 00 clr %o3
2002da8: 94 12 a2 30 or %o2, 0x230, %o2
2002dac: 19 00 00 10 sethi %hi(0x4000), %o4
2002db0: 9a 10 20 00 clr %o5
2002db4: 40 00 22 6c call 200b764 <IMFS_allocate_node>
2002db8: 98 13 21 ed or %o4, 0x1ed, %o4
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
2002dbc: b8 92 20 00 orcc %o0, 0, %i4
2002dc0: 02 80 00 12 be 2002e08 <IMFS_initialize_support+0xac> <== NEVER TAKEN
2002dc4: 90 06 20 28 add %i0, 0x28, %o0
mt_entry->fs_info = fs_info;
2002dc8: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
2002dcc: 13 00 80 6e sethi %hi(0x201b800), %o1
2002dd0: 94 10 20 30 mov 0x30, %o2
2002dd4: 40 00 35 04 call 20101e4 <memcpy>
2002dd8: 92 12 63 1c or %o1, 0x31c, %o1
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;
2002ddc: c4 07 20 4c ld [ %i4 + 0x4c ], %g2
mt_entry->mt_fs_root->location.node_access = root_node;
2002de0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2002de4: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2002de8: f8 20 60 08 st %i4, [ %g1 + 8 ]
2002dec: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
mt_entry->mt_fs_root->location.ops = op_table;
2002df0: f2 20 60 14 st %i1, [ %g1 + 0x14 ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002df4: 86 10 20 06 mov 6, %g3
2002df8: 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) {
2002dfc: 84 10 20 10 mov 0x10, %g2
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002e00: 10 80 00 08 b 2002e20 <IMFS_initialize_support+0xc4>
2002e04: c2 00 63 58 ld [ %g1 + 0x358 ], %g1
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
2002e08: 40 00 32 9b call 200f874 <__errno>
2002e0c: b0 10 3f ff mov -1, %i0
2002e10: 82 10 20 0c mov 0xc, %g1
2002e14: c2 22 00 00 st %g1, [ %o0 ]
2002e18: 81 c7 e0 08 ret
2002e1c: 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) {
2002e20: 80 a0 80 01 cmp %g2, %g1
2002e24: 22 80 00 09 be,a 2002e48 <IMFS_initialize_support+0xec>
2002e28: 05 00 80 75 sethi %hi(0x201d400), %g2
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
2002e2c: 34 80 00 06 bg,a 2002e44 <IMFS_initialize_support+0xe8>
2002e30: 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) {
2002e34: 86 80 ff ff addcc %g3, -1, %g3
2002e38: 12 bf ff fa bne 2002e20 <IMFS_initialize_support+0xc4> <== ALWAYS TAKEN
2002e3c: 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);
2002e40: 82 10 20 80 mov 0x80, %g1 <== NOT EXECUTED
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
2002e44: 05 00 80 75 sethi %hi(0x201d400), %g2
2002e48: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] ! 201d720 <imfs_memfile_bytes_per_block>
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
2002e4c: 81 c7 e0 08 ret
2002e50: 91 e8 20 00 restore %g0, 0, %o0
020047e8 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
20047e8: 9d e3 bf 40 save %sp, -192, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
20047ec: 03 00 80 84 sethi %hi(0x2021000), %g1
20047f0: c2 00 62 ec ld [ %g1 + 0x2ec ], %g1 ! 20212ec <rtems_current_user_env>
switch (mode & S_IFMT) {
20047f4: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
20047f8: c2 00 60 08 ld [ %g1 + 8 ], %g1
20047fc: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
2004800: 03 00 00 3c sethi %hi(0xf000), %g1
2004804: 82 0e 40 01 and %i1, %g1, %g1
2004808: 80 a0 40 02 cmp %g1, %g2
200480c: 02 80 00 13 be 2004858 <IMFS_make_generic_node+0x70>
2004810: 92 10 00 18 mov %i0, %o1
2004814: 80 a0 40 02 cmp %g1, %g2
2004818: 38 80 00 04 bgu,a 2004828 <IMFS_make_generic_node+0x40> <== ALWAYS TAKEN
200481c: 05 00 00 18 sethi %hi(0x6000), %g2
2004820: 10 80 00 05 b 2004834 <IMFS_make_generic_node+0x4c> <== NOT EXECUTED
2004824: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
2004828: 80 a0 40 02 cmp %g1, %g2
200482c: 02 80 00 0b be 2004858 <IMFS_make_generic_node+0x70>
2004830: 05 00 00 20 sethi %hi(0x8000), %g2
2004834: 80 a0 40 02 cmp %g1, %g2
2004838: 22 80 00 09 be,a 200485c <IMFS_make_generic_node+0x74> <== NEVER TAKEN
200483c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
case S_IFCHR:
case S_IFIFO:
case S_IFREG:
break;
default:
errno = EINVAL;
2004840: 40 00 3d 1e call 2013cb8 <__errno>
2004844: b0 10 3f ff mov -1, %i0
2004848: 82 10 20 16 mov 0x16, %g1
200484c: c2 22 00 00 st %g1, [ %o0 ]
2004850: 81 c7 e0 08 ret
2004854: 81 e8 00 00 restore
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
2004858: c2 06 80 00 ld [ %i2 ], %g1
200485c: 80 a0 60 07 cmp %g1, 7
2004860: 12 80 00 28 bne 2004900 <IMFS_make_generic_node+0x118>
2004864: 94 10 20 78 mov 0x78, %o2
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 =
2004868: 40 00 08 d5 call 2006bbc <rtems_filesystem_eval_path_start>
200486c: 90 07 bf a4 add %fp, -92, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
2004870: 7f ff ff cc call 20047a0 <IMFS_is_imfs_instance>
2004874: ba 10 00 08 mov %o0, %i5
2004878: 80 8a 20 ff btst 0xff, %o0
200487c: 02 80 00 1a be 20048e4 <IMFS_make_generic_node+0xfc>
2004880: 90 07 bf a4 add %fp, -92, %o0
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
new_node = IMFS_create_node_with_control(
2004884: d4 07 bf ac ld [ %fp + -84 ], %o2
2004888: d6 07 bf b0 ld [ %fp + -80 ], %o3
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
200488c: f6 27 bf e0 st %i3, [ %fp + -32 ]
new_node = IMFS_create_node_with_control(
2004890: 90 10 00 1d mov %i5, %o0
2004894: 92 10 00 1a mov %i2, %o1
2004898: 98 10 00 19 mov %i1, %o4
200489c: 9a 07 bf e0 add %fp, -32, %o5
20048a0: 40 00 2c d5 call 200fbf4 <IMFS_create_node_with_control>
20048a4: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
20048a8: 80 a2 20 00 cmp %o0, 0
20048ac: 02 80 00 11 be 20048f0 <IMFS_make_generic_node+0x108>
20048b0: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
20048b4: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
20048b8: 40 00 02 97 call 2005314 <gettimeofday>
20048bc: 90 07 bf f8 add %fp, -8, %o0
20048c0: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime( parent );
20048c4: 90 07 bf f8 add %fp, -8, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
20048c8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
20048cc: 40 00 02 92 call 2005314 <gettimeofday>
20048d0: 92 10 20 00 clr %o1
20048d4: c2 07 bf f8 ld [ %fp + -8 ], %g1
20048d8: b0 10 20 00 clr %i0
20048dc: 10 80 00 05 b 20048f0 <IMFS_make_generic_node+0x108>
20048e0: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
20048e4: 92 10 20 86 mov 0x86, %o1
20048e8: 40 00 08 02 call 20068f0 <rtems_filesystem_eval_path_error>
20048ec: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
20048f0: 40 00 08 b9 call 2006bd4 <rtems_filesystem_eval_path_cleanup>
20048f4: 90 07 bf a4 add %fp, -92, %o0
20048f8: 81 c7 e0 08 ret
20048fc: 81 e8 00 00 restore
} else {
errno = EINVAL;
2004900: 40 00 3c ee call 2013cb8 <__errno>
2004904: b0 10 3f ff mov -1, %i0
2004908: 82 10 20 16 mov 0x16, %g1
200490c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
}
return rv;
}
2004910: 81 c7 e0 08 ret
2004914: 81 e8 00 00 restore
0200e5e8 <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
200e5e8: 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 )
200e5ec: 03 00 80 75 sethi %hi(0x201d400), %g1
200e5f0: fa 00 63 20 ld [ %g1 + 0x320 ], %i5 ! 201d720 <imfs_memfile_bytes_per_block>
200e5f4: b9 37 60 02 srl %i5, 2, %i4
200e5f8: 92 10 00 1c mov %i4, %o1
200e5fc: 40 00 28 4c call 201872c <.umul>
200e600: 90 07 20 01 add %i4, 1, %o0
200e604: 92 10 00 1c mov %i4, %o1
200e608: 40 00 28 49 call 201872c <.umul>
200e60c: 90 02 20 01 inc %o0
200e610: 92 10 00 1d mov %i5, %o1
200e614: 40 00 28 46 call 201872c <.umul>
200e618: 90 02 3f ff add %o0, -1, %o0
200e61c: 82 10 20 00 clr %g1
200e620: 80 a0 40 19 cmp %g1, %i1
200e624: 34 80 00 0b bg,a 200e650 <IMFS_memfile_extend+0x68> <== NEVER TAKEN
200e628: f8 06 20 50 ld [ %i0 + 0x50 ], %i4 <== NOT EXECUTED
200e62c: 80 a0 40 19 cmp %g1, %i1
200e630: 12 80 00 04 bne 200e640 <IMFS_memfile_extend+0x58>
200e634: 80 a2 00 1a cmp %o0, %i2
200e638: 38 80 00 06 bgu,a 200e650 <IMFS_memfile_extend+0x68>
200e63c: f8 06 20 50 ld [ %i0 + 0x50 ], %i4
rtems_set_errno_and_return_minus_one( EINVAL );
200e640: 40 00 04 8d call 200f874 <__errno>
200e644: 01 00 00 00 nop
200e648: 10 80 00 29 b 200e6ec <IMFS_memfile_extend+0x104>
200e64c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
200e650: 80 a6 40 1c cmp %i1, %i4
200e654: 14 80 00 07 bg 200e670 <IMFS_memfile_extend+0x88> <== NEVER TAKEN
200e658: e0 06 20 54 ld [ %i0 + 0x54 ], %l0
200e65c: 80 a6 40 1c cmp %i1, %i4
200e660: 12 80 00 37 bne 200e73c <IMFS_memfile_extend+0x154> <== NEVER TAKEN
200e664: 80 a6 80 10 cmp %i2, %l0
200e668: 08 80 00 35 bleu 200e73c <IMFS_memfile_extend+0x154>
200e66c: 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;
200e670: b7 3f 60 1f sra %i5, 0x1f, %i3
200e674: 96 10 00 1d mov %i5, %o3
200e678: 94 10 00 1b mov %i3, %o2
200e67c: 90 10 00 19 mov %i1, %o0
200e680: 40 00 29 bd call 2018d74 <__divdi3>
200e684: 92 10 00 1a mov %i2, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e688: 90 10 00 1c mov %i4, %o0
200e68c: 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;
200e690: a2 10 00 09 mov %o1, %l1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e694: 94 10 00 1b mov %i3, %o2
200e698: 40 00 29 b7 call 2018d74 <__divdi3>
200e69c: 92 10 00 10 mov %l0, %o1
200e6a0: b8 10 00 09 mov %o1, %i4
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e6a4: 10 80 00 15 b 200e6f8 <IMFS_memfile_extend+0x110>
200e6a8: ba 10 00 09 mov %o1, %i5
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
200e6ac: 7f ff ff 49 call 200e3d0 <IMFS_memfile_addblock>
200e6b0: 92 10 00 1d mov %i5, %o1
200e6b4: 80 a2 20 00 cmp %o0, 0
200e6b8: 22 80 00 10 be,a 200e6f8 <IMFS_memfile_extend+0x110>
200e6bc: ba 07 60 01 inc %i5
for ( ; block>=old_blocks ; block-- ) {
200e6c0: 10 80 00 06 b 200e6d8 <IMFS_memfile_extend+0xf0>
200e6c4: 80 a7 40 1c cmp %i5, %i4
IMFS_memfile_remove_block( the_jnode, block );
200e6c8: 90 10 00 18 mov %i0, %o0
200e6cc: 7f ff ff bb call 200e5b8 <IMFS_memfile_remove_block>
200e6d0: ba 07 7f ff add %i5, -1, %i5
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
200e6d4: 80 a7 40 1c cmp %i5, %i4
200e6d8: 1a bf ff fc bcc 200e6c8 <IMFS_memfile_extend+0xe0>
200e6dc: 92 10 00 1d mov %i5, %o1
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
200e6e0: 40 00 04 65 call 200f874 <__errno>
200e6e4: 01 00 00 00 nop
200e6e8: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
200e6ec: c2 22 00 00 st %g1, [ %o0 ]
200e6f0: 81 c7 e0 08 ret
200e6f4: 91 e8 3f ff restore %g0, -1, %o0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e6f8: 80 a7 40 11 cmp %i5, %l1
200e6fc: 08 bf ff ec bleu 200e6ac <IMFS_memfile_extend+0xc4>
200e700: 90 10 00 18 mov %i0, %o0
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
200e704: f2 26 20 50 st %i1, [ %i0 + 0x50 ]
200e708: f4 26 20 54 st %i2, [ %i0 + 0x54 ]
IMFS_update_ctime(the_jnode);
200e70c: 92 10 20 00 clr %o1
200e710: 7f ff d4 2a call 20037b8 <gettimeofday>
200e714: 90 07 bf f8 add %fp, -8, %o0
200e718: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
200e71c: 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);
200e720: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
IMFS_update_mtime(the_jnode);
200e724: 7f ff d4 25 call 20037b8 <gettimeofday>
200e728: 92 10 20 00 clr %o1
200e72c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e730: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
return 0;
200e734: 81 c7 e0 08 ret
200e738: 91 e8 20 00 restore %g0, 0, %o0
}
200e73c: 81 c7 e0 08 ret
200e740: 91 e8 20 00 restore %g0, 0, %o0
0200df40 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
200df40: 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 ) {
200df44: 03 00 80 75 sethi %hi(0x201d400), %g1
200df48: f8 00 63 20 ld [ %g1 + 0x320 ], %i4 ! 201d720 <imfs_memfile_bytes_per_block>
200df4c: b9 37 20 02 srl %i4, 2, %i4
200df50: 82 07 3f ff add %i4, -1, %g1
200df54: 80 a6 40 01 cmp %i1, %g1
200df58: 18 80 00 18 bgu 200dfb8 <IMFS_memfile_get_block_pointer+0x78>
200df5c: ba 10 00 18 mov %i0, %i5
p = info->indirect;
if ( malloc_it ) {
200df60: 80 a6 a0 00 cmp %i2, 0
200df64: 02 80 00 0f be 200dfa0 <IMFS_memfile_get_block_pointer+0x60>
200df68: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
if ( !p ) {
200df6c: 80 a0 60 00 cmp %g1, 0
200df70: 32 80 00 09 bne,a 200df94 <IMFS_memfile_get_block_pointer+0x54>
200df74: f0 07 60 58 ld [ %i5 + 0x58 ], %i0
p = memfile_alloc_block();
200df78: 7f ff ff e5 call 200df0c <memfile_alloc_block>
200df7c: b0 10 20 00 clr %i0
if ( !p )
200df80: 80 a2 20 00 cmp %o0, 0
200df84: 02 80 00 8a be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200df88: 01 00 00 00 nop
return 0;
info->indirect = p;
200df8c: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
}
return &info->indirect[ my_block ];
200df90: f0 07 60 58 ld [ %i5 + 0x58 ], %i0
200df94: b3 2e 60 02 sll %i1, 2, %i1
200df98: 81 c7 e0 08 ret
200df9c: 91 ee 00 19 restore %i0, %i1, %o0
}
if ( !p )
200dfa0: 80 a0 60 00 cmp %g1, 0
200dfa4: 02 80 00 82 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200dfa8: b0 10 20 00 clr %i0
return 0;
return &info->indirect[ my_block ];
200dfac: b3 2e 60 02 sll %i1, 2, %i1
200dfb0: 81 c7 e0 08 ret
200dfb4: 91 e8 40 19 restore %g1, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
200dfb8: 90 07 20 01 add %i4, 1, %o0
200dfbc: 40 00 29 dc call 201872c <.umul>
200dfc0: 92 10 00 1c mov %i4, %o1
200dfc4: 82 02 3f ff add %o0, -1, %g1
200dfc8: 80 a6 40 01 cmp %i1, %g1
200dfcc: 18 80 00 2f bgu 200e088 <IMFS_memfile_get_block_pointer+0x148>
200dfd0: b6 10 00 08 mov %o0, %i3
my_block -= FIRST_DOUBLY_INDIRECT;
200dfd4: b2 26 40 1c sub %i1, %i4, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200dfd8: 92 10 00 1c mov %i4, %o1
200dfdc: 40 00 2a ba call 2018ac4 <.urem>
200dfe0: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dfe4: 92 10 00 1c mov %i4, %o1
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200dfe8: b6 10 00 08 mov %o0, %i3
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dfec: 40 00 2a 0a call 2018814 <.udiv>
200dff0: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
if ( malloc_it ) {
200dff4: 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;
200dff8: b8 10 00 08 mov %o0, %i4
p = info->doubly_indirect;
if ( malloc_it ) {
200dffc: 02 80 00 18 be 200e05c <IMFS_memfile_get_block_pointer+0x11c>
200e000: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !p ) {
200e004: 80 a2 20 00 cmp %o0, 0
200e008: 32 80 00 08 bne,a 200e028 <IMFS_memfile_get_block_pointer+0xe8>
200e00c: b9 2f 20 02 sll %i4, 2, %i4
p = memfile_alloc_block();
200e010: 7f ff ff bf call 200df0c <memfile_alloc_block>
200e014: b0 10 20 00 clr %i0
if ( !p )
200e018: 80 a2 20 00 cmp %o0, 0
200e01c: 02 80 00 64 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e020: b9 2f 20 02 sll %i4, 2, %i4
return 0;
info->doubly_indirect = p;
200e024: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
}
p1 = (block_p *)p[ doubly ];
200e028: ba 02 00 1c add %o0, %i4, %i5
200e02c: d0 02 00 1c ld [ %o0 + %i4 ], %o0
if ( !p1 ) {
200e030: 80 a2 20 00 cmp %o0, 0
200e034: 12 80 00 4f bne 200e170 <IMFS_memfile_get_block_pointer+0x230>
200e038: b1 2e e0 02 sll %i3, 2, %i0
p1 = memfile_alloc_block();
200e03c: 7f ff ff b4 call 200df0c <memfile_alloc_block>
200e040: b0 10 20 00 clr %i0
if ( !p1 )
200e044: 80 a2 20 00 cmp %o0, 0
200e048: 02 80 00 59 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e04c: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
200e050: d0 27 40 00 st %o0, [ %i5 ]
}
return (block_p *)&p1[ singly ];
200e054: 10 80 00 47 b 200e170 <IMFS_memfile_get_block_pointer+0x230>
200e058: b1 2e e0 02 sll %i3, 2, %i0
}
if ( !p )
200e05c: 80 a2 20 00 cmp %o0, 0
200e060: 02 80 00 53 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e064: b0 10 20 00 clr %i0
return 0;
p = (block_p *)p[ doubly ];
200e068: b9 2f 20 02 sll %i4, 2, %i4
200e06c: c2 02 00 1c ld [ %o0 + %i4 ], %g1
if ( !p )
200e070: 80 a0 60 00 cmp %g1, 0
200e074: 02 80 00 4e be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e078: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
200e07c: b1 2e e0 02 sll %i3, 2, %i0
200e080: 81 c7 e0 08 ret
200e084: 91 e8 40 18 restore %g1, %i0, %o0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
200e088: 90 02 20 01 inc %o0
200e08c: 40 00 29 a8 call 201872c <.umul>
200e090: 92 10 00 1c mov %i4, %o1
200e094: 90 02 3f ff add %o0, -1, %o0
200e098: 80 a6 40 08 cmp %i1, %o0
200e09c: 18 80 00 44 bgu 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e0a0: b0 10 20 00 clr %i0
my_block -= FIRST_TRIPLY_INDIRECT;
200e0a4: b2 26 40 1b sub %i1, %i3, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200e0a8: 92 10 00 1c mov %i4, %o1
200e0ac: 40 00 2a 86 call 2018ac4 <.urem>
200e0b0: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e0b4: 92 10 00 1c mov %i4, %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;
200e0b8: a0 10 00 08 mov %o0, %l0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e0bc: 40 00 29 d6 call 2018814 <.udiv>
200e0c0: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
200e0c4: 92 10 00 1c mov %i4, %o1
200e0c8: 40 00 29 d3 call 2018814 <.udiv>
200e0cc: b2 10 00 08 mov %o0, %i1
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e0d0: 92 10 00 1c mov %i4, %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;
200e0d4: b6 10 00 08 mov %o0, %i3
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e0d8: 40 00 2a 7b call 2018ac4 <.urem>
200e0dc: 90 10 00 19 mov %i1, %o0
p = info->triply_indirect;
if ( malloc_it ) {
200e0e0: 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;
200e0e4: b8 10 00 08 mov %o0, %i4
p = info->triply_indirect;
if ( malloc_it ) {
200e0e8: 02 80 00 24 be 200e178 <IMFS_memfile_get_block_pointer+0x238>
200e0ec: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
if ( !p ) {
200e0f0: 80 a2 20 00 cmp %o0, 0
200e0f4: 12 80 00 08 bne 200e114 <IMFS_memfile_get_block_pointer+0x1d4>
200e0f8: b7 2e e0 02 sll %i3, 2, %i3
p = memfile_alloc_block();
200e0fc: 7f ff ff 84 call 200df0c <memfile_alloc_block>
200e100: 01 00 00 00 nop
if ( !p )
200e104: 80 a2 20 00 cmp %o0, 0
200e108: 02 80 00 29 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e10c: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
200e110: d0 27 60 60 st %o0, [ %i5 + 0x60 ]
}
p1 = (block_p *) p[ triply ];
200e114: ba 02 00 1b add %o0, %i3, %i5
200e118: d0 02 00 1b ld [ %o0 + %i3 ], %o0
if ( !p1 ) {
200e11c: 80 a2 20 00 cmp %o0, 0
200e120: 32 80 00 08 bne,a 200e140 <IMFS_memfile_get_block_pointer+0x200>
200e124: b9 2f 20 02 sll %i4, 2, %i4
p1 = memfile_alloc_block();
200e128: 7f ff ff 79 call 200df0c <memfile_alloc_block>
200e12c: b0 10 20 00 clr %i0
if ( !p1 )
200e130: 80 a2 20 00 cmp %o0, 0
200e134: 02 80 00 1e be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e138: b9 2f 20 02 sll %i4, 2, %i4
return 0;
p[ triply ] = (block_p) p1;
200e13c: d0 27 40 00 st %o0, [ %i5 ]
}
p2 = (block_p *)p1[ doubly ];
200e140: ba 02 00 1c add %o0, %i4, %i5
200e144: d0 02 00 1c ld [ %o0 + %i4 ], %o0
if ( !p2 ) {
200e148: 80 a2 20 00 cmp %o0, 0
200e14c: 12 80 00 09 bne 200e170 <IMFS_memfile_get_block_pointer+0x230>
200e150: b1 2c 20 02 sll %l0, 2, %i0
p2 = memfile_alloc_block();
200e154: 7f ff ff 6e call 200df0c <memfile_alloc_block>
200e158: b0 10 20 00 clr %i0
if ( !p2 )
200e15c: 80 a2 20 00 cmp %o0, 0
200e160: 02 80 00 13 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e164: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
200e168: d0 27 40 00 st %o0, [ %i5 ]
}
return (block_p *)&p2[ singly ];
200e16c: b1 2c 20 02 sll %l0, 2, %i0
200e170: 81 c7 e0 08 ret
200e174: 91 ea 00 18 restore %o0, %i0, %o0
}
if ( !p )
200e178: 80 a2 20 00 cmp %o0, 0
200e17c: 02 80 00 0c be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e180: b7 2e e0 02 sll %i3, 2, %i3
return 0;
p1 = (block_p *) p[ triply ];
200e184: c2 02 00 1b ld [ %o0 + %i3 ], %g1
if ( !p1 )
200e188: 80 a0 60 00 cmp %g1, 0
200e18c: 02 80 00 08 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e190: b9 2f 20 02 sll %i4, 2, %i4
return 0;
p2 = (block_p *)p1[ doubly ];
200e194: c2 00 40 1c ld [ %g1 + %i4 ], %g1
if ( !p2 )
200e198: 80 a0 60 00 cmp %g1, 0
200e19c: 02 80 00 04 be 200e1ac <IMFS_memfile_get_block_pointer+0x26c><== NEVER TAKEN
200e1a0: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
200e1a4: b1 2c 20 02 sll %l0, 2, %i0
200e1a8: b0 00 40 18 add %g1, %i0, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
200e1ac: 81 c7 e0 08 ret
200e1b0: 81 e8 00 00 restore
0200e1b4 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200e1b4: 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;
200e1b8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
200e1bc: 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 ) {
200e1c0: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200e1c4: a0 10 00 19 mov %i1, %l0
* 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 ) {
200e1c8: 80 a0 60 05 cmp %g1, 5
200e1cc: 12 80 00 1c bne 200e23c <IMFS_memfile_read+0x88>
200e1d0: a2 10 00 1a mov %i2, %l1
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
200e1d4: d8 1e 20 50 ldd [ %i0 + 0x50 ], %o4
200e1d8: 82 10 20 00 clr %g1
200e1dc: 86 a3 40 1a subcc %o5, %i2, %g3
200e1e0: 84 63 00 19 subx %o4, %i1, %g2
200e1e4: 80 a0 40 02 cmp %g1, %g2
200e1e8: 14 80 00 07 bg 200e204 <IMFS_memfile_read+0x50> <== NEVER TAKEN
200e1ec: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
200e1f0: 80 a0 40 02 cmp %g1, %g2
200e1f4: 12 80 00 06 bne 200e20c <IMFS_memfile_read+0x58> <== NEVER TAKEN
200e1f8: 80 a7 00 03 cmp %i4, %g3
200e1fc: 28 80 00 05 bleu,a 200e210 <IMFS_memfile_read+0x5c> <== NEVER TAKEN
200e200: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
200e204: 10 80 00 03 b 200e210 <IMFS_memfile_read+0x5c>
200e208: b0 23 40 11 sub %o5, %l1, %i0
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
200e20c: 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);
200e210: 92 02 40 11 add %o1, %l1, %o1
200e214: 94 10 00 18 mov %i0, %o2
200e218: 40 00 07 f3 call 20101e4 <memcpy>
200e21c: 90 10 00 1b mov %i3, %o0
IMFS_update_atime( the_jnode );
200e220: 90 07 bf f8 add %fp, -8, %o0
200e224: 7f ff d5 65 call 20037b8 <gettimeofday>
200e228: 92 10 20 00 clr %o1
200e22c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e230: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return my_length;
200e234: 81 c7 e0 08 ret
200e238: 81 e8 00 00 restore
/*
* 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 )
200e23c: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
/*
* 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;
200e240: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
200e244: 88 10 20 00 clr %g4
200e248: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
200e24c: 80 a1 00 03 cmp %g4, %g3
200e250: 14 80 00 08 bg 200e270 <IMFS_memfile_read+0xbc> <== NEVER TAKEN
200e254: b4 07 00 1a add %i4, %i2, %i2
200e258: 80 a1 00 03 cmp %g4, %g3
200e25c: 32 80 00 07 bne,a 200e278 <IMFS_memfile_read+0xc4> <== NEVER TAKEN
200e260: 03 00 80 75 sethi %hi(0x201d400), %g1 <== NOT EXECUTED
200e264: 80 a6 80 02 cmp %i2, %g2
200e268: 28 80 00 04 bleu,a 200e278 <IMFS_memfile_read+0xc4>
200e26c: 03 00 80 75 sethi %hi(0x201d400), %g1
my_length = the_jnode->info.file.size - start;
200e270: 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;
200e274: 03 00 80 75 sethi %hi(0x201d400), %g1
200e278: f4 00 63 20 ld [ %g1 + 0x320 ], %i2 ! 201d720 <imfs_memfile_bytes_per_block>
200e27c: 90 10 00 10 mov %l0, %o0
200e280: b1 3e a0 1f sra %i2, 0x1f, %i0
200e284: 92 10 00 11 mov %l1, %o1
200e288: 94 10 00 18 mov %i0, %o2
200e28c: 40 00 2b a0 call 201910c <__moddi3>
200e290: 96 10 00 1a mov %i2, %o3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e294: 90 10 00 10 mov %l0, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e298: b2 10 00 09 mov %o1, %i1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e29c: 94 10 00 18 mov %i0, %o2
200e2a0: 92 10 00 11 mov %l1, %o1
200e2a4: 40 00 2a b4 call 2018d74 <__divdi3>
200e2a8: 96 10 00 1a mov %i2, %o3
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
200e2ac: a2 10 00 1b mov %i3, %l1
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e2b0: a0 10 00 09 mov %o1, %l0
if ( start_offset ) {
200e2b4: 80 a6 60 00 cmp %i1, 0
200e2b8: 02 80 00 14 be 200e308 <IMFS_memfile_read+0x154>
200e2bc: b0 10 20 00 clr %i0
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e2c0: 90 10 00 1d mov %i5, %o0
200e2c4: 7f ff ff 1f call 200df40 <IMFS_memfile_get_block_pointer>
200e2c8: 94 10 20 00 clr %o2
if ( !block_ptr )
200e2cc: 80 a2 20 00 cmp %o0, 0
200e2d0: 02 bf ff d9 be 200e234 <IMFS_memfile_read+0x80> <== NEVER TAKEN
200e2d4: b4 26 80 19 sub %i2, %i1, %i2
* 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;
200e2d8: 80 a7 00 1a cmp %i4, %i2
200e2dc: 08 80 00 03 bleu 200e2e8 <IMFS_memfile_read+0x134>
200e2e0: b0 10 00 1c mov %i4, %i0
200e2e4: b0 10 00 1a mov %i2, %i0
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
200e2e8: d2 02 00 00 ld [ %o0 ], %o1
200e2ec: 94 10 00 18 mov %i0, %o2
200e2f0: 90 10 00 1b mov %i3, %o0
200e2f4: 92 02 40 19 add %o1, %i1, %o1
200e2f8: 40 00 07 bb call 20101e4 <memcpy>
200e2fc: a2 06 c0 18 add %i3, %i0, %l1
dest += to_copy;
block++;
200e300: a0 04 20 01 inc %l0
my_length -= to_copy;
200e304: b8 27 00 18 sub %i4, %i0, %i4
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e308: 35 00 80 75 sethi %hi(0x201d400), %i2
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e30c: 10 80 00 0f b 200e348 <IMFS_memfile_read+0x194>
200e310: f6 06 a3 20 ld [ %i2 + 0x320 ], %i3 ! 201d720 <imfs_memfile_bytes_per_block>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e314: 92 10 00 10 mov %l0, %o1
200e318: 7f ff ff 0a call 200df40 <IMFS_memfile_get_block_pointer>
200e31c: 94 10 20 00 clr %o2
if ( !block_ptr )
200e320: 82 92 20 00 orcc %o0, 0, %g1
200e324: 02 bf ff c4 be 200e234 <IMFS_memfile_read+0x80> <== NEVER TAKEN
200e328: 90 10 00 11 mov %l1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
200e32c: d2 00 40 00 ld [ %g1 ], %o1
200e330: 94 10 00 1b mov %i3, %o2
200e334: 40 00 07 ac call 20101e4 <memcpy>
200e338: a2 04 40 1b add %l1, %i3, %l1
dest += to_copy;
block++;
200e33c: a0 04 20 01 inc %l0
my_length -= to_copy;
200e340: b8 27 00 1b sub %i4, %i3, %i4
copied += to_copy;
200e344: 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 ) {
200e348: c2 06 a3 20 ld [ %i2 + 0x320 ], %g1
200e34c: 80 a7 00 01 cmp %i4, %g1
200e350: 1a bf ff f1 bcc 200e314 <IMFS_memfile_read+0x160>
200e354: 90 10 00 1d mov %i5, %o0
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
200e358: 80 a7 20 00 cmp %i4, 0
200e35c: 02 80 00 0e be 200e394 <IMFS_memfile_read+0x1e0>
200e360: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e364: 90 10 00 1d mov %i5, %o0
200e368: 92 10 00 10 mov %l0, %o1
200e36c: 7f ff fe f5 call 200df40 <IMFS_memfile_get_block_pointer>
200e370: 94 10 20 00 clr %o2
if ( !block_ptr )
200e374: 82 92 20 00 orcc %o0, 0, %g1
200e378: 02 bf ff af be 200e234 <IMFS_memfile_read+0x80> <== NEVER TAKEN
200e37c: 90 10 00 11 mov %l1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
200e380: d2 00 40 00 ld [ %g1 ], %o1
200e384: 94 10 00 1c mov %i4, %o2
200e388: 40 00 07 97 call 20101e4 <memcpy>
200e38c: b0 07 00 18 add %i4, %i0, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
200e390: 90 07 bf f8 add %fp, -8, %o0
200e394: 7f ff d5 09 call 20037b8 <gettimeofday>
200e398: 92 10 20 00 clr %o1
200e39c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e3a0: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return copied;
}
200e3a4: 81 c7 e0 08 ret
200e3a8: 81 e8 00 00 restore
0200e48c <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
200e48c: 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;
200e490: 03 00 80 75 sethi %hi(0x201d400), %g1
200e494: fa 00 63 20 ld [ %g1 + 0x320 ], %i5 ! 201d720 <imfs_memfile_bytes_per_block>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
200e498: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
200e49c: 80 a0 60 00 cmp %g1, 0
200e4a0: 02 80 00 05 be 200e4b4 <IMFS_memfile_remove+0x28>
200e4a4: bb 37 60 02 srl %i5, 2, %i5
memfile_free_blocks_in_table( &info->indirect, to_free );
200e4a8: 90 06 20 58 add %i0, 0x58, %o0
200e4ac: 7f ff ff e5 call 200e440 <memfile_free_blocks_in_table>
200e4b0: 92 10 00 1d mov %i5, %o1
}
if ( info->doubly_indirect ) {
200e4b4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200e4b8: b8 10 20 00 clr %i4
200e4bc: 80 a0 60 00 cmp %g1, 0
200e4c0: 12 80 00 0d bne 200e4f4 <IMFS_memfile_remove+0x68>
200e4c4: 37 00 80 75 sethi %hi(0x201d400), %i3
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
200e4c8: 10 80 00 15 b 200e51c <IMFS_memfile_remove+0x90>
200e4cc: 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(
200e4d0: 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] ) {
200e4d4: 90 00 80 01 add %g2, %g1, %o0
200e4d8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200e4dc: 80 a0 60 00 cmp %g1, 0
200e4e0: 22 80 00 05 be,a 200e4f4 <IMFS_memfile_remove+0x68> <== NEVER TAKEN
200e4e4: b8 07 20 01 inc %i4 <== NOT EXECUTED
memfile_free_blocks_in_table(
200e4e8: 7f ff ff d6 call 200e440 <memfile_free_blocks_in_table>
200e4ec: 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++ ) {
200e4f0: b8 07 20 01 inc %i4
200e4f4: c2 06 e3 20 ld [ %i3 + 0x320 ], %g1
200e4f8: 83 30 60 02 srl %g1, 2, %g1
200e4fc: 80 a7 00 01 cmp %i4, %g1
200e500: 2a bf ff f4 bcs,a 200e4d0 <IMFS_memfile_remove+0x44>
200e504: 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 );
200e508: 90 06 20 5c add %i0, 0x5c, %o0
200e50c: 7f ff ff cd call 200e440 <memfile_free_blocks_in_table>
200e510: 92 10 00 1d mov %i5, %o1
}
if ( info->triply_indirect ) {
200e514: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
200e518: b8 10 20 00 clr %i4
200e51c: 80 a0 60 00 cmp %g1, 0
200e520: 12 80 00 1c bne 200e590 <IMFS_memfile_remove+0x104>
200e524: 33 00 80 75 sethi %hi(0x201d400), %i1
200e528: 81 c7 e0 08 ret
200e52c: 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(
200e530: 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];
200e534: f6 00 40 10 ld [ %g1 + %l0 ], %i3
if ( !p ) /* ensure we have a valid pointer */
200e538: 80 a6 e0 00 cmp %i3, 0
200e53c: 02 80 00 1b be 200e5a8 <IMFS_memfile_remove+0x11c> <== NEVER TAKEN
200e540: 90 06 20 60 add %i0, 0x60, %o0
200e544: 10 80 00 09 b 200e568 <IMFS_memfile_remove+0xdc>
200e548: b4 10 20 00 clr %i2
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
200e54c: 80 a0 60 00 cmp %g1, 0
200e550: 02 80 00 04 be 200e560 <IMFS_memfile_remove+0xd4> <== NEVER TAKEN
200e554: 90 10 00 1b mov %i3, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
200e558: 7f ff ff ba call 200e440 <memfile_free_blocks_in_table>
200e55c: 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++ ) {
200e560: b4 06 a0 01 inc %i2
200e564: b6 06 e0 04 add %i3, 4, %i3
200e568: c2 06 63 20 ld [ %i1 + 0x320 ], %g1
200e56c: 83 30 60 02 srl %g1, 2, %g1
200e570: 80 a6 80 01 cmp %i2, %g1
200e574: 2a bf ff f6 bcs,a 200e54c <IMFS_memfile_remove+0xc0>
200e578: 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(
200e57c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
200e580: 92 10 00 1d mov %i5, %o1
200e584: 90 02 00 10 add %o0, %l0, %o0
200e588: 7f ff ff ae call 200e440 <memfile_free_blocks_in_table>
200e58c: 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++ ) {
200e590: c2 06 63 20 ld [ %i1 + 0x320 ], %g1
200e594: 83 30 60 02 srl %g1, 2, %g1
200e598: 80 a7 00 01 cmp %i4, %g1
200e59c: 2a bf ff e5 bcs,a 200e530 <IMFS_memfile_remove+0xa4>
200e5a0: 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(
200e5a4: 90 06 20 60 add %i0, 0x60, %o0
200e5a8: 7f ff ff a6 call 200e440 <memfile_free_blocks_in_table>
200e5ac: 92 10 00 1d mov %i5, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
200e5b0: 81 c7 e0 08 ret
200e5b4: 81 e8 00 00 restore
0200e744 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
200e744: 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 ) {
200e748: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
200e74c: ba 10 00 18 mov %i0, %i5
* 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 ) {
200e750: 80 a0 60 00 cmp %g1, 0
200e754: 06 80 00 09 bl 200e778 <IMFS_memfile_write+0x34> <== NEVER TAKEN
200e758: 94 07 00 1a add %i4, %i2, %o2
200e75c: 80 a0 60 00 cmp %g1, 0
200e760: 12 80 00 12 bne 200e7a8 <IMFS_memfile_write+0x64> <== NEVER TAKEN
200e764: 03 00 80 75 sethi %hi(0x201d400), %g1
200e768: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
200e76c: 80 a0 40 0a cmp %g1, %o2
200e770: 1a 80 00 0e bcc 200e7a8 <IMFS_memfile_write+0x64>
200e774: 03 00 80 75 sethi %hi(0x201d400), %g1
status = IMFS_memfile_extend( the_jnode, last_byte );
200e778: 90 10 00 1d mov %i5, %o0
200e77c: 7f ff ff 9b call 200e5e8 <IMFS_memfile_extend>
200e780: 92 10 20 00 clr %o1
if ( status )
200e784: 80 a2 20 00 cmp %o0, 0
200e788: 02 80 00 08 be 200e7a8 <IMFS_memfile_write+0x64>
200e78c: 03 00 80 75 sethi %hi(0x201d400), %g1
rtems_set_errno_and_return_minus_one( ENOSPC );
200e790: 40 00 04 39 call 200f874 <__errno>
200e794: b0 10 3f ff mov -1, %i0
200e798: 82 10 20 1c mov 0x1c, %g1
200e79c: c2 22 00 00 st %g1, [ %o0 ]
200e7a0: 81 c7 e0 08 ret
200e7a4: 81 e8 00 00 restore
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7a8: e0 00 63 20 ld [ %g1 + 0x320 ], %l0
200e7ac: 92 10 00 1a mov %i2, %o1
200e7b0: b1 3c 20 1f sra %l0, 0x1f, %i0
200e7b4: 96 10 00 10 mov %l0, %o3
200e7b8: 94 10 00 18 mov %i0, %o2
200e7bc: 40 00 2a 54 call 201910c <__moddi3>
200e7c0: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7c4: 94 10 00 18 mov %i0, %o2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7c8: a2 10 00 09 mov %o1, %l1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7cc: 90 10 00 19 mov %i1, %o0
200e7d0: 92 10 00 1a mov %i2, %o1
200e7d4: 40 00 29 68 call 2018d74 <__divdi3>
200e7d8: 96 10 00 10 mov %l0, %o3
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
200e7dc: b0 10 20 00 clr %i0
/*
* 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 ) {
200e7e0: 80 a4 60 00 cmp %l1, 0
200e7e4: 02 80 00 14 be 200e834 <IMFS_memfile_write+0xf0>
200e7e8: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e7ec: 90 10 00 1d mov %i5, %o0
200e7f0: 7f ff fd d4 call 200df40 <IMFS_memfile_get_block_pointer>
200e7f4: 94 10 20 00 clr %o2
if ( !block_ptr )
200e7f8: 80 a2 20 00 cmp %o0, 0
200e7fc: 02 80 00 36 be 200e8d4 <IMFS_memfile_write+0x190> <== NEVER TAKEN
200e800: 01 00 00 00 nop
* 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;
200e804: b0 24 00 11 sub %l0, %l1, %i0
200e808: 80 a6 00 1c cmp %i0, %i4
200e80c: 38 80 00 02 bgu,a 200e814 <IMFS_memfile_write+0xd0>
200e810: b0 10 00 1c mov %i4, %i0
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
200e814: d0 02 00 00 ld [ %o0 ], %o0
200e818: 92 10 00 1b mov %i3, %o1
200e81c: 90 02 00 11 add %o0, %l1, %o0
200e820: 94 10 00 18 mov %i0, %o2
200e824: 40 00 06 70 call 20101e4 <memcpy>
200e828: b6 06 c0 18 add %i3, %i0, %i3
src += to_copy;
block++;
200e82c: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e830: b8 27 00 18 sub %i4, %i0, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e834: 21 00 80 75 sethi %hi(0x201d400), %l0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e838: 10 80 00 0f b 200e874 <IMFS_memfile_write+0x130>
200e83c: f2 04 23 20 ld [ %l0 + 0x320 ], %i1 ! 201d720 <imfs_memfile_bytes_per_block>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e840: 92 10 00 1a mov %i2, %o1
200e844: 7f ff fd bf call 200df40 <IMFS_memfile_get_block_pointer>
200e848: 94 10 20 00 clr %o2
if ( !block_ptr )
200e84c: 80 a2 20 00 cmp %o0, 0
200e850: 02 bf ff d4 be 200e7a0 <IMFS_memfile_write+0x5c> <== NEVER TAKEN
200e854: 92 10 00 1b mov %i3, %o1
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 );
200e858: d0 02 00 00 ld [ %o0 ], %o0
200e85c: 94 10 00 19 mov %i1, %o2
200e860: 40 00 06 61 call 20101e4 <memcpy>
200e864: b6 06 c0 19 add %i3, %i1, %i3
src += to_copy;
block++;
200e868: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e86c: 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(
200e870: b0 06 00 19 add %i0, %i1, %i0
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e874: c2 04 23 20 ld [ %l0 + 0x320 ], %g1
200e878: 80 a7 00 01 cmp %i4, %g1
200e87c: 1a bf ff f1 bcc 200e840 <IMFS_memfile_write+0xfc>
200e880: 90 10 00 1d mov %i5, %o0
* 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 ) {
200e884: 80 a7 20 00 cmp %i4, 0
200e888: 02 80 00 0e be 200e8c0 <IMFS_memfile_write+0x17c>
200e88c: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e890: 90 10 00 1d mov %i5, %o0
200e894: 92 10 00 1a mov %i2, %o1
200e898: 7f ff fd aa call 200df40 <IMFS_memfile_get_block_pointer>
200e89c: 94 10 20 00 clr %o2
if ( !block_ptr )
200e8a0: 80 a2 20 00 cmp %o0, 0
200e8a4: 02 bf ff bf be 200e7a0 <IMFS_memfile_write+0x5c> <== NEVER TAKEN
200e8a8: 92 10 00 1b mov %i3, %o1
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 );
200e8ac: d0 02 00 00 ld [ %o0 ], %o0
200e8b0: 94 10 00 1c mov %i4, %o2
200e8b4: 40 00 06 4c call 20101e4 <memcpy>
200e8b8: b0 06 00 1c add %i0, %i4, %i0
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
200e8bc: 90 07 bf f8 add %fp, -8, %o0
200e8c0: 7f ff d3 be call 20037b8 <gettimeofday>
200e8c4: 92 10 20 00 clr %o1
200e8c8: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e8cc: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
200e8d0: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return copied;
}
200e8d4: 81 c7 e0 08 ret
200e8d8: 81 e8 00 00 restore
02002f54 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2002f54: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
2002f58: 05 00 00 3c sethi %hi(0xf000), %g2
2002f5c: 07 00 00 10 sethi %hi(0x4000), %g3
2002f60: 84 0e c0 02 and %i3, %g2, %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2002f64: 94 10 00 19 mov %i1, %o2
2002f68: 96 10 00 1a mov %i2, %o3
2002f6c: 98 10 00 1b mov %i3, %o4
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
2002f70: 80 a0 80 03 cmp %g2, %g3
2002f74: 02 80 00 16 be 2002fcc <IMFS_mknod+0x78>
2002f78: 82 10 20 00 clr %g1
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
2002f7c: 07 00 00 20 sethi %hi(0x8000), %g3
2002f80: 80 a0 80 03 cmp %g2, %g3
2002f84: 02 80 00 11 be 2002fc8 <IMFS_mknod+0x74>
2002f88: 07 00 00 08 sethi %hi(0x2000), %g3
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
2002f8c: 80 a0 80 03 cmp %g2, %g3
2002f90: 22 80 00 07 be,a 2002fac <IMFS_mknod+0x58>
2002f94: f8 3f bf e0 std %i4, [ %fp + -32 ]
2002f98: 07 00 00 18 sethi %hi(0x6000), %g3
2002f9c: 80 a0 80 03 cmp %g2, %g3
2002fa0: 12 80 00 05 bne 2002fb4 <IMFS_mknod+0x60>
2002fa4: 07 00 00 04 sethi %hi(0x1000), %g3
*type = IMFS_DEVICE;
rtems_filesystem_split_dev_t(
2002fa8: f8 3f bf e0 std %i4, [ %fp + -32 ]
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;
2002fac: 10 80 00 08 b 2002fcc <IMFS_mknod+0x78>
2002fb0: 82 10 20 01 mov 1, %g1
rtems_filesystem_split_dev_t(
dev,
info->device.major,
info->device.minor
);
} else if (S_ISFIFO( mode )) {
2002fb4: 80 a0 80 03 cmp %g2, %g3
2002fb8: 32 80 00 06 bne,a 2002fd0 <IMFS_mknod+0x7c> <== NEVER TAKEN
2002fbc: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 <== NOT EXECUTED
*type = IMFS_FIFO;
2002fc0: 10 80 00 03 b 2002fcc <IMFS_mknod+0x78>
2002fc4: 82 10 20 06 mov 6, %g1
2002fc8: 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 =
2002fcc: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
2002fd0: 82 00 60 02 add %g1, 2, %g1
2002fd4: c4 00 a0 20 ld [ %g2 + 0x20 ], %g2
2002fd8: 83 28 60 02 sll %g1, 2, %g1
2002fdc: d2 00 80 01 ld [ %g2 + %g1 ], %o1
2002fe0: 90 10 00 18 mov %i0, %o0
2002fe4: 40 00 22 13 call 200b830 <IMFS_create_node_with_control>
2002fe8: 9a 07 bf e0 add %fp, -32, %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 ) {
2002fec: 80 a2 20 00 cmp %o0, 0
2002ff0: 02 80 00 0e be 2003028 <IMFS_mknod+0xd4>
2002ff4: 82 10 3f ff mov -1, %g1
IMFS_jnode_t *parent = parentloc->node_access;
2002ff8: f0 06 20 08 ld [ %i0 + 8 ], %i0
IMFS_update_ctime( parent );
2002ffc: 92 10 20 00 clr %o1
2003000: 40 00 01 ee call 20037b8 <gettimeofday>
2003004: 90 07 bf f8 add %fp, -8, %o0
2003008: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime( parent );
200300c: 90 07 bf f8 add %fp, -8, %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 );
2003010: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
IMFS_update_mtime( parent );
2003014: 40 00 01 e9 call 20037b8 <gettimeofday>
2003018: 92 10 20 00 clr %o1
200301c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2003020: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
2003024: 82 10 20 00 clr %g1
} else {
rv = -1;
}
return rv;
}
2003028: 81 c7 e0 08 ret
200302c: 91 e8 00 01 restore %g0, %g1, %o0
02003030 <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
2003030: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
2003034: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2003038: 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;
200303c: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
2003040: c4 00 80 00 ld [ %g2 ], %g2
2003044: 80 a0 a0 00 cmp %g2, 0
2003048: 12 80 00 0f bne 2003084 <IMFS_mount+0x54>
200304c: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
2003050: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
2003054: 80 a0 a0 00 cmp %g2, 0
2003058: 12 80 00 05 bne 200306c <IMFS_mount+0x3c> <== NEVER TAKEN
200305c: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
2003060: 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;
2003064: 81 c7 e0 08 ret
2003068: 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;
200306c: 40 00 32 02 call 200f874 <__errno> <== NOT EXECUTED
2003070: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003074: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
2003078: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200307c: 81 c7 e0 08 ret <== NOT EXECUTED
2003080: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
2003084: 40 00 31 fc call 200f874 <__errno>
2003088: b0 10 3f ff mov -1, %i0
200308c: 82 10 20 14 mov 0x14, %g1
2003090: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2003094: 81 c7 e0 08 ret
2003098: 81 e8 00 00 restore
0200bc60 <IMFS_node_remove_directory>:
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node,
const IMFS_jnode_t *root_node
)
{
200bc60: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
200bc64: 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 );
200bc68: 82 06 20 54 add %i0, 0x54, %g1
200bc6c: 80 a0 80 01 cmp %g2, %g1
200bc70: 02 80 00 08 be 200bc90 <IMFS_node_remove_directory+0x30>
200bc74: 80 a6 00 19 cmp %i0, %i1
errno = ENOTEMPTY;
200bc78: 40 00 0e ff call 200f874 <__errno>
200bc7c: b0 10 20 00 clr %i0
200bc80: 82 10 20 5a mov 0x5a, %g1
200bc84: c2 22 00 00 st %g1, [ %o0 ]
200bc88: 81 c7 e0 08 ret
200bc8c: 81 e8 00 00 restore
node = NULL;
} else if ( node == root_node || IMFS_is_mount_point( node ) ) {
200bc90: 02 80 00 06 be 200bca8 <IMFS_node_remove_directory+0x48>
200bc94: 01 00 00 00 nop
200bc98: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200bc9c: 80 a0 60 00 cmp %g1, 0
200bca0: 02 80 00 06 be 200bcb8 <IMFS_node_remove_directory+0x58> <== ALWAYS TAKEN
200bca4: 01 00 00 00 nop
errno = EBUSY;
200bca8: 40 00 0e f3 call 200f874 <__errno>
200bcac: b0 10 20 00 clr %i0 ! 0 <PROM_START>
200bcb0: 82 10 20 10 mov 0x10, %g1
200bcb4: c2 22 00 00 st %g1, [ %o0 ]
node = NULL;
}
return node;
}
200bcb8: 81 c7 e0 08 ret
200bcbc: 81 e8 00 00 restore
02003118 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
2003118: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
200311c: fa 06 60 08 ld [ %i1 + 8 ], %i5
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
2003120: 92 10 00 1b mov %i3, %o1
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
2003124: c2 07 60 08 ld [ %i5 + 8 ], %g1
2003128: 80 a0 60 00 cmp %g1, 0
200312c: 02 80 00 21 be 20031b0 <IMFS_rename+0x98> <== NEVER TAKEN
2003130: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
2003134: 80 a7 20 1f cmp %i4, 0x1f
2003138: 18 80 00 18 bgu 2003198 <IMFS_rename+0x80> <== NEVER TAKEN
200313c: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
2003140: 40 00 34 29 call 20101e4 <memcpy>
2003144: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
2003148: b8 07 40 1c add %i5, %i4, %i4
200314c: c0 2f 20 0c clrb [ %i4 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2003150: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
2003154: c2 07 60 04 ld [ %i5 + 4 ], %g1
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
2003158: 90 07 bf f8 add %fp, -8, %o0
next->previous = previous;
200315c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
2003160: 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;
2003164: 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;
2003168: 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 );
200316c: 84 06 a0 54 add %i2, 0x54, %g2
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
2003170: 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;
2003174: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
old_last->next = the_node;
2003178: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200317c: c2 27 60 04 st %g1, [ %i5 + 4 ]
2003180: 40 00 01 8e call 20037b8 <gettimeofday>
2003184: 92 10 20 00 clr %o1
2003188: c2 07 bf f8 ld [ %fp + -8 ], %g1
200318c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
2003190: 81 c7 e0 08 ret
2003194: 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;
2003198: 40 00 31 b7 call 200f874 <__errno> <== NOT EXECUTED
200319c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20031a0: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
20031a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20031a8: 81 c7 e0 08 ret <== NOT EXECUTED
20031ac: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
20031b0: 40 00 31 b1 call 200f874 <__errno> <== NOT EXECUTED
20031b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20031b8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20031bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20031c0: 81 c7 e0 08 ret <== NOT EXECUTED
20031c4: 81 e8 00 00 restore <== NOT EXECUTED
020032c4 <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
20032c4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
20032c8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
20032cc: 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;
20032d0: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
20032d4: c4 00 80 00 ld [ %g2 ], %g2
20032d8: 80 a0 a0 00 cmp %g2, 0
20032dc: 12 80 00 0f bne 2003318 <IMFS_unmount+0x54> <== NEVER TAKEN
20032e0: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
20032e4: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
20032e8: 80 a0 80 18 cmp %g2, %i0
20032ec: 12 80 00 05 bne 2003300 <IMFS_unmount+0x3c> <== NEVER TAKEN
20032f0: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
20032f4: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
20032f8: 81 c7 e0 08 ret
20032fc: 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;
2003300: 40 00 31 5d call 200f874 <__errno> <== NOT EXECUTED
2003304: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003308: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200330c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2003310: 81 c7 e0 08 ret <== NOT EXECUTED
2003314: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
2003318: 40 00 31 57 call 200f874 <__errno> <== NOT EXECUTED
200331c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003320: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
2003324: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003328: 81 c7 e0 08 ret <== NOT EXECUTED
200332c: 81 e8 00 00 restore <== NOT EXECUTED
02006da8 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
2006da8: 9d e3 bf 98 save %sp, -104, %sp
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
2006dac: 80 a6 3f ff cmp %i0, -1
2006db0: 32 80 00 0a bne,a 2006dd8 <Stack_check_Dump_threads_usage+0x30>
2006db4: e0 06 21 40 ld [ %i0 + 0x140 ], %l0
if (!Stack_check_Interrupt_stack.area)
2006db8: 33 00 81 bc sethi %hi(0x206f000), %i1
2006dbc: b2 16 61 3c or %i1, 0x13c, %i1 ! 206f13c <Stack_check_Interrupt_stack>
2006dc0: c2 06 60 04 ld [ %i1 + 4 ], %g1
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
current = 0;
2006dc4: a0 10 20 00 clr %l0
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
2006dc8: 80 a0 60 00 cmp %g1, 0
2006dcc: 12 80 00 04 bne 2006ddc <Stack_check_Dump_threads_usage+0x34><== ALWAYS TAKEN
2006dd0: b0 10 20 00 clr %i0
2006dd4: 30 80 00 4f b,a 2006f10 <Stack_check_Dump_threads_usage+0x168><== NOT EXECUTED
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
2006dd8: b2 06 20 b4 add %i0, 0xb4, %i1
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
2006ddc: c4 06 60 04 ld [ %i1 + 4 ], %g2
size = Stack_check_usable_stack_size(stack);
2006de0: f4 06 40 00 ld [ %i1 ], %i2
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
2006de4: 82 00 a0 20 add %g2, 0x20, %g1
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
2006de8: b4 06 bf f0 add %i2, -16, %i2
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
2006dec: 07 29 69 69 sethi %hi(0xa5a5a400), %g3
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
2006df0: 88 0e bf fc and %i2, -4, %g4
if (*base != U32_PATTERN)
2006df4: 86 10 e1 a5 or %g3, 0x1a5, %g3
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
2006df8: 10 80 00 06 b 2006e10 <Stack_check_Dump_threads_usage+0x68>
2006dfc: 88 00 40 04 add %g1, %g4, %g4
if (*base != U32_PATTERN)
2006e00: 80 a7 40 03 cmp %i5, %g3
2006e04: 12 80 00 08 bne 2006e24 <Stack_check_Dump_threads_usage+0x7c>
2006e08: 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++)
2006e0c: 82 00 60 04 add %g1, 4, %g1
2006e10: 80 a0 40 04 cmp %g1, %g4
2006e14: 2a bf ff fb bcs,a 2006e00 <Stack_check_Dump_threads_usage+0x58><== ALWAYS TAKEN
2006e18: fa 00 40 00 ld [ %g1 ], %i5
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;
2006e1c: 10 80 00 07 b 2006e38 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
2006e20: ba 10 20 00 clr %i5 <== 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 )
2006e24: 02 80 00 05 be 2006e38 <Stack_check_Dump_threads_usage+0x90><== NEVER TAKEN
2006e28: ba 10 20 00 clr %i5
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
2006e2c: ba 00 a0 10 add %g2, 0x10, %i5
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
2006e30: ba 07 40 1a add %i5, %i2, %i5
2006e34: ba 27 40 01 sub %i5, %g1, %i5
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
2006e38: 80 a6 20 00 cmp %i0, 0
2006e3c: 02 80 00 12 be 2006e84 <Stack_check_Dump_threads_usage+0xdc>
2006e40: 03 00 81 b0 sethi %hi(0x206c000), %g1
#endif
{
(*print_handler)(
2006e44: f6 06 20 08 ld [ %i0 + 8 ], %i3
2006e48: f8 00 63 d8 ld [ %g1 + 0x3d8 ], %i4
2006e4c: 03 00 81 b0 sethi %hi(0x206c000), %g1
2006e50: e2 00 63 d4 ld [ %g1 + 0x3d4 ], %l1 ! 206c3d4 <print_context>
2006e54: 94 07 bf f8 add %fp, -8, %o2
2006e58: 90 10 00 1b mov %i3, %o0
2006e5c: 40 00 18 01 call 200ce60 <rtems_object_get_name>
2006e60: 92 10 20 05 mov 5, %o1
2006e64: 13 00 81 7b sethi %hi(0x205ec00), %o1
2006e68: 96 10 00 08 mov %o0, %o3
2006e6c: 92 12 61 00 or %o1, 0x100, %o1
2006e70: 90 10 00 11 mov %l1, %o0
2006e74: 9f c7 00 00 call %i4
2006e78: 94 10 00 1b mov %i3, %o2
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2006e7c: 10 80 00 0a b 2006ea4 <Stack_check_Dump_threads_usage+0xfc>
2006e80: d4 06 60 04 ld [ %i1 + 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 );
2006e84: 05 00 81 b0 sethi %hi(0x206c000), %g2
2006e88: c2 00 63 d8 ld [ %g1 + 0x3d8 ], %g1
2006e8c: d0 00 a3 d4 ld [ %g2 + 0x3d4 ], %o0
2006e90: 13 00 81 7b sethi %hi(0x205ec00), %o1
2006e94: 94 10 3f ff mov -1, %o2
2006e98: 9f c0 40 00 call %g1
2006e9c: 92 12 61 10 or %o1, 0x110, %o1
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2006ea0: d4 06 60 04 ld [ %i1 + 4 ], %o2
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2006ea4: 37 00 81 b0 sethi %hi(0x206c000), %i3
2006ea8: 39 00 81 b0 sethi %hi(0x206c000), %i4
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2006eac: d6 06 40 00 ld [ %i1 ], %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2006eb0: c2 06 e3 d8 ld [ %i3 + 0x3d8 ], %g1
2006eb4: d0 07 23 d4 ld [ %i4 + 0x3d4 ], %o0
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2006eb8: 96 02 ff ff add %o3, -1, %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2006ebc: 13 00 81 7b sethi %hi(0x205ec00), %o1
2006ec0: 96 02 80 0b add %o2, %o3, %o3
2006ec4: 92 12 61 20 or %o1, 0x120, %o1
2006ec8: 98 10 00 10 mov %l0, %o4
2006ecc: 9f c0 40 00 call %g1
2006ed0: 9a 10 00 1a mov %i2, %o5
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
2006ed4: 03 00 81 b0 sethi %hi(0x206c000), %g1
2006ed8: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 206c3d0 <Stack_check_Initialized>
(*print_handler)( print_context, "Unavailable\n" );
2006edc: d0 07 23 d4 ld [ %i4 + 0x3d4 ], %o0
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
2006ee0: 80 a0 60 00 cmp %g1, 0
2006ee4: 12 80 00 07 bne 2006f00 <Stack_check_Dump_threads_usage+0x158><== ALWAYS TAKEN
2006ee8: c2 06 e3 d8 ld [ %i3 + 0x3d8 ], %g1
(*print_handler)( print_context, "Unavailable\n" );
2006eec: 13 00 81 7b sethi %hi(0x205ec00), %o1 <== NOT EXECUTED
2006ef0: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006ef4: 92 12 61 40 or %o1, 0x140, %o1 ! 205ed40 <write_block_string.9313+0x5b8><== NOT EXECUTED
2006ef8: 81 c7 e0 08 ret <== NOT EXECUTED
2006efc: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
2006f00: 13 00 81 7b sethi %hi(0x205ec00), %o1
2006f04: 94 10 00 1d mov %i5, %o2
2006f08: 9f c0 40 00 call %g1
2006f0c: 92 12 61 50 or %o1, 0x150, %o1
2006f10: 81 c7 e0 08 ret
2006f14: 81 e8 00 00 restore
02007004 <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)
{
2007004: 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");
2007008: 11 00 81 7b sethi %hi(0x205ec00), %o0
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
200700c: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5
char name[32];
printk("BLOWN STACK!!!\n");
2007010: 40 00 0a 46 call 2009928 <printk>
2007014: 90 12 21 58 or %o0, 0x158, %o0
printk("task control block: 0x%08" PRIxPTR "\n", running);
2007018: 92 10 00 18 mov %i0, %o1
200701c: 11 00 81 7b sethi %hi(0x205ec00), %o0
2007020: 40 00 0a 42 call 2009928 <printk>
2007024: 90 12 21 68 or %o0, 0x168, %o0 ! 205ed68 <write_block_string.9313+0x5e0>
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
2007028: d2 06 20 08 ld [ %i0 + 8 ], %o1
200702c: 11 00 81 7b sethi %hi(0x205ec00), %o0
2007030: 40 00 0a 3e call 2009928 <printk>
2007034: 90 12 21 88 or %o0, 0x188, %o0 ! 205ed88 <write_block_string.9313+0x600>
printk(
2007038: d2 06 20 0c ld [ %i0 + 0xc ], %o1
200703c: 11 00 81 7b sethi %hi(0x205ec00), %o0
2007040: 40 00 0a 3a call 2009928 <printk>
2007044: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 205eda0 <write_block_string.9313+0x618>
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
2007048: d0 06 20 08 ld [ %i0 + 8 ], %o0
200704c: 94 07 bf e0 add %fp, -32, %o2
2007050: 40 00 17 84 call 200ce60 <rtems_object_get_name>
2007054: 92 10 20 20 mov 0x20, %o1
2007058: 92 10 00 08 mov %o0, %o1
200705c: 11 00 81 7b sethi %hi(0x205ec00), %o0
2007060: 40 00 0a 32 call 2009928 <printk>
2007064: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 205edb8 <write_block_string.9313+0x630>
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
2007068: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2
200706c: 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(
2007070: 11 00 81 7b sethi %hi(0x205ec00), %o0
2007074: 96 02 80 09 add %o2, %o1, %o3
2007078: 40 00 0a 2c call 2009928 <printk>
200707c: 90 12 21 d0 or %o0, 0x1d0, %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) {
2007080: 80 a6 60 00 cmp %i1, 0
2007084: 12 80 00 07 bne 20070a0 <Stack_check_report_blown_task+0x9c><== NEVER TAKEN
2007088: 11 00 81 7b sethi %hi(0x205ec00), %o0
printk(
200708c: 92 10 20 10 mov 0x10, %o1
2007090: 90 12 22 08 or %o0, 0x208, %o0
2007094: 94 07 60 08 add %i5, 8, %o2
2007098: 40 00 0a 24 call 2009928 <printk>
200709c: 96 07 60 18 add %i5, 0x18, %o3
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
20070a0: 40 00 1a 35 call 200d974 <rtems_fatal_error_occurred>
20070a4: 90 10 20 81 mov 0x81, %o0
0200a8c8 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
200a8c8: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
200a8cc: 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 );
200a8d0: 7f ff e4 94 call 2003b20 <sparc_disable_interrupts>
200a8d4: fa 00 62 8c ld [ %g1 + 0x28c ], %i5 ! 202128c <_Per_CPU_Information+0xc>
200a8d8: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
200a8dc: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
200a8e0: 80 a0 60 00 cmp %g1, 0
200a8e4: 12 80 00 08 bne 200a904 <_CORE_RWLock_Release+0x3c>
200a8e8: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
200a8ec: 7f ff e4 91 call 2003b30 <sparc_enable_interrupts>
200a8f0: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
200a8f4: 82 10 20 02 mov 2, %g1
200a8f8: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
200a8fc: 81 c7 e0 08 ret
200a900: 81 e8 00 00 restore
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
200a904: 32 80 00 0b bne,a 200a930 <_CORE_RWLock_Release+0x68>
200a908: c0 27 60 34 clr [ %i5 + 0x34 ]
the_rwlock->number_of_readers -= 1;
200a90c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200a910: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
200a914: 80 a0 60 00 cmp %g1, 0
200a918: 02 80 00 05 be 200a92c <_CORE_RWLock_Release+0x64>
200a91c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
200a920: 7f ff e4 84 call 2003b30 <sparc_enable_interrupts>
200a924: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
200a928: 30 80 00 24 b,a 200a9b8 <_CORE_RWLock_Release+0xf0>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
200a92c: 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;
200a930: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
200a934: 7f ff e4 7f call 2003b30 <sparc_enable_interrupts>
200a938: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
200a93c: 40 00 07 ac call 200c7ec <_Thread_queue_Dequeue>
200a940: 90 10 00 18 mov %i0, %o0
if ( next ) {
200a944: 80 a2 20 00 cmp %o0, 0
200a948: 22 80 00 1c be,a 200a9b8 <_CORE_RWLock_Release+0xf0>
200a94c: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
200a950: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
200a954: 80 a0 60 01 cmp %g1, 1
200a958: 32 80 00 05 bne,a 200a96c <_CORE_RWLock_Release+0xa4>
200a95c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
200a960: 82 10 20 02 mov 2, %g1
return CORE_RWLOCK_SUCCESSFUL;
200a964: 10 80 00 14 b 200a9b4 <_CORE_RWLock_Release+0xec>
200a968: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
200a96c: 82 00 60 01 inc %g1
200a970: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
200a974: 82 10 20 01 mov 1, %g1
200a978: 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 );
200a97c: 40 00 08 d8 call 200ccdc <_Thread_queue_First>
200a980: 90 10 00 18 mov %i0, %o0
if ( !next ||
200a984: 92 92 20 00 orcc %o0, 0, %o1
200a988: 22 80 00 0c be,a 200a9b8 <_CORE_RWLock_Release+0xf0>
200a98c: b0 10 20 00 clr %i0
200a990: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
200a994: 80 a0 60 01 cmp %g1, 1
200a998: 02 80 00 07 be 200a9b4 <_CORE_RWLock_Release+0xec> <== NEVER TAKEN
200a99c: 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;
200a9a0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200a9a4: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
200a9a8: 40 00 08 7e call 200cba0 <_Thread_queue_Extract>
200a9ac: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
}
200a9b0: 30 bf ff f3 b,a 200a97c <_CORE_RWLock_Release+0xb4>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
200a9b4: b0 10 20 00 clr %i0
200a9b8: 81 c7 e0 08 ret
200a9bc: 81 e8 00 00 restore
0200a9c0 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
200a9c0: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200a9c4: 90 10 00 18 mov %i0, %o0
200a9c8: 40 00 06 b5 call 200c49c <_Thread_Get>
200a9cc: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a9d0: c2 07 bf fc ld [ %fp + -4 ], %g1
200a9d4: 80 a0 60 00 cmp %g1, 0
200a9d8: 12 80 00 09 bne 200a9fc <_CORE_RWLock_Timeout+0x3c> <== NEVER TAKEN
200a9dc: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200a9e0: 40 00 08 fd call 200cdd4 <_Thread_queue_Process_timeout>
200a9e4: 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--;
200a9e8: 03 00 80 83 sethi %hi(0x2020c00), %g1
200a9ec: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 2020d40 <_Thread_Dispatch_disable_level>
200a9f0: 84 00 bf ff add %g2, -1, %g2
200a9f4: c4 20 61 40 st %g2, [ %g1 + 0x140 ]
return _Thread_Dispatch_disable_level;
200a9f8: c2 00 61 40 ld [ %g1 + 0x140 ], %g1
200a9fc: 81 c7 e0 08 ret
200aa00: 81 e8 00 00 restore
02010b64 <_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
)
{
2010b64: 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;
2010b68: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
the_message_queue->number_of_pending_messages = 0;
2010b6c: c0 26 20 48 clr [ %i0 + 0x48 ]
the_message_queue->maximum_message_size = maximum_message_size;
2010b70: 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;
2010b74: c0 26 20 60 clr [ %i0 + 0x60 ]
the_message_queue->notify_argument = the_argument;
2010b78: c0 26 20 64 clr [ %i0 + 0x64 ]
/*
* 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)) {
2010b7c: 80 8e e0 03 btst 3, %i3
2010b80: 02 80 00 07 be 2010b9c <_CORE_message_queue_Initialize+0x38>
2010b84: ba 10 00 1b mov %i3, %i5
allocated_message_size += sizeof(uint32_t);
2010b88: ba 06 e0 04 add %i3, 4, %i5
allocated_message_size &= ~(sizeof(uint32_t) - 1);
2010b8c: ba 0f 7f fc and %i5, -4, %i5
}
if (allocated_message_size < maximum_message_size)
2010b90: 80 a7 40 1b cmp %i5, %i3
2010b94: 0a 80 00 24 bcs 2010c24 <_CORE_message_queue_Initialize+0xc0><== NEVER TAKEN
2010b98: b8 10 20 00 clr %i4
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
2010b9c: ba 07 60 14 add %i5, 0x14, %i5
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
2010ba0: 90 10 20 00 clr %o0
2010ba4: 92 10 00 1a mov %i2, %o1
2010ba8: 94 10 20 00 clr %o2
2010bac: 96 10 00 1d mov %i5, %o3
2010bb0: 40 00 43 34 call 2021880 <__muldi3>
2010bb4: b8 10 20 00 clr %i4
if ( x > SIZE_MAX )
2010bb8: 80 a2 20 00 cmp %o0, 0
2010bbc: 34 80 00 1b bg,a 2010c28 <_CORE_message_queue_Initialize+0xc4>
2010bc0: b0 0f 20 01 and %i4, 1, %i0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
2010bc4: 40 00 0c 28 call 2013c64 <_Workspace_Allocate>
2010bc8: 90 10 00 09 mov %o1, %o0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
2010bcc: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
2010bd0: 80 a2 20 00 cmp %o0, 0
2010bd4: 02 80 00 14 be 2010c24 <_CORE_message_queue_Initialize+0xc0>
2010bd8: 92 10 00 08 mov %o0, %o1
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
2010bdc: 90 06 20 68 add %i0, 0x68, %o0
2010be0: 94 10 00 1a mov %i2, %o2
2010be4: 7f ff ff d2 call 2010b2c <_Chain_Initialize>
2010be8: 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 );
2010bec: 82 06 20 50 add %i0, 0x50, %g1
head->next = tail;
head->previous = NULL;
tail->previous = head;
2010bf0: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
2010bf4: 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 );
2010bf8: 84 06 20 54 add %i0, 0x54, %g2
2010bfc: 82 18 60 01 xor %g1, 1, %g1
2010c00: 80 a0 00 01 cmp %g0, %g1
head->next = tail;
2010c04: c4 26 20 50 st %g2, [ %i0 + 0x50 ]
head->previous = NULL;
2010c08: c0 26 20 54 clr [ %i0 + 0x54 ]
2010c0c: 90 10 00 18 mov %i0, %o0
2010c10: 92 60 3f ff subx %g0, -1, %o1
2010c14: 94 10 20 80 mov 0x80, %o2
2010c18: 96 10 20 06 mov 6, %o3
2010c1c: 40 00 09 ea call 20133c4 <_Thread_queue_Initialize>
2010c20: b8 10 20 01 mov 1, %i4
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
2010c24: b0 0f 20 01 and %i4, 1, %i0
2010c28: 81 c7 e0 08 ret
2010c2c: 81 e8 00 00 restore
02008704 <_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
)
{
2008704: 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)) ) {
2008708: 90 10 00 18 mov %i0, %o0
200870c: 40 00 07 7e call 200a504 <_Thread_queue_Dequeue>
2008710: ba 10 00 18 mov %i0, %i5
2008714: 80 a2 20 00 cmp %o0, 0
2008718: 12 80 00 0e bne 2008750 <_CORE_semaphore_Surrender+0x4c>
200871c: 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 );
2008720: 7f ff e7 b3 call 20025ec <sparc_disable_interrupts>
2008724: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
2008728: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
200872c: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
2008730: 80 a0 40 02 cmp %g1, %g2
2008734: 1a 80 00 05 bcc 2008748 <_CORE_semaphore_Surrender+0x44> <== NEVER TAKEN
2008738: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
200873c: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
2008740: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
2008744: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
2008748: 7f ff e7 ad call 20025fc <sparc_enable_interrupts>
200874c: 01 00 00 00 nop
}
return status;
}
2008750: 81 c7 e0 08 ret
2008754: 81 e8 00 00 restore
02007400 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
2007400: 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 ];
2007404: f8 06 21 58 ld [ %i0 + 0x158 ], %i4
option_set = (rtems_option) the_thread->Wait.option;
2007408: f6 06 20 30 ld [ %i0 + 0x30 ], %i3
_ISR_Disable( level );
200740c: 7f ff ec 78 call 20025ec <sparc_disable_interrupts>
2007410: ba 10 00 18 mov %i0, %i5
2007414: b0 10 00 08 mov %o0, %i0
pending_events = api->pending_events;
2007418: c4 07 00 00 ld [ %i4 ], %g2
event_condition = (rtems_event_set) the_thread->Wait.count;
200741c: 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 ) ) {
2007420: 82 88 c0 02 andcc %g3, %g2, %g1
2007424: 02 80 00 43 be 2007530 <_Event_Surrender+0x130>
2007428: 01 00 00 00 nop
/*
* 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() &&
200742c: 09 00 80 78 sethi %hi(0x201e000), %g4
2007430: 88 11 21 50 or %g4, 0x150, %g4 ! 201e150 <_Per_CPU_Information>
2007434: f2 01 20 08 ld [ %g4 + 8 ], %i1
2007438: 80 a6 60 00 cmp %i1, 0
200743c: 22 80 00 1d be,a 20074b0 <_Event_Surrender+0xb0>
2007440: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
2007444: c8 01 20 0c ld [ %g4 + 0xc ], %g4
2007448: 80 a7 40 04 cmp %i5, %g4
200744c: 32 80 00 19 bne,a 20074b0 <_Event_Surrender+0xb0>
2007450: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
2007454: 09 00 80 79 sethi %hi(0x201e400), %g4
2007458: f2 01 21 50 ld [ %g4 + 0x150 ], %i1 ! 201e550 <_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 ) &&
200745c: 80 a6 60 02 cmp %i1, 2
2007460: 02 80 00 07 be 200747c <_Event_Surrender+0x7c> <== NEVER TAKEN
2007464: 80 a0 40 03 cmp %g1, %g3
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
2007468: c8 01 21 50 ld [ %g4 + 0x150 ], %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) ||
200746c: 80 a1 20 01 cmp %g4, 1
2007470: 32 80 00 10 bne,a 20074b0 <_Event_Surrender+0xb0>
2007474: 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) ) {
2007478: 80 a0 40 03 cmp %g1, %g3
200747c: 02 80 00 04 be 200748c <_Event_Surrender+0x8c>
2007480: 80 8e e0 02 btst 2, %i3
2007484: 02 80 00 2b be 2007530 <_Event_Surrender+0x130> <== NEVER TAKEN
2007488: 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) );
200748c: 84 28 80 01 andn %g2, %g1, %g2
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
2007490: c4 27 00 00 st %g2, [ %i4 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007494: 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;
2007498: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
200749c: c2 20 80 00 st %g1, [ %g2 ]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
20074a0: 84 10 20 03 mov 3, %g2
20074a4: 03 00 80 79 sethi %hi(0x201e400), %g1
20074a8: c4 20 61 50 st %g2, [ %g1 + 0x150 ] ! 201e550 <_Event_Sync_state>
20074ac: 30 80 00 21 b,a 2007530 <_Event_Surrender+0x130>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
20074b0: 80 89 21 00 btst 0x100, %g4
20074b4: 02 80 00 1f be 2007530 <_Event_Surrender+0x130>
20074b8: 80 a0 40 03 cmp %g1, %g3
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
20074bc: 02 80 00 04 be 20074cc <_Event_Surrender+0xcc>
20074c0: 80 8e e0 02 btst 2, %i3
20074c4: 02 80 00 1b be 2007530 <_Event_Surrender+0x130> <== NEVER TAKEN
20074c8: 01 00 00 00 nop
20074cc: 84 28 80 01 andn %g2, %g1, %g2
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
20074d0: c4 27 00 00 st %g2, [ %i4 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20074d4: 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;
20074d8: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20074dc: c2 20 80 00 st %g1, [ %g2 ]
_ISR_Flash( level );
20074e0: 7f ff ec 47 call 20025fc <sparc_enable_interrupts>
20074e4: 90 10 00 18 mov %i0, %o0
20074e8: 7f ff ec 41 call 20025ec <sparc_disable_interrupts>
20074ec: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
20074f0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
20074f4: 80 a0 60 02 cmp %g1, 2
20074f8: 02 80 00 06 be 2007510 <_Event_Surrender+0x110>
20074fc: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
2007500: 7f ff ec 3f call 20025fc <sparc_enable_interrupts>
2007504: 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 );
2007508: 10 80 00 08 b 2007528 <_Event_Surrender+0x128>
200750c: 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;
2007510: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
2007514: 7f ff ec 3a call 20025fc <sparc_enable_interrupts>
2007518: 33 04 00 ff sethi %hi(0x1003fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
200751c: 40 00 0e b5 call 200aff0 <_Watchdog_Remove>
2007520: 90 07 60 48 add %i5, 0x48, %o0
2007524: b2 16 63 f8 or %i1, 0x3f8, %i1
2007528: 40 00 0a 37 call 2009e04 <_Thread_Clear_state>
200752c: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
2007530: 7f ff ec 33 call 20025fc <sparc_enable_interrupts>
2007534: 81 e8 00 00 restore
02007538 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
2007538: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
200753c: 90 10 00 18 mov %i0, %o0
2007540: 40 00 0b 1d call 200a1b4 <_Thread_Get>
2007544: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
2007548: c2 07 bf fc ld [ %fp + -4 ], %g1
200754c: 80 a0 60 00 cmp %g1, 0
2007550: 12 80 00 1d bne 20075c4 <_Event_Timeout+0x8c> <== NEVER TAKEN
2007554: 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 );
2007558: 7f ff ec 25 call 20025ec <sparc_disable_interrupts>
200755c: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
2007560: 03 00 80 78 sethi %hi(0x201e000), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
2007564: c2 00 61 5c ld [ %g1 + 0x15c ], %g1 ! 201e15c <_Per_CPU_Information+0xc>
2007568: 80 a7 40 01 cmp %i5, %g1
200756c: 12 80 00 09 bne 2007590 <_Event_Timeout+0x58>
2007570: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
2007574: 03 00 80 79 sethi %hi(0x201e400), %g1
2007578: c4 00 61 50 ld [ %g1 + 0x150 ], %g2 ! 201e550 <_Event_Sync_state>
200757c: 80 a0 a0 01 cmp %g2, 1
2007580: 32 80 00 05 bne,a 2007594 <_Event_Timeout+0x5c>
2007584: 82 10 20 06 mov 6, %g1
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
2007588: 84 10 20 02 mov 2, %g2
200758c: c4 20 61 50 st %g2, [ %g1 + 0x150 ]
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
2007590: 82 10 20 06 mov 6, %g1
2007594: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
2007598: 7f ff ec 19 call 20025fc <sparc_enable_interrupts>
200759c: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
20075a0: 90 10 00 1d mov %i5, %o0
20075a4: 13 04 00 ff sethi %hi(0x1003fc00), %o1
20075a8: 40 00 0a 17 call 2009e04 <_Thread_Clear_state>
20075ac: 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--;
20075b0: 03 00 80 77 sethi %hi(0x201dc00), %g1
20075b4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201dc10 <_Thread_Dispatch_disable_level>
20075b8: 84 00 bf ff add %g2, -1, %g2
20075bc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
return _Thread_Dispatch_disable_level;
20075c0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
20075c4: 81 c7 e0 08 ret
20075c8: 81 e8 00 00 restore
0200d770 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
200d770: 9d e3 bf 98 save %sp, -104, %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;
200d774: c0 27 bf f8 clr [ %fp + -8 ]
Heap_Block *extend_last_block = NULL;
200d778: 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;
200d77c: 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;
200d780: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
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;
200d784: e2 06 20 10 ld [ %i0 + 0x10 ], %l1
uintptr_t const min_block_size = heap->min_block_size;
200d788: d6 06 20 14 ld [ %i0 + 0x14 ], %o3
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
uintptr_t const free_size = stats->free_size;
200d78c: e4 06 20 30 ld [ %i0 + 0x30 ], %l2
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
200d790: 80 a7 40 19 cmp %i5, %i1
200d794: 0a 80 00 9f bcs 200da10 <_Heap_Extend+0x2a0>
200d798: b8 10 20 00 clr %i4
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
200d79c: 90 10 00 19 mov %i1, %o0
200d7a0: 92 10 00 1a mov %i2, %o1
200d7a4: 94 10 00 11 mov %l1, %o2
200d7a8: 98 07 bf f8 add %fp, -8, %o4
200d7ac: 7f ff ec 84 call 20089bc <_Heap_Get_first_and_last_block>
200d7b0: 9a 07 bf fc add %fp, -4, %o5
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
200d7b4: 80 8a 20 ff btst 0xff, %o0
200d7b8: 02 80 00 96 be 200da10 <_Heap_Extend+0x2a0>
200d7bc: b4 10 00 10 mov %l0, %i2
200d7c0: aa 10 20 00 clr %l5
200d7c4: ac 10 20 00 clr %l6
200d7c8: b8 10 20 00 clr %i4
200d7cc: a8 10 20 00 clr %l4
200d7d0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
(uintptr_t) start_block : heap->area_begin;
uintptr_t const sub_area_end = start_block->prev_size;
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
200d7d4: 80 a0 40 1d cmp %g1, %i5
200d7d8: 1a 80 00 05 bcc 200d7ec <_Heap_Extend+0x7c>
200d7dc: e6 06 80 00 ld [ %i2 ], %l3
200d7e0: 80 a6 40 13 cmp %i1, %l3
200d7e4: 2a 80 00 8b bcs,a 200da10 <_Heap_Extend+0x2a0>
200d7e8: b8 10 20 00 clr %i4
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
200d7ec: 80 a7 40 01 cmp %i5, %g1
200d7f0: 02 80 00 06 be 200d808 <_Heap_Extend+0x98>
200d7f4: 80 a7 40 13 cmp %i5, %l3
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
200d7f8: 2a 80 00 05 bcs,a 200d80c <_Heap_Extend+0x9c>
200d7fc: ac 10 00 1a mov %i2, %l6
200d800: 10 80 00 04 b 200d810 <_Heap_Extend+0xa0>
200d804: 90 10 00 13 mov %l3, %o0
200d808: a8 10 00 1a mov %i2, %l4
200d80c: 90 10 00 13 mov %l3, %o0
200d810: 40 00 2d 51 call 2018d54 <.urem>
200d814: 92 10 00 11 mov %l1, %o1
200d818: ae 04 ff f8 add %l3, -8, %l7
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
200d81c: 80 a4 c0 19 cmp %l3, %i1
200d820: 12 80 00 05 bne 200d834 <_Heap_Extend+0xc4>
200d824: 90 25 c0 08 sub %l7, %o0, %o0
start_block->prev_size = extend_area_end;
200d828: 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 )
200d82c: 10 80 00 04 b 200d83c <_Heap_Extend+0xcc>
200d830: b8 10 00 08 mov %o0, %i4
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
200d834: 2a 80 00 02 bcs,a 200d83c <_Heap_Extend+0xcc>
200d838: aa 10 00 08 mov %o0, %l5
- 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;
200d83c: f4 02 20 04 ld [ %o0 + 4 ], %i2
200d840: 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);
200d844: 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 );
200d848: 80 a6 80 10 cmp %i2, %l0
200d84c: 12 bf ff e2 bne 200d7d4 <_Heap_Extend+0x64>
200d850: 82 10 00 1a mov %i2, %g1
if ( extend_area_begin < heap->area_begin ) {
200d854: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200d858: 80 a6 40 01 cmp %i1, %g1
200d85c: 3a 80 00 04 bcc,a 200d86c <_Heap_Extend+0xfc>
200d860: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
heap->area_begin = extend_area_begin;
200d864: 10 80 00 05 b 200d878 <_Heap_Extend+0x108>
200d868: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
} else if ( heap->area_end < extend_area_end ) {
200d86c: 80 a0 40 1d cmp %g1, %i5
200d870: 2a 80 00 02 bcs,a 200d878 <_Heap_Extend+0x108>
200d874: 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;
200d878: c4 07 bf f8 ld [ %fp + -8 ], %g2
200d87c: c2 07 bf fc ld [ %fp + -4 ], %g1
extend_first_block->prev_size = extend_area_end;
200d880: 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 =
200d884: 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;
200d888: 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;
200d88c: 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 =
200d890: 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 ) {
200d894: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
200d898: 80 a0 c0 02 cmp %g3, %g2
200d89c: 08 80 00 04 bleu 200d8ac <_Heap_Extend+0x13c>
200d8a0: c0 20 60 04 clr [ %g1 + 4 ]
heap->first_block = extend_first_block;
200d8a4: 10 80 00 06 b 200d8bc <_Heap_Extend+0x14c>
200d8a8: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
200d8ac: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200d8b0: 80 a0 80 01 cmp %g2, %g1
200d8b4: 2a 80 00 02 bcs,a 200d8bc <_Heap_Extend+0x14c>
200d8b8: c2 26 20 24 st %g1, [ %i0 + 0x24 ]
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
200d8bc: 80 a5 20 00 cmp %l4, 0
200d8c0: 02 80 00 14 be 200d910 <_Heap_Extend+0x1a0>
200d8c4: 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;
200d8c8: 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;
200d8cc: 92 10 00 1a mov %i2, %o1
200d8d0: 40 00 2d 21 call 2018d54 <.urem>
200d8d4: 90 10 00 19 mov %i1, %o0
if ( remainder != 0 ) {
200d8d8: 80 a2 20 00 cmp %o0, 0
200d8dc: 02 80 00 04 be 200d8ec <_Heap_Extend+0x17c>
200d8e0: c2 05 00 00 ld [ %l4 ], %g1
return value - remainder + alignment;
200d8e4: b2 06 40 1a add %i1, %i2, %i1
200d8e8: 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 =
200d8ec: 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;
200d8f0: 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 =
200d8f4: 82 25 00 09 sub %l4, %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;
200d8f8: 82 10 60 01 or %g1, 1, %g1
_Heap_Free_block( heap, new_first_block );
200d8fc: 90 10 00 18 mov %i0, %o0
200d900: 7f ff ff 92 call 200d748 <_Heap_Free_block>
200d904: c2 22 60 04 st %g1, [ %o1 + 4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
200d908: 10 80 00 08 b 200d928 <_Heap_Extend+0x1b8>
200d90c: 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 ) {
200d910: 80 a5 a0 00 cmp %l6, 0
200d914: 02 80 00 04 be 200d924 <_Heap_Extend+0x1b4>
200d918: ac 25 80 01 sub %l6, %g1, %l6
{
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;
200d91c: ac 15 a0 01 or %l6, 1, %l6
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
200d920: ec 20 60 04 st %l6, [ %g1 + 4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
200d924: 80 a7 20 00 cmp %i4, 0
200d928: 02 80 00 15 be 200d97c <_Heap_Extend+0x20c>
200d92c: 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);
200d930: 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(
200d934: ba 27 40 1c sub %i5, %i4, %i5
200d938: 40 00 2d 07 call 2018d54 <.urem>
200d93c: 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)
200d940: c4 07 20 04 ld [ %i4 + 4 ], %g2
200d944: ba 27 40 08 sub %i5, %o0, %i5
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
200d948: 82 07 40 1c add %i5, %i4, %g1
(last_block->size_and_flag - last_block_new_size)
200d94c: 84 20 80 1d sub %g2, %i5, %g2
| HEAP_PREV_BLOCK_USED;
200d950: 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 =
200d954: 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;
200d958: 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 );
200d95c: 90 10 00 18 mov %i0, %o0
200d960: 82 08 60 01 and %g1, 1, %g1
200d964: 92 10 00 1c mov %i4, %o1
block->size_and_flag = size | flag;
200d968: ba 17 40 01 or %i5, %g1, %i5
200d96c: 7f ff ff 77 call 200d748 <_Heap_Free_block>
200d970: fa 27 20 04 st %i5, [ %i4 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200d974: 10 80 00 0f b 200d9b0 <_Heap_Extend+0x240>
200d978: 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 ) {
200d97c: 80 a5 60 00 cmp %l5, 0
200d980: 02 80 00 0b be 200d9ac <_Heap_Extend+0x23c>
200d984: 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;
200d988: c4 05 60 04 ld [ %l5 + 4 ], %g2
_Heap_Link_above(
200d98c: 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 );
200d990: 86 20 c0 15 sub %g3, %l5, %g3
200d994: 84 08 a0 01 and %g2, 1, %g2
block->size_and_flag = size | flag;
200d998: 84 10 c0 02 or %g3, %g2, %g2
200d99c: c4 25 60 04 st %g2, [ %l5 + 4 ]
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
200d9a0: c4 00 60 04 ld [ %g1 + 4 ], %g2
200d9a4: 84 10 a0 01 or %g2, 1, %g2
200d9a8: c4 20 60 04 st %g2, [ %g1 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200d9ac: 80 a7 20 00 cmp %i4, 0
200d9b0: 32 80 00 09 bne,a 200d9d4 <_Heap_Extend+0x264>
200d9b4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d9b8: 80 a5 20 00 cmp %l4, 0
200d9bc: 32 80 00 06 bne,a 200d9d4 <_Heap_Extend+0x264>
200d9c0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
_Heap_Free_block( heap, extend_first_block );
200d9c4: d2 07 bf f8 ld [ %fp + -8 ], %o1
200d9c8: 7f ff ff 60 call 200d748 <_Heap_Free_block>
200d9cc: 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
200d9d0: 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(
200d9d4: 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;
200d9d8: 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(
200d9dc: 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;
200d9e0: 84 08 a0 01 and %g2, 1, %g2
block->size_and_flag = size | flag;
200d9e4: 84 10 c0 02 or %g3, %g2, %g2
200d9e8: c4 20 60 04 st %g2, [ %g1 + 4 ]
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
200d9ec: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
200d9f0: b8 10 20 01 mov 1, %i4
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
200d9f4: a4 20 40 12 sub %g1, %l2, %l2
/* Statistics */
stats->size += extended_size;
200d9f8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
if ( extended_size_ptr != NULL )
200d9fc: 80 a6 e0 00 cmp %i3, 0
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
200da00: 82 00 40 12 add %g1, %l2, %g1
if ( extended_size_ptr != NULL )
200da04: 02 80 00 03 be 200da10 <_Heap_Extend+0x2a0> <== NEVER TAKEN
200da08: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
200da0c: e4 26 c0 00 st %l2, [ %i3 ]
*extended_size_ptr = extended_size;
return true;
}
200da10: b0 0f 20 01 and %i4, 1, %i0
200da14: 81 c7 e0 08 ret
200da18: 81 e8 00 00 restore
0200d78c <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
200d78c: 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 ) {
return true;
200d790: 88 10 20 01 mov 1, %g4
/*
* 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 ) {
200d794: 80 a6 60 00 cmp %i1, 0
200d798: 02 80 00 78 be 200d978 <_Heap_Free+0x1ec>
200d79c: 90 10 00 19 mov %i1, %o0
200d7a0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200d7a4: 40 00 2c c8 call 2018ac4 <.urem>
200d7a8: ba 06 7f f8 add %i1, -8, %i5
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
200d7ac: d8 06 20 20 ld [ %i0 + 0x20 ], %o4
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
200d7b0: ba 27 40 08 sub %i5, %o0, %i5
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;
200d7b4: 80 a7 40 0c cmp %i5, %o4
200d7b8: 0a 80 00 05 bcs 200d7cc <_Heap_Free+0x40>
200d7bc: 82 10 20 00 clr %g1
200d7c0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d7c4: 80 a0 40 1d cmp %g1, %i5
200d7c8: 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 ) ) {
200d7cc: 80 a0 60 00 cmp %g1, 0
200d7d0: 02 80 00 6a be 200d978 <_Heap_Free+0x1ec>
200d7d4: 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;
200d7d8: da 07 60 04 ld [ %i5 + 4 ], %o5
200d7dc: 84 0b 7f fe and %o5, -2, %g2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200d7e0: 82 07 40 02 add %i5, %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;
200d7e4: 80 a0 40 0c cmp %g1, %o4
200d7e8: 0a 80 00 05 bcs 200d7fc <_Heap_Free+0x70> <== NEVER TAKEN
200d7ec: 86 10 20 00 clr %g3
200d7f0: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
200d7f4: 80 a0 c0 01 cmp %g3, %g1
200d7f8: 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 ) ) {
200d7fc: 80 a0 e0 00 cmp %g3, 0
200d800: 02 80 00 5e be 200d978 <_Heap_Free+0x1ec> <== NEVER TAKEN
200d804: 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;
200d808: de 00 60 04 ld [ %g1 + 4 ], %o7
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
200d80c: 80 8b e0 01 btst 1, %o7
200d810: 02 80 00 5a be 200d978 <_Heap_Free+0x1ec> <== NEVER TAKEN
200d814: 9e 0b ff fe and %o7, -2, %o7
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
200d818: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
200d81c: 80 a0 40 04 cmp %g1, %g4
200d820: 02 80 00 07 be 200d83c <_Heap_Free+0xb0>
200d824: 96 10 20 00 clr %o3
200d828: 86 00 40 0f add %g1, %o7, %g3
200d82c: c6 00 e0 04 ld [ %g3 + 4 ], %g3
200d830: 86 08 e0 01 and %g3, 1, %g3
200d834: 80 a0 00 03 cmp %g0, %g3
200d838: 96 60 3f ff subx %g0, -1, %o3
if ( !_Heap_Is_prev_used( block ) ) {
200d83c: 80 8b 60 01 btst 1, %o5
200d840: 12 80 00 26 bne 200d8d8 <_Heap_Free+0x14c>
200d844: 80 8a e0 ff btst 0xff, %o3
uintptr_t const prev_size = block->prev_size;
200d848: da 07 40 00 ld [ %i5 ], %o5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200d84c: 86 27 40 0d sub %i5, %o5, %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;
200d850: 80 a0 c0 0c cmp %g3, %o4
200d854: 0a 80 00 04 bcs 200d864 <_Heap_Free+0xd8> <== NEVER TAKEN
200d858: 94 10 20 00 clr %o2
200d85c: 80 a1 00 03 cmp %g4, %g3
200d860: 94 60 3f ff subx %g0, -1, %o2
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
200d864: 80 a2 a0 00 cmp %o2, 0
200d868: 02 80 00 44 be 200d978 <_Heap_Free+0x1ec> <== NEVER TAKEN
200d86c: 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;
200d870: d8 00 e0 04 ld [ %g3 + 4 ], %o4
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) ) {
200d874: 80 8b 20 01 btst 1, %o4
200d878: 02 80 00 40 be 200d978 <_Heap_Free+0x1ec> <== NEVER TAKEN
200d87c: 80 8a e0 ff btst 0xff, %o3
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
200d880: 22 80 00 0f be,a 200d8bc <_Heap_Free+0x130>
200d884: 9a 00 80 0d add %g2, %o5, %o5
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
200d888: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = block->prev;
200d88c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
uintptr_t const size = block_size + prev_size + next_block_size;
200d890: 9e 00 80 0f add %g2, %o7, %o7
prev->next = next;
200d894: c8 20 60 08 st %g4, [ %g1 + 8 ]
next->prev = prev;
200d898: c2 21 20 0c st %g1, [ %g4 + 0xc ]
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d89c: 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;
200d8a0: 9a 03 c0 0d add %o7, %o5, %o5
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d8a4: 82 00 7f ff add %g1, -1, %g1
200d8a8: 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;
200d8ac: da 20 c0 0d st %o5, [ %g3 + %o5 ]
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;
200d8b0: 82 13 60 01 or %o5, 1, %g1
200d8b4: 10 80 00 27 b 200d950 <_Heap_Free+0x1c4>
200d8b8: 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;
200d8bc: 88 13 60 01 or %o5, 1, %g4
200d8c0: c8 20 e0 04 st %g4, [ %g3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d8c4: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = size;
200d8c8: da 27 40 02 st %o5, [ %i5 + %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;
200d8cc: 86 08 ff fe and %g3, -2, %g3
200d8d0: 10 80 00 20 b 200d950 <_Heap_Free+0x1c4>
200d8d4: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
200d8d8: 22 80 00 0d be,a 200d90c <_Heap_Free+0x180>
200d8dc: 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;
200d8e0: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = old_block->prev;
200d8e4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
new_block->next = next;
200d8e8: c8 27 60 08 st %g4, [ %i5 + 8 ]
new_block->prev = prev;
200d8ec: c2 27 60 0c st %g1, [ %i5 + 0xc ]
uintptr_t const size = block_size + next_block_size;
200d8f0: 86 03 c0 02 add %o7, %g2, %g3
next->prev = new_block;
prev->next = new_block;
200d8f4: fa 20 60 08 st %i5, [ %g1 + 8 ]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
200d8f8: fa 21 20 0c st %i5, [ %g4 + 0xc ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d8fc: 82 10 e0 01 or %g3, 1, %g1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
200d900: c6 27 40 03 st %g3, [ %i5 + %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;
200d904: 10 80 00 13 b 200d950 <_Heap_Free+0x1c4>
200d908: c2 27 60 04 st %g1, [ %i5 + 4 ]
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
200d90c: f0 27 60 0c st %i0, [ %i5 + 0xc ]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
200d910: c6 27 60 08 st %g3, [ %i5 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
200d914: fa 20 e0 0c st %i5, [ %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;
200d918: 86 10 a0 01 or %g2, 1, %g3
200d91c: c6 27 60 04 st %g3, [ %i5 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d920: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = block_size;
200d924: c4 27 40 02 st %g2, [ %i5 + %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;
200d928: 86 08 ff fe and %g3, -2, %g3
200d92c: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
200d930: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
if ( stats->max_free_blocks < stats->free_blocks ) {
200d934: 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;
200d938: 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;
200d93c: fa 26 20 08 st %i5, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
200d940: 80 a0 c0 01 cmp %g3, %g1
200d944: 1a 80 00 03 bcc 200d950 <_Heap_Free+0x1c4>
200d948: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
200d94c: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
}
}
/* Statistics */
--stats->used_blocks;
200d950: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
++stats->frees;
stats->free_size += block_size;
return( true );
200d954: 88 10 20 01 mov 1, %g4
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
200d958: 82 00 7f ff add %g1, -1, %g1
200d95c: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
++stats->frees;
200d960: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200d964: 82 00 60 01 inc %g1
200d968: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->free_size += block_size;
200d96c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
200d970: 84 00 40 02 add %g1, %g2, %g2
200d974: c4 26 20 30 st %g2, [ %i0 + 0x30 ]
return( true );
}
200d978: b0 09 20 01 and %g4, 1, %i0
200d97c: 81 c7 e0 08 ret
200d980: 81 e8 00 00 restore
0203ee68 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
203ee68: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *current = heap->first_block;
203ee6c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
Heap_Block *end = heap->last_block;
203ee70: 10 80 00 0b b 203ee9c <_Heap_Iterate+0x34>
203ee74: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
while ( !stop && current != end ) {
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 );
203ee78: 96 10 00 1a mov %i2, %o3
- 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;
203ee7c: 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);
203ee80: ba 02 00 09 add %o0, %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;
203ee84: d4 07 60 04 ld [ %i5 + 4 ], %o2
203ee88: 9f c6 40 00 call %i1
203ee8c: 94 0a a0 01 and %o2, 1, %o2
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
203ee90: 80 8a 20 ff btst 0xff, %o0
203ee94: 12 80 00 05 bne 203eea8 <_Heap_Iterate+0x40> <== NEVER TAKEN
203ee98: 90 10 00 1d mov %i5, %o0
203ee9c: 80 a2 00 1c cmp %o0, %i4
203eea0: 32 bf ff f6 bne,a 203ee78 <_Heap_Iterate+0x10>
203eea4: d2 02 20 04 ld [ %o0 + 4 ], %o1
203eea8: 81 c7 e0 08 ret
203eeac: 81 e8 00 00 restore
0200daa4 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
200daa4: 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);
200daa8: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200daac: 40 00 2c 06 call 2018ac4 <.urem>
200dab0: 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
200dab4: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200dab8: 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);
200dabc: 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;
200dac0: 80 a2 00 03 cmp %o0, %g3
200dac4: 0a 80 00 05 bcs 200dad8 <_Heap_Size_of_alloc_area+0x34>
200dac8: 84 10 20 00 clr %g2
200dacc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200dad0: 80 a0 40 08 cmp %g1, %o0
200dad4: 84 60 3f ff subx %g0, -1, %g2
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 ) ) {
200dad8: 80 a0 a0 00 cmp %g2, 0
200dadc: 02 80 00 15 be 200db30 <_Heap_Size_of_alloc_area+0x8c>
200dae0: 82 10 20 00 clr %g1
- 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;
200dae4: fa 02 20 04 ld [ %o0 + 4 ], %i5
200dae8: ba 0f 7f fe and %i5, -2, %i5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200daec: ba 02 00 1d add %o0, %i5, %i5
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;
200daf0: 80 a7 40 03 cmp %i5, %g3
200daf4: 0a 80 00 05 bcs 200db08 <_Heap_Size_of_alloc_area+0x64> <== NEVER TAKEN
200daf8: 84 10 20 00 clr %g2
200dafc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200db00: 80 a0 40 1d cmp %g1, %i5
200db04: 84 60 3f ff subx %g0, -1, %g2
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
200db08: 80 a0 a0 00 cmp %g2, 0
200db0c: 02 80 00 09 be 200db30 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200db10: 82 10 20 00 clr %g1
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;
200db14: c4 07 60 04 ld [ %i5 + 4 ], %g2
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
200db18: 80 88 a0 01 btst 1, %g2
200db1c: 02 80 00 05 be 200db30 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200db20: ba 27 40 19 sub %i5, %i1, %i5
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
200db24: 82 10 20 01 mov 1, %g1
|| !_Heap_Is_prev_used( next_block )
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
200db28: ba 07 60 04 add %i5, 4, %i5
200db2c: fa 26 80 00 st %i5, [ %i2 ]
return true;
}
200db30: b0 08 60 01 and %g1, 1, %i0
200db34: 81 c7 e0 08 ret
200db38: 81 e8 00 00 restore
02009878 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
2009878: 9d e3 bf 80 save %sp, -128, %sp
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
200987c: 3b 00 80 26 sethi %hi(0x2009800), %i5
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
2009880: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
uintptr_t const min_block_size = heap->min_block_size;
2009884: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
Heap_Block *const first_block = heap->first_block;
2009888: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
Heap_Block *const last_block = heap->last_block;
200988c: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
2009890: 80 a6 a0 00 cmp %i2, 0
2009894: 02 80 00 04 be 20098a4 <_Heap_Walk+0x2c>
2009898: ba 17 60 24 or %i5, 0x24, %i5
200989c: 3b 00 80 26 sethi %hi(0x2009800), %i5
20098a0: ba 17 60 2c or %i5, 0x2c, %i5 ! 200982c <_Heap_Walk_print>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
20098a4: 03 00 80 80 sethi %hi(0x2020000), %g1
20098a8: c4 00 61 28 ld [ %g1 + 0x128 ], %g2 ! 2020128 <_System_state_Current>
20098ac: 80 a0 a0 03 cmp %g2, 3
20098b0: 12 80 01 24 bne 2009d40 <_Heap_Walk+0x4c8>
20098b4: 82 10 20 01 mov 1, %g1
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)(
20098b8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
20098bc: da 06 20 18 ld [ %i0 + 0x18 ], %o5
20098c0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
20098c4: f6 23 a0 60 st %i3, [ %sp + 0x60 ]
20098c8: e2 23 a0 64 st %l1, [ %sp + 0x64 ]
20098cc: c2 06 20 08 ld [ %i0 + 8 ], %g1
20098d0: 90 10 00 19 mov %i1, %o0
20098d4: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
20098d8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20098dc: 92 10 20 00 clr %o1
20098e0: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
20098e4: 15 00 80 72 sethi %hi(0x201c800), %o2
20098e8: 96 10 00 1c mov %i4, %o3
20098ec: 94 12 a1 f8 or %o2, 0x1f8, %o2
20098f0: 9f c7 40 00 call %i5
20098f4: 98 10 00 10 mov %l0, %o4
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
20098f8: 80 a7 20 00 cmp %i4, 0
20098fc: 12 80 00 07 bne 2009918 <_Heap_Walk+0xa0>
2009900: 80 8f 20 07 btst 7, %i4
(*printer)( source, true, "page size is zero\n" );
2009904: 15 00 80 72 sethi %hi(0x201c800), %o2
2009908: 90 10 00 19 mov %i1, %o0
200990c: 92 10 20 01 mov 1, %o1
2009910: 10 80 00 32 b 20099d8 <_Heap_Walk+0x160>
2009914: 94 12 a2 90 or %o2, 0x290, %o2
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
2009918: 22 80 00 08 be,a 2009938 <_Heap_Walk+0xc0>
200991c: 90 10 00 10 mov %l0, %o0
(*printer)(
2009920: 15 00 80 72 sethi %hi(0x201c800), %o2
2009924: 90 10 00 19 mov %i1, %o0
2009928: 92 10 20 01 mov 1, %o1
200992c: 94 12 a2 a8 or %o2, 0x2a8, %o2
2009930: 10 80 01 0b b 2009d5c <_Heap_Walk+0x4e4>
2009934: 96 10 00 1c mov %i4, %o3
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
2009938: 7f ff e0 6a call 2001ae0 <.urem>
200993c: 92 10 00 1c mov %i4, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
2009940: 80 a2 20 00 cmp %o0, 0
2009944: 22 80 00 08 be,a 2009964 <_Heap_Walk+0xec>
2009948: 90 06 e0 08 add %i3, 8, %o0
(*printer)(
200994c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009950: 90 10 00 19 mov %i1, %o0
2009954: 92 10 20 01 mov 1, %o1
2009958: 94 12 a2 c8 or %o2, 0x2c8, %o2
200995c: 10 80 01 00 b 2009d5c <_Heap_Walk+0x4e4>
2009960: 96 10 00 10 mov %l0, %o3
2009964: 7f ff e0 5f call 2001ae0 <.urem>
2009968: 92 10 00 1c mov %i4, %o1
);
return false;
}
if (
200996c: 80 a2 20 00 cmp %o0, 0
2009970: 22 80 00 08 be,a 2009990 <_Heap_Walk+0x118>
2009974: c2 06 e0 04 ld [ %i3 + 4 ], %g1
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
2009978: 15 00 80 72 sethi %hi(0x201c800), %o2
200997c: 90 10 00 19 mov %i1, %o0
2009980: 92 10 20 01 mov 1, %o1
2009984: 94 12 a2 f0 or %o2, 0x2f0, %o2
2009988: 10 80 00 f5 b 2009d5c <_Heap_Walk+0x4e4>
200998c: 96 10 00 1b mov %i3, %o3
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
2009990: 80 88 60 01 btst 1, %g1
2009994: 32 80 00 07 bne,a 20099b0 <_Heap_Walk+0x138>
2009998: f4 04 60 04 ld [ %l1 + 4 ], %i2
(*printer)(
200999c: 15 00 80 72 sethi %hi(0x201c800), %o2
20099a0: 90 10 00 19 mov %i1, %o0
20099a4: 92 10 20 01 mov 1, %o1
20099a8: 10 80 00 0c b 20099d8 <_Heap_Walk+0x160>
20099ac: 94 12 a3 28 or %o2, 0x328, %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;
20099b0: 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);
20099b4: b4 04 40 1a add %l1, %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;
20099b8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
20099bc: 80 88 60 01 btst 1, %g1
20099c0: 12 80 00 0a bne 20099e8 <_Heap_Walk+0x170>
20099c4: 80 a6 80 1b cmp %i2, %i3
(*printer)(
20099c8: 15 00 80 72 sethi %hi(0x201c800), %o2
20099cc: 90 10 00 19 mov %i1, %o0
20099d0: 92 10 20 01 mov 1, %o1
20099d4: 94 12 a3 58 or %o2, 0x358, %o2
20099d8: 9f c7 40 00 call %i5
20099dc: 01 00 00 00 nop
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
20099e0: 10 80 00 d8 b 2009d40 <_Heap_Walk+0x4c8>
20099e4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
);
return false;
}
if (
20099e8: 02 80 00 06 be 2009a00 <_Heap_Walk+0x188>
20099ec: 15 00 80 72 sethi %hi(0x201c800), %o2
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
20099f0: 90 10 00 19 mov %i1, %o0
20099f4: 92 10 20 01 mov 1, %o1
20099f8: 10 bf ff f8 b 20099d8 <_Heap_Walk+0x160>
20099fc: 94 12 a3 70 or %o2, 0x370, %o2
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
2009a00: e6 06 20 10 ld [ %i0 + 0x10 ], %l3
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
2009a04: d6 06 20 08 ld [ %i0 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
2009a08: 10 80 00 33 b 2009ad4 <_Heap_Walk+0x25c>
2009a0c: a4 10 00 18 mov %i0, %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;
2009a10: 80 a0 80 0b cmp %g2, %o3
2009a14: 18 80 00 05 bgu 2009a28 <_Heap_Walk+0x1b0>
2009a18: 82 10 20 00 clr %g1
2009a1c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2009a20: 80 a0 40 0b cmp %g1, %o3
2009a24: 82 60 3f ff subx %g0, -1, %g1
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 ) ) {
2009a28: 80 a0 60 00 cmp %g1, 0
2009a2c: 32 80 00 07 bne,a 2009a48 <_Heap_Walk+0x1d0>
2009a30: 90 02 e0 08 add %o3, 8, %o0
(*printer)(
2009a34: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a38: 90 10 00 19 mov %i1, %o0
2009a3c: 92 10 20 01 mov 1, %o1
2009a40: 10 80 00 c7 b 2009d5c <_Heap_Walk+0x4e4>
2009a44: 94 12 a3 a0 or %o2, 0x3a0, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
2009a48: d6 27 bf f8 st %o3, [ %fp + -8 ]
2009a4c: 7f ff e0 25 call 2001ae0 <.urem>
2009a50: 92 10 00 13 mov %l3, %o1
);
return false;
}
if (
2009a54: 80 a2 20 00 cmp %o0, 0
2009a58: 02 80 00 07 be 2009a74 <_Heap_Walk+0x1fc>
2009a5c: d6 07 bf f8 ld [ %fp + -8 ], %o3
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
2009a60: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a64: 90 10 00 19 mov %i1, %o0
2009a68: 92 10 20 01 mov 1, %o1
2009a6c: 10 80 00 bc b 2009d5c <_Heap_Walk+0x4e4>
2009a70: 94 12 a3 c0 or %o2, 0x3c0, %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;
2009a74: c2 02 e0 04 ld [ %o3 + 4 ], %g1
2009a78: 82 08 7f fe and %g1, -2, %g1
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;
2009a7c: 82 02 c0 01 add %o3, %g1, %g1
2009a80: c2 00 60 04 ld [ %g1 + 4 ], %g1
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
2009a84: 80 88 60 01 btst 1, %g1
2009a88: 22 80 00 07 be,a 2009aa4 <_Heap_Walk+0x22c>
2009a8c: d8 02 e0 0c ld [ %o3 + 0xc ], %o4
(*printer)(
2009a90: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a94: 90 10 00 19 mov %i1, %o0
2009a98: 92 10 20 01 mov 1, %o1
2009a9c: 10 80 00 b0 b 2009d5c <_Heap_Walk+0x4e4>
2009aa0: 94 12 a3 f0 or %o2, 0x3f0, %o2
);
return false;
}
if ( free_block->prev != prev_block ) {
2009aa4: 80 a3 00 12 cmp %o4, %l2
2009aa8: 22 80 00 0a be,a 2009ad0 <_Heap_Walk+0x258>
2009aac: a4 10 00 0b mov %o3, %l2
(*printer)(
2009ab0: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009ab4: 90 10 00 19 mov %i1, %o0
2009ab8: 92 10 20 01 mov 1, %o1
2009abc: 94 12 a0 10 or %o2, 0x10, %o2
2009ac0: 9f c7 40 00 call %i5
2009ac4: 01 00 00 00 nop
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009ac8: 10 80 00 9e b 2009d40 <_Heap_Walk+0x4c8>
2009acc: 82 10 20 00 clr %g1 ! 0 <PROM_START>
return false;
}
prev_block = free_block;
free_block = free_block->next;
2009ad0: 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 ) {
2009ad4: 80 a2 c0 18 cmp %o3, %i0
2009ad8: 32 bf ff ce bne,a 2009a10 <_Heap_Walk+0x198>
2009adc: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
2009ae0: 2d 00 80 73 sethi %hi(0x201cc00), %l6
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
2009ae4: 2f 00 80 73 sethi %hi(0x201cc00), %l7
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
2009ae8: ac 15 a1 d0 or %l6, 0x1d0, %l6
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
2009aec: ae 15 e1 b8 or %l7, 0x1b8, %l7
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
2009af0: 2b 00 80 73 sethi %hi(0x201cc00), %l5
- 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;
2009af4: c2 06 a0 04 ld [ %i2 + 4 ], %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;
2009af8: c6 06 20 20 ld [ %i0 + 0x20 ], %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;
2009afc: a4 08 7f fe and %g1, -2, %l2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
2009b00: a6 06 80 12 add %i2, %l2, %l3
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;
2009b04: 80 a0 c0 13 cmp %g3, %l3
2009b08: 18 80 00 05 bgu 2009b1c <_Heap_Walk+0x2a4> <== NEVER TAKEN
2009b0c: 84 10 20 00 clr %g2
2009b10: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
2009b14: 80 a0 80 13 cmp %g2, %l3
2009b18: 84 60 3f ff subx %g0, -1, %g2
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
2009b1c: 80 a0 a0 00 cmp %g2, 0
2009b20: 12 80 00 07 bne 2009b3c <_Heap_Walk+0x2c4>
2009b24: 84 1e 80 11 xor %i2, %l1, %g2
(*printer)(
2009b28: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009b2c: 90 10 00 19 mov %i1, %o0
2009b30: 92 10 20 01 mov 1, %o1
2009b34: 10 80 00 2c b 2009be4 <_Heap_Walk+0x36c>
2009b38: 94 12 a0 48 or %o2, 0x48, %o2
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;
2009b3c: 80 a0 00 02 cmp %g0, %g2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
2009b40: c2 27 bf fc st %g1, [ %fp + -4 ]
2009b44: a8 40 20 00 addx %g0, 0, %l4
2009b48: 90 10 00 12 mov %l2, %o0
2009b4c: 7f ff df e5 call 2001ae0 <.urem>
2009b50: 92 10 00 1c mov %i4, %o1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
2009b54: 80 a2 20 00 cmp %o0, 0
2009b58: 02 80 00 0c be 2009b88 <_Heap_Walk+0x310>
2009b5c: c2 07 bf fc ld [ %fp + -4 ], %g1
2009b60: 80 8d 20 ff btst 0xff, %l4
2009b64: 02 80 00 0a be 2009b8c <_Heap_Walk+0x314>
2009b68: 80 a4 80 10 cmp %l2, %l0
(*printer)(
2009b6c: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009b70: 90 10 00 19 mov %i1, %o0
2009b74: 92 10 20 01 mov 1, %o1
2009b78: 94 12 a0 78 or %o2, 0x78, %o2
2009b7c: 96 10 00 1a mov %i2, %o3
2009b80: 10 bf ff d0 b 2009ac0 <_Heap_Walk+0x248>
2009b84: 98 10 00 12 mov %l2, %o4
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
2009b88: 80 a4 80 10 cmp %l2, %l0
2009b8c: 1a 80 00 0d bcc 2009bc0 <_Heap_Walk+0x348>
2009b90: 80 a4 c0 1a cmp %l3, %i2
2009b94: 80 8d 20 ff btst 0xff, %l4
2009b98: 02 80 00 0a be 2009bc0 <_Heap_Walk+0x348> <== NEVER TAKEN
2009b9c: 80 a4 c0 1a cmp %l3, %i2
(*printer)(
2009ba0: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009ba4: 90 10 00 19 mov %i1, %o0
2009ba8: 92 10 20 01 mov 1, %o1
2009bac: 94 12 a0 a8 or %o2, 0xa8, %o2
2009bb0: 96 10 00 1a mov %i2, %o3
2009bb4: 98 10 00 12 mov %l2, %o4
2009bb8: 10 80 00 3d b 2009cac <_Heap_Walk+0x434>
2009bbc: 9a 10 00 10 mov %l0, %o5
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
2009bc0: 38 80 00 0c bgu,a 2009bf0 <_Heap_Walk+0x378>
2009bc4: a8 08 60 01 and %g1, 1, %l4
2009bc8: 80 8d 20 ff btst 0xff, %l4
2009bcc: 02 80 00 09 be 2009bf0 <_Heap_Walk+0x378>
2009bd0: a8 08 60 01 and %g1, 1, %l4
(*printer)(
2009bd4: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009bd8: 90 10 00 19 mov %i1, %o0
2009bdc: 92 10 20 01 mov 1, %o1
2009be0: 94 12 a0 d8 or %o2, 0xd8, %o2
2009be4: 96 10 00 1a mov %i2, %o3
2009be8: 10 bf ff b6 b 2009ac0 <_Heap_Walk+0x248>
2009bec: 98 10 00 13 mov %l3, %o4
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;
2009bf0: c2 04 e0 04 ld [ %l3 + 4 ], %g1
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
2009bf4: 80 88 60 01 btst 1, %g1
2009bf8: 12 80 00 40 bne 2009cf8 <_Heap_Walk+0x480>
2009bfc: 90 10 00 19 mov %i1, %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 ?
2009c00: da 06 a0 0c ld [ %i2 + 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)(
2009c04: c2 06 20 08 ld [ %i0 + 8 ], %g1
2009c08: 05 00 80 72 sethi %hi(0x201c800), %g2
return _Heap_Free_list_head(heap)->next;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_last( Heap_Control *heap )
{
return _Heap_Free_list_tail(heap)->prev;
2009c0c: c8 06 20 0c ld [ %i0 + 0xc ], %g4
2009c10: 80 a3 40 01 cmp %o5, %g1
2009c14: 02 80 00 07 be 2009c30 <_Heap_Walk+0x3b8>
2009c18: 86 10 a1 b8 or %g2, 0x1b8, %g3
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
2009c1c: 80 a3 40 18 cmp %o5, %i0
2009c20: 12 80 00 04 bne 2009c30 <_Heap_Walk+0x3b8>
2009c24: 86 15 61 80 or %l5, 0x180, %g3
2009c28: 07 00 80 72 sethi %hi(0x201c800), %g3
2009c2c: 86 10 e1 c8 or %g3, 0x1c8, %g3 ! 201c9c8 <__log2table+0x130>
block->next,
block->next == last_free_block ?
2009c30: c4 06 a0 08 ld [ %i2 + 8 ], %g2
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)(
2009c34: 1f 00 80 72 sethi %hi(0x201c800), %o7
2009c38: 80 a0 80 04 cmp %g2, %g4
2009c3c: 02 80 00 07 be 2009c58 <_Heap_Walk+0x3e0>
2009c40: 82 13 e1 d8 or %o7, 0x1d8, %g1
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
2009c44: 80 a0 80 18 cmp %g2, %i0
2009c48: 12 80 00 04 bne 2009c58 <_Heap_Walk+0x3e0>
2009c4c: 82 15 61 80 or %l5, 0x180, %g1
2009c50: 03 00 80 72 sethi %hi(0x201c800), %g1
2009c54: 82 10 61 e8 or %g1, 0x1e8, %g1 ! 201c9e8 <__log2table+0x150>
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)(
2009c58: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
2009c5c: c4 23 a0 60 st %g2, [ %sp + 0x60 ]
2009c60: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2009c64: 90 10 00 19 mov %i1, %o0
2009c68: 92 10 20 00 clr %o1
2009c6c: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009c70: 96 10 00 1a mov %i2, %o3
2009c74: 94 12 a1 10 or %o2, 0x110, %o2
2009c78: 9f c7 40 00 call %i5
2009c7c: 98 10 00 12 mov %l2, %o4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
2009c80: da 04 c0 00 ld [ %l3 ], %o5
2009c84: 80 a4 80 0d cmp %l2, %o5
2009c88: 02 80 00 0d be 2009cbc <_Heap_Walk+0x444>
2009c8c: 80 a5 20 00 cmp %l4, 0
(*printer)(
2009c90: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009c94: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
2009c98: 90 10 00 19 mov %i1, %o0
2009c9c: 92 10 20 01 mov 1, %o1
2009ca0: 94 12 a1 48 or %o2, 0x148, %o2
2009ca4: 96 10 00 1a mov %i2, %o3
2009ca8: 98 10 00 12 mov %l2, %o4
2009cac: 9f c7 40 00 call %i5
2009cb0: 01 00 00 00 nop
2009cb4: 10 80 00 23 b 2009d40 <_Heap_Walk+0x4c8>
2009cb8: 82 10 20 00 clr %g1 ! 0 <PROM_START>
);
return false;
}
if ( !prev_used ) {
2009cbc: 32 80 00 0a bne,a 2009ce4 <_Heap_Walk+0x46c>
2009cc0: c2 06 20 08 ld [ %i0 + 8 ], %g1
(*printer)(
2009cc4: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009cc8: 90 10 00 19 mov %i1, %o0
2009ccc: 92 10 20 01 mov 1, %o1
2009cd0: 10 80 00 22 b 2009d58 <_Heap_Walk+0x4e0>
2009cd4: 94 12 a1 88 or %o2, 0x188, %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 ) {
2009cd8: 02 80 00 17 be 2009d34 <_Heap_Walk+0x4bc>
2009cdc: 80 a4 c0 1b cmp %l3, %i3
return true;
}
free_block = free_block->next;
2009ce0: c2 00 60 08 ld [ %g1 + 8 ], %g1
)
{
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 ) {
2009ce4: 80 a0 40 18 cmp %g1, %i0
2009ce8: 12 bf ff fc bne 2009cd8 <_Heap_Walk+0x460>
2009cec: 80 a0 40 1a cmp %g1, %i2
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009cf0: 10 80 00 17 b 2009d4c <_Heap_Walk+0x4d4>
2009cf4: 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) {
2009cf8: 80 a5 20 00 cmp %l4, 0
2009cfc: 02 80 00 08 be 2009d1c <_Heap_Walk+0x4a4>
2009d00: 92 10 20 00 clr %o1
(*printer)(
2009d04: 94 10 00 17 mov %l7, %o2
2009d08: 96 10 00 1a mov %i2, %o3
2009d0c: 9f c7 40 00 call %i5
2009d10: 98 10 00 12 mov %l2, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
2009d14: 10 80 00 08 b 2009d34 <_Heap_Walk+0x4bc>
2009d18: 80 a4 c0 1b cmp %l3, %i3
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
2009d1c: da 06 80 00 ld [ %i2 ], %o5
2009d20: 94 10 00 16 mov %l6, %o2
2009d24: 96 10 00 1a mov %i2, %o3
2009d28: 9f c7 40 00 call %i5
2009d2c: 98 10 00 12 mov %l2, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
2009d30: 80 a4 c0 1b cmp %l3, %i3
2009d34: 12 bf ff 70 bne 2009af4 <_Heap_Walk+0x27c>
2009d38: b4 10 00 13 mov %l3, %i2
return true;
2009d3c: 82 10 20 01 mov 1, %g1
}
2009d40: b0 08 60 01 and %g1, 1, %i0
2009d44: 81 c7 e0 08 ret
2009d48: 81 e8 00 00 restore
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009d4c: 90 10 00 19 mov %i1, %o0
2009d50: 92 10 20 01 mov 1, %o1
2009d54: 94 12 a1 f8 or %o2, 0x1f8, %o2
2009d58: 96 10 00 1a mov %i2, %o3
2009d5c: 9f c7 40 00 call %i5
2009d60: 01 00 00 00 nop
2009d64: 10 bf ff f7 b 2009d40 <_Heap_Walk+0x4c8>
2009d68: 82 10 20 00 clr %g1 ! 0 <PROM_START>
02008d1c <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2008d1c: 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 )
2008d20: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2008d24: ba 10 00 18 mov %i0, %i5
* 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 )
2008d28: 80 a0 60 00 cmp %g1, 0
2008d2c: 02 80 00 20 be 2008dac <_Objects_Allocate+0x90> <== NEVER TAKEN
2008d30: b0 10 20 00 clr %i0
/*
* 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 );
2008d34: b8 07 60 20 add %i5, 0x20, %i4
2008d38: 7f ff fd 76 call 2008310 <_Chain_Get>
2008d3c: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
2008d40: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
2008d44: 80 a0 60 00 cmp %g1, 0
2008d48: 02 80 00 19 be 2008dac <_Objects_Allocate+0x90>
2008d4c: 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 ) {
2008d50: 80 a2 20 00 cmp %o0, 0
2008d54: 32 80 00 0a bne,a 2008d7c <_Objects_Allocate+0x60>
2008d58: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
_Objects_Extend_information( information );
2008d5c: 40 00 00 1d call 2008dd0 <_Objects_Extend_information>
2008d60: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
2008d64: 7f ff fd 6b call 2008310 <_Chain_Get>
2008d68: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
2008d6c: b0 92 20 00 orcc %o0, 0, %i0
2008d70: 02 80 00 0f be 2008dac <_Objects_Allocate+0x90>
2008d74: 01 00 00 00 nop
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
2008d78: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
2008d7c: d0 16 20 0a lduh [ %i0 + 0xa ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
2008d80: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
2008d84: 40 00 3e a4 call 2018814 <.udiv>
2008d88: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
2008d8c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2008d90: 91 2a 20 02 sll %o0, 2, %o0
2008d94: c4 00 40 08 ld [ %g1 + %o0 ], %g2
2008d98: 84 00 bf ff add %g2, -1, %g2
2008d9c: c4 20 40 08 st %g2, [ %g1 + %o0 ]
information->inactive--;
2008da0: c2 17 60 2c lduh [ %i5 + 0x2c ], %g1
2008da4: 82 00 7f ff add %g1, -1, %g1
2008da8: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
2008dac: 81 c7 e0 08 ret
2008db0: 81 e8 00 00 restore
02009128 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
2009128: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
200912c: 80 a6 60 00 cmp %i1, 0
2009130: 02 80 00 17 be 200918c <_Objects_Get_information+0x64>
2009134: ba 10 20 00 clr %i5
/*
* 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 );
2009138: 40 00 12 81 call 200db3c <_Objects_API_maximum_class>
200913c: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
2009140: 80 a2 20 00 cmp %o0, 0
2009144: 02 80 00 12 be 200918c <_Objects_Get_information+0x64>
2009148: 80 a6 40 08 cmp %i1, %o0
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
200914c: 18 80 00 10 bgu 200918c <_Objects_Get_information+0x64>
2009150: 03 00 80 76 sethi %hi(0x201d800), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
2009154: b1 2e 20 02 sll %i0, 2, %i0
2009158: 82 10 63 78 or %g1, 0x378, %g1
200915c: c2 00 40 18 ld [ %g1 + %i0 ], %g1
2009160: 80 a0 60 00 cmp %g1, 0
2009164: 02 80 00 0a be 200918c <_Objects_Get_information+0x64> <== NEVER TAKEN
2009168: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
200916c: fa 00 40 19 ld [ %g1 + %i1 ], %i5
if ( !info )
2009170: 80 a7 60 00 cmp %i5, 0
2009174: 02 80 00 06 be 200918c <_Objects_Get_information+0x64> <== NEVER TAKEN
2009178: 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 )
200917c: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
return NULL;
2009180: 80 a0 00 01 cmp %g0, %g1
2009184: 82 60 20 00 subx %g0, 0, %g1
2009188: ba 0f 40 01 and %i5, %g1, %i5
#endif
return info;
}
200918c: 81 c7 e0 08 ret
2009190: 91 e8 00 1d restore %g0, %i5, %o0
0200d1a4 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
200d1a4: 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;
200d1a8: 92 96 20 00 orcc %i0, 0, %o1
200d1ac: 12 80 00 06 bne 200d1c4 <_Objects_Id_to_name+0x20>
200d1b0: 83 32 60 18 srl %o1, 0x18, %g1
200d1b4: 03 00 80 b8 sethi %hi(0x202e000), %g1
200d1b8: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 ! 202e39c <_Per_CPU_Information+0xc>
200d1bc: d2 00 60 08 ld [ %g1 + 8 ], %o1
200d1c0: 83 32 60 18 srl %o1, 0x18, %g1
200d1c4: 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 )
200d1c8: 84 00 7f ff add %g1, -1, %g2
200d1cc: 80 a0 a0 02 cmp %g2, 2
200d1d0: 18 80 00 16 bgu 200d228 <_Objects_Id_to_name+0x84>
200d1d4: ba 10 20 03 mov 3, %i5
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
200d1d8: 10 80 00 16 b 200d230 <_Objects_Id_to_name+0x8c>
200d1dc: 83 28 60 02 sll %g1, 2, %g1
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
200d1e0: 85 28 a0 02 sll %g2, 2, %g2
200d1e4: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
200d1e8: 80 a2 20 00 cmp %o0, 0
200d1ec: 02 80 00 0f be 200d228 <_Objects_Id_to_name+0x84> <== NEVER TAKEN
200d1f0: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
200d1f4: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
200d1f8: 80 a0 60 00 cmp %g1, 0
200d1fc: 12 80 00 0b bne 200d228 <_Objects_Id_to_name+0x84> <== NEVER TAKEN
200d200: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
200d204: 7f ff ff ca call 200d12c <_Objects_Get>
200d208: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
200d20c: 80 a2 20 00 cmp %o0, 0
200d210: 02 80 00 06 be 200d228 <_Objects_Id_to_name+0x84>
200d214: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
200d218: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
200d21c: ba 10 20 00 clr %i5
the_object = _Objects_Get( information, tmpId, &ignored_location );
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
200d220: 40 00 03 cb call 200e14c <_Thread_Enable_dispatch>
200d224: c2 26 40 00 st %g1, [ %i1 ]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
200d228: 81 c7 e0 08 ret
200d22c: 91 e8 00 1d restore %g0, %i5, %o0
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
200d230: 05 00 80 b7 sethi %hi(0x202dc00), %g2
200d234: 84 10 a1 78 or %g2, 0x178, %g2 ! 202dd78 <_Objects_Information_table>
200d238: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200d23c: 80 a0 60 00 cmp %g1, 0
200d240: 12 bf ff e8 bne 200d1e0 <_Objects_Id_to_name+0x3c>
200d244: 85 32 60 1b srl %o1, 0x1b, %g2
200d248: 30 bf ff f8 b,a 200d228 <_Objects_Id_to_name+0x84>
0200ef3c <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
200ef3c: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
200ef40: f6 06 20 08 ld [ %i0 + 8 ], %i3
*
* 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;
200ef44: 39 00 80 78 sethi %hi(0x201e000), %i4
200ef48: b5 36 e0 18 srl %i3, 0x18, %i2
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 ];
200ef4c: b7 2e e0 10 sll %i3, 0x10, %i3
200ef50: b4 0e a0 07 and %i2, 7, %i2
200ef54: b7 36 e0 0e srl %i3, 0xe, %i3
200ef58: b4 06 a0 04 add %i2, 4, %i2
200ef5c: 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;
200ef60: 82 17 20 28 or %i4, 0x28, %g1
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200ef64: ba 10 20 01 mov 1, %i5
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
200ef68: 84 10 20 01 mov 1, %g2
for ( index = 1 ; index <= max ; ++index ) {
200ef6c: 10 80 00 18 b 200efcc <_POSIX_Keys_Run_destructors+0x90>
200ef70: f2 10 60 10 lduh [ %g1 + 0x10 ], %i1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
200ef74: 86 17 20 28 or %i4, 0x28, %g3
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
200ef78: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
200ef7c: 83 28 60 02 sll %g1, 2, %g1
200ef80: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
200ef84: 80 a0 60 00 cmp %g1, 0
200ef88: 22 80 00 11 be,a 200efcc <_POSIX_Keys_Run_destructors+0x90>
200ef8c: ba 07 60 01 inc %i5
200ef90: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200ef94: 80 a0 e0 00 cmp %g3, 0
200ef98: 02 80 00 0c be 200efc8 <_POSIX_Keys_Run_destructors+0x8c>
200ef9c: 86 00 40 1a add %g1, %i2, %g3
void *value = key->Values [ thread_api ][ thread_index ];
200efa0: c6 00 e0 04 ld [ %g3 + 4 ], %g3
200efa4: d0 00 c0 1b ld [ %g3 + %i3 ], %o0
if ( value != NULL ) {
200efa8: 80 a2 20 00 cmp %o0, 0
200efac: 22 80 00 08 be,a 200efcc <_POSIX_Keys_Run_destructors+0x90><== ALWAYS TAKEN
200efb0: ba 07 60 01 inc %i5
key->Values [ thread_api ][ thread_index ] = NULL;
200efb4: c0 20 c0 1b clr [ %g3 + %i3 ] <== NOT EXECUTED
(*key->destructor)( value );
200efb8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
200efbc: 9f c0 40 00 call %g1 <== NOT EXECUTED
200efc0: 01 00 00 00 nop <== NOT EXECUTED
done = false;
200efc4: 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 ) {
200efc8: ba 07 60 01 inc %i5
200efcc: 83 2f 60 10 sll %i5, 0x10, %g1
200efd0: 83 30 60 10 srl %g1, 0x10, %g1
200efd4: 80 a0 40 19 cmp %g1, %i1
200efd8: 08 bf ff e7 bleu 200ef74 <_POSIX_Keys_Run_destructors+0x38>
200efdc: 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 ) {
200efe0: 02 bf ff e1 be 200ef64 <_POSIX_Keys_Run_destructors+0x28> <== NEVER TAKEN
200efe4: 82 17 20 28 or %i4, 0x28, %g1
done = false;
}
}
}
}
}
200efe8: 81 c7 e0 08 ret
200efec: 81 e8 00 00 restore
0200ca3c <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
200ca3c: 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(
200ca40: 11 00 80 ab sethi %hi(0x202ac00), %o0
200ca44: 92 10 00 18 mov %i0, %o1
200ca48: 90 12 23 3c or %o0, 0x33c, %o0
200ca4c: 40 00 0c d2 call 200fd94 <_Objects_Get>
200ca50: 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 ) {
200ca54: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ca58: 80 a0 60 00 cmp %g1, 0
200ca5c: 12 80 00 45 bne 200cb70 <_POSIX_Message_queue_Receive_support+0x134>
200ca60: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
200ca64: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200ca68: 84 08 60 03 and %g1, 3, %g2
200ca6c: 80 a0 a0 01 cmp %g2, 1
200ca70: 32 80 00 08 bne,a 200ca90 <_POSIX_Message_queue_Receive_support+0x54>
200ca74: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
_Thread_Enable_dispatch();
200ca78: 40 00 10 a1 call 2010cfc <_Thread_Enable_dispatch>
200ca7c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
200ca80: 40 00 28 55 call 2016bd4 <__errno>
200ca84: 01 00 00 00 nop
200ca88: 10 80 00 0b b 200cab4 <_POSIX_Message_queue_Receive_support+0x78>
200ca8c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
200ca90: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200ca94: 80 a6 80 02 cmp %i2, %g2
200ca98: 1a 80 00 09 bcc 200cabc <_POSIX_Message_queue_Receive_support+0x80>
200ca9c: 84 10 3f ff mov -1, %g2
_Thread_Enable_dispatch();
200caa0: 40 00 10 97 call 2010cfc <_Thread_Enable_dispatch>
200caa4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EMSGSIZE );
200caa8: 40 00 28 4b call 2016bd4 <__errno>
200caac: 01 00 00 00 nop
200cab0: 82 10 20 7a mov 0x7a, %g1 ! 7a <PROM_START+0x7a>
200cab4: 10 80 00 2d b 200cb68 <_POSIX_Message_queue_Receive_support+0x12c>
200cab8: c2 22 00 00 st %g1, [ %o0 ]
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
200cabc: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
200cac0: 80 a7 20 00 cmp %i4, 0
200cac4: 02 80 00 06 be 200cadc <_POSIX_Message_queue_Receive_support+0xa0>
200cac8: 98 10 20 00 clr %o4
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
200cacc: 05 00 00 10 sethi %hi(0x4000), %g2
200cad0: 82 08 40 02 and %g1, %g2, %g1
200cad4: 80 a0 00 01 cmp %g0, %g1
200cad8: 98 60 3f ff subx %g0, -1, %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
200cadc: 90 02 20 1c add %o0, 0x1c, %o0
200cae0: 92 10 00 18 mov %i0, %o1
200cae4: 94 10 00 19 mov %i1, %o2
200cae8: 96 07 bf fc add %fp, -4, %o3
200caec: 98 0b 20 01 and %o4, 1, %o4
200caf0: 40 00 08 72 call 200ecb8 <_CORE_message_queue_Seize>
200caf4: 9a 10 00 1d mov %i5, %o5
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
200caf8: 40 00 10 81 call 2010cfc <_Thread_Enable_dispatch>
200cafc: 01 00 00 00 nop
if (msg_prio) {
200cb00: 80 a6 e0 00 cmp %i3, 0
200cb04: 02 80 00 08 be 200cb24 <_POSIX_Message_queue_Receive_support+0xe8><== NEVER TAKEN
200cb08: 03 00 80 ab sethi %hi(0x202ac00), %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
200cb0c: c2 00 63 bc ld [ %g1 + 0x3bc ], %g1 ! 202afbc <_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);
200cb10: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
200cb14: 83 38 a0 1f sra %g2, 0x1f, %g1
200cb18: 84 18 40 02 xor %g1, %g2, %g2
200cb1c: 82 20 80 01 sub %g2, %g1, %g1
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
200cb20: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
200cb24: 3b 00 80 ab sethi %hi(0x202ac00), %i5
200cb28: ba 17 63 b0 or %i5, 0x3b0, %i5 ! 202afb0 <_Per_CPU_Information>
200cb2c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cb30: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
200cb34: 80 a0 60 00 cmp %g1, 0
200cb38: 12 80 00 05 bne 200cb4c <_POSIX_Message_queue_Receive_support+0x110>
200cb3c: 01 00 00 00 nop
return length_out;
200cb40: f0 07 bf fc ld [ %fp + -4 ], %i0
200cb44: 81 c7 e0 08 ret
200cb48: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one(
200cb4c: 40 00 28 22 call 2016bd4 <__errno>
200cb50: 01 00 00 00 nop
200cb54: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cb58: b8 10 00 08 mov %o0, %i4
200cb5c: 40 00 00 9b call 200cdc8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
200cb60: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
200cb64: d0 27 00 00 st %o0, [ %i4 ]
200cb68: 81 c7 e0 08 ret
200cb6c: 91 e8 3f ff restore %g0, -1, %o0
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
200cb70: 40 00 28 19 call 2016bd4 <__errno>
200cb74: b0 10 3f ff mov -1, %i0
200cb78: 82 10 20 09 mov 9, %g1
200cb7c: c2 22 00 00 st %g1, [ %o0 ]
}
200cb80: 81 c7 e0 08 ret
200cb84: 81 e8 00 00 restore
0200ee50 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
200ee50: 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)
200ee54: 80 a6 a0 00 cmp %i2, 0
200ee58: 22 80 00 06 be,a 200ee70 <_POSIX_Semaphore_Create_support+0x20>
200ee5c: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( ENOSYS );
200ee60: 40 00 0a 61 call 20117e4 <__errno>
200ee64: 01 00 00 00 nop
200ee68: 10 80 00 21 b 200eeec <_POSIX_Semaphore_Create_support+0x9c>
200ee6c: 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++;
200ee70: c4 00 63 30 ld [ %g1 + 0x330 ], %g2
200ee74: 84 00 a0 01 inc %g2
200ee78: c4 20 63 30 st %g2, [ %g1 + 0x330 ]
return _Thread_Dispatch_disable_level;
200ee7c: c2 00 63 30 ld [ %g1 + 0x330 ], %g1
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
200ee80: 35 00 80 8a sethi %hi(0x2022800), %i2
200ee84: 7f ff ee cc call 200a9b4 <_Objects_Allocate>
200ee88: 90 16 a2 30 or %i2, 0x230, %o0 ! 2022a30 <_POSIX_Semaphore_Information>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
200ee8c: ba 92 20 00 orcc %o0, 0, %i5
200ee90: 12 80 00 08 bne 200eeb0 <_POSIX_Semaphore_Create_support+0x60>
200ee94: 80 a6 20 00 cmp %i0, 0
_Thread_Enable_dispatch();
200ee98: 7f ff f3 ef call 200be54 <_Thread_Enable_dispatch>
200ee9c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSPC );
200eea0: 40 00 0a 51 call 20117e4 <__errno>
200eea4: 01 00 00 00 nop
200eea8: 10 80 00 11 b 200eeec <_POSIX_Semaphore_Create_support+0x9c>
200eeac: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
200eeb0: 02 80 00 12 be 200eef8 <_POSIX_Semaphore_Create_support+0xa8>
200eeb4: 92 10 00 19 mov %i1, %o1
name = _Workspace_String_duplicate( name_arg, name_len );
200eeb8: 40 00 04 72 call 2010080 <_Workspace_String_duplicate>
200eebc: 90 10 00 18 mov %i0, %o0
if ( !name ) {
200eec0: b2 92 20 00 orcc %o0, 0, %i1
200eec4: 12 80 00 0f bne 200ef00 <_POSIX_Semaphore_Create_support+0xb0><== ALWAYS TAKEN
200eec8: 80 a6 60 00 cmp %i1, 0
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
200eecc: 90 16 a2 30 or %i2, 0x230, %o0 <== NOT EXECUTED
200eed0: 7f ff ef 92 call 200ad18 <_Objects_Free> <== NOT EXECUTED
200eed4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
200eed8: 7f ff f3 df call 200be54 <_Thread_Enable_dispatch> <== NOT EXECUTED
200eedc: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
200eee0: 40 00 0a 41 call 20117e4 <__errno> <== NOT EXECUTED
200eee4: 01 00 00 00 nop <== NOT EXECUTED
200eee8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
200eeec: c2 22 00 00 st %g1, [ %o0 ]
200eef0: 81 c7 e0 08 ret
200eef4: 91 e8 3f ff restore %g0, -1, %o0
}
} else {
name = NULL;
200eef8: b2 10 20 00 clr %i1
}
the_semaphore->process_shared = pshared;
if ( name ) {
200eefc: 80 a6 60 00 cmp %i1, 0
200ef00: 02 80 00 08 be 200ef20 <_POSIX_Semaphore_Create_support+0xd0>
200ef04: c0 27 60 10 clr [ %i5 + 0x10 ]
the_semaphore->named = true;
200ef08: 82 10 20 01 mov 1, %g1
200ef0c: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
200ef10: 82 10 20 01 mov 1, %g1
200ef14: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
200ef18: 10 80 00 05 b 200ef2c <_POSIX_Semaphore_Create_support+0xdc>
200ef1c: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
} else {
the_semaphore->named = false;
200ef20: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
200ef24: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
200ef28: 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;
200ef2c: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200ef30: 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;
200ef34: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200ef38: 92 07 60 5c add %i5, 0x5c, %o1
200ef3c: 94 10 00 1b mov %i3, %o2
200ef40: 7f ff ed 02 call 200a348 <_CORE_semaphore_Initialize>
200ef44: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
200ef48: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200ef4c: 05 00 80 8a sethi %hi(0x2022800), %g2
200ef50: c4 00 a2 4c ld [ %g2 + 0x24c ], %g2 ! 2022a4c <_POSIX_Semaphore_Information+0x1c>
200ef54: 83 28 60 02 sll %g1, 2, %g1
200ef58: 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;
200ef5c: f2 27 60 0c st %i1, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
200ef60: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
200ef64: 7f ff f3 bc call 200be54 <_Thread_Enable_dispatch>
200ef68: b0 10 20 00 clr %i0
return 0;
}
200ef6c: 81 c7 e0 08 ret
200ef70: 81 e8 00 00 restore
0200c8fc <_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 ];
200c8fc: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
200c900: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
200c904: 80 a0 a0 00 cmp %g2, 0
200c908: 12 80 00 13 bne 200c954 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58><== NEVER TAKEN
200c90c: 01 00 00 00 nop
200c910: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
200c914: 80 a0 a0 01 cmp %g2, 1
200c918: 12 80 00 0f bne 200c954 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58>
200c91c: 01 00 00 00 nop
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
200c920: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
200c924: 80 a0 60 00 cmp %g1, 0
200c928: 02 80 00 0b be 200c954 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58>
200c92c: 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--;
200c930: 03 00 80 78 sethi %hi(0x201e000), %g1
200c934: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 201e0c0 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
200c938: 92 10 3f ff mov -1, %o1
200c93c: 84 00 bf ff add %g2, -1, %g2
200c940: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
return _Thread_Dispatch_disable_level;
200c944: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1
200c948: 82 13 c0 00 mov %o7, %g1
200c94c: 40 00 01 b6 call 200d024 <_POSIX_Thread_Exit>
200c950: 9e 10 40 00 mov %g1, %o7
} else
_Thread_Enable_dispatch();
200c954: 82 13 c0 00 mov %o7, %g1
200c958: 7f ff f6 42 call 200a260 <_Thread_Enable_dispatch>
200c95c: 9e 10 40 00 mov %g1, %o7
0200dcb0 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
200dcb0: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
200dcb4: d0 06 40 00 ld [ %i1 ], %o0
200dcb8: 7f ff ff f3 call 200dc84 <_POSIX_Priority_Is_valid>
200dcbc: ba 10 00 18 mov %i0, %i5
200dcc0: 80 8a 20 ff btst 0xff, %o0
200dcc4: 02 80 00 11 be 200dd08 <_POSIX_Thread_Translate_sched_param+0x58><== NEVER TAKEN
200dcc8: b0 10 20 16 mov 0x16, %i0
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
200dccc: c0 26 80 00 clr [ %i2 ]
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
200dcd0: 80 a7 60 00 cmp %i5, 0
200dcd4: 12 80 00 06 bne 200dcec <_POSIX_Thread_Translate_sched_param+0x3c>
200dcd8: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200dcdc: 82 10 20 01 mov 1, %g1
200dce0: c2 26 80 00 st %g1, [ %i2 ]
return 0;
200dce4: 81 c7 e0 08 ret
200dce8: 91 e8 20 00 restore %g0, 0, %o0
}
if ( policy == SCHED_FIFO ) {
200dcec: 80 a7 60 01 cmp %i5, 1
200dcf0: 02 80 00 06 be 200dd08 <_POSIX_Thread_Translate_sched_param+0x58>
200dcf4: b0 10 20 00 clr %i0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
200dcf8: 80 a7 60 02 cmp %i5, 2
200dcfc: 32 80 00 05 bne,a 200dd10 <_POSIX_Thread_Translate_sched_param+0x60>
200dd00: 80 a7 60 04 cmp %i5, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
200dd04: fa 26 80 00 st %i5, [ %i2 ]
return 0;
200dd08: 81 c7 e0 08 ret
200dd0c: 81 e8 00 00 restore
}
if ( policy == SCHED_SPORADIC ) {
200dd10: 12 bf ff fe bne 200dd08 <_POSIX_Thread_Translate_sched_param+0x58>
200dd14: b0 10 20 16 mov 0x16, %i0
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
200dd18: c2 06 60 08 ld [ %i1 + 8 ], %g1
200dd1c: 80 a0 60 00 cmp %g1, 0
200dd20: 32 80 00 07 bne,a 200dd3c <_POSIX_Thread_Translate_sched_param+0x8c>
200dd24: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200dd28: c2 06 60 0c ld [ %i1 + 0xc ], %g1
200dd2c: 80 a0 60 00 cmp %g1, 0
200dd30: 02 80 00 1d be 200dda4 <_POSIX_Thread_Translate_sched_param+0xf4>
200dd34: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
200dd38: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200dd3c: 80 a0 60 00 cmp %g1, 0
200dd40: 12 80 00 06 bne 200dd58 <_POSIX_Thread_Translate_sched_param+0xa8>
200dd44: 01 00 00 00 nop
200dd48: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200dd4c: 80 a0 60 00 cmp %g1, 0
200dd50: 02 bf ff ee be 200dd08 <_POSIX_Thread_Translate_sched_param+0x58>
200dd54: b0 10 20 16 mov 0x16, %i0
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
200dd58: 7f ff f7 4f call 200ba94 <_Timespec_To_ticks>
200dd5c: 90 06 60 08 add %i1, 8, %o0
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
200dd60: b0 10 20 16 mov 0x16, %i0
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 ) <
200dd64: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
200dd68: 7f ff f7 4b call 200ba94 <_Timespec_To_ticks>
200dd6c: 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 ) <
200dd70: 80 a7 40 08 cmp %i5, %o0
200dd74: 0a 80 00 0c bcs 200dda4 <_POSIX_Thread_Translate_sched_param+0xf4>
200dd78: 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 ) )
200dd7c: 7f ff ff c2 call 200dc84 <_POSIX_Priority_Is_valid>
200dd80: d0 06 60 04 ld [ %i1 + 4 ], %o0
200dd84: 80 8a 20 ff btst 0xff, %o0
200dd88: 02 bf ff e0 be 200dd08 <_POSIX_Thread_Translate_sched_param+0x58>
200dd8c: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
200dd90: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
200dd94: b0 10 20 00 clr %i0
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
200dd98: 03 00 80 1f sethi %hi(0x2007c00), %g1
200dd9c: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 2007da0 <_POSIX_Threads_Sporadic_budget_callout>
200dda0: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
return EINVAL;
}
200dda4: 81 c7 e0 08 ret
200dda8: 81 e8 00 00 restore
0200cc3c <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
200cc3c: 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 ];
200cc40: f0 06 61 5c ld [ %i1 + 0x15c ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
200cc44: 40 00 08 a4 call 200eed4 <_POSIX_Threads_cancel_run>
200cc48: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
200cc4c: 90 10 00 19 mov %i1, %o0
200cc50: 40 00 08 bb call 200ef3c <_POSIX_Keys_Run_destructors>
200cc54: 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 )) )
200cc58: 10 80 00 03 b 200cc64 <_POSIX_Threads_Delete_extension+0x28>
200cc5c: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
200cc60: 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 )) )
200cc64: 7f ff f6 28 call 200a504 <_Thread_queue_Dequeue>
200cc68: 90 10 00 1d mov %i5, %o0
200cc6c: 80 a2 20 00 cmp %o0, 0
200cc70: 32 bf ff fc bne,a 200cc60 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
200cc74: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
200cc78: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
200cc7c: 80 a0 60 04 cmp %g1, 4
200cc80: 32 80 00 05 bne,a 200cc94 <_POSIX_Threads_Delete_extension+0x58>
200cc84: c0 26 61 5c clr [ %i1 + 0x15c ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200cc88: 7f ff f8 da call 200aff0 <_Watchdog_Remove>
200cc8c: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
200cc90: c0 26 61 5c clr [ %i1 + 0x15c ]
_Workspace_Free( api );
200cc94: 7f ff f9 4f call 200b1d0 <_Workspace_Free>
200cc98: 81 e8 00 00 restore
02007b00 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
2007b00: 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;
2007b04: 03 00 80 86 sethi %hi(0x2021800), %g1
2007b08: 82 10 63 6c or %g1, 0x36c, %g1 ! 2021b6c <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
2007b0c: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
2007b10: 80 a6 e0 00 cmp %i3, 0
2007b14: 02 80 00 1d be 2007b88 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007b18: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
2007b1c: 80 a7 60 00 cmp %i5, 0
2007b20: 02 80 00 1a be 2007b88 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007b24: 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 );
2007b28: 40 00 18 a1 call 200ddac <pthread_attr_init>
2007b2c: 90 07 bf bc add %fp, -68, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
2007b30: 92 10 20 02 mov 2, %o1
2007b34: 40 00 18 aa call 200dddc <pthread_attr_setinheritsched>
2007b38: 90 07 bf bc add %fp, -68, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
2007b3c: d2 07 60 04 ld [ %i5 + 4 ], %o1
2007b40: 40 00 18 b6 call 200de18 <pthread_attr_setstacksize>
2007b44: 90 07 bf bc add %fp, -68, %o0
status = pthread_create(
2007b48: d4 07 40 00 ld [ %i5 ], %o2
2007b4c: 90 07 bf fc add %fp, -4, %o0
2007b50: 92 07 bf bc add %fp, -68, %o1
2007b54: 96 10 20 00 clr %o3
2007b58: 7f ff ff 17 call 20077b4 <pthread_create>
2007b5c: ba 07 60 08 add %i5, 8, %i5
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
2007b60: 80 a2 20 00 cmp %o0, 0
2007b64: 02 80 00 05 be 2007b78 <_POSIX_Threads_Initialize_user_threads_body+0x78>
2007b68: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
2007b6c: 90 10 20 02 mov 2, %o0
2007b70: 40 00 08 04 call 2009b80 <_Internal_error_Occurred>
2007b74: 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++ ) {
2007b78: b8 07 20 01 inc %i4
2007b7c: 80 a7 00 1b cmp %i4, %i3
2007b80: 12 bf ff ea bne 2007b28 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
2007b84: 01 00 00 00 nop
2007b88: 81 c7 e0 08 ret
2007b8c: 81 e8 00 00 restore
0200cd90 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
200cd90: 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 ];
200cd94: 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 );
200cd98: 40 00 04 2a call 200de40 <_Timespec_To_ticks>
200cd9c: 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);
200cda0: 03 00 80 73 sethi %hi(0x201cc00), %g1
200cda4: d2 08 62 74 ldub [ %g1 + 0x274 ], %o1 ! 201ce74 <rtems_maximum_priority>
200cda8: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->cpu_time_budget = ticks;
200cdac: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
200cdb0: 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 ) {
200cdb4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
200cdb8: 80 a0 60 00 cmp %g1, 0
200cdbc: 12 80 00 08 bne 200cddc <_POSIX_Threads_Sporadic_budget_TSR+0x4c><== NEVER TAKEN
200cdc0: 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 ) {
200cdc4: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200cdc8: 80 a0 40 09 cmp %g1, %o1
200cdcc: 08 80 00 04 bleu 200cddc <_POSIX_Threads_Sporadic_budget_TSR+0x4c>
200cdd0: 90 10 00 19 mov %i1, %o0
_Thread_Change_priority( the_thread, new_priority, true );
200cdd4: 7f ff f3 c6 call 2009cec <_Thread_Change_priority>
200cdd8: 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 );
200cddc: 40 00 04 19 call 200de40 <_Timespec_To_ticks>
200cde0: 90 07 60 90 add %i5, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cde4: 31 00 80 77 sethi %hi(0x201dc00), %i0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
200cde8: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cdec: b0 16 20 d0 or %i0, 0xd0, %i0
200cdf0: 7f ff f8 26 call 200ae88 <_Watchdog_Insert>
200cdf4: 93 ef 60 a8 restore %i5, 0xa8, %o1
0200cdf8 <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200cdf8: 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 */
200cdfc: 86 10 3f ff mov -1, %g3
200ce00: c4 00 a0 8c ld [ %g2 + 0x8c ], %g2
200ce04: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
200ce08: 07 00 80 73 sethi %hi(0x201cc00), %g3
200ce0c: d2 08 e2 74 ldub [ %g3 + 0x274 ], %o1 ! 201ce74 <rtems_maximum_priority>
200ce10: 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 ) {
200ce14: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
200ce18: 80 a0 a0 00 cmp %g2, 0
200ce1c: 12 80 00 09 bne 200ce40 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ce20: 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 ) {
200ce24: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200ce28: 80 a0 40 09 cmp %g1, %o1
200ce2c: 1a 80 00 05 bcc 200ce40 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ce30: 94 10 20 01 mov 1, %o2
_Thread_Change_priority( the_thread, new_priority, true );
200ce34: 82 13 c0 00 mov %o7, %g1
200ce38: 7f ff f3 ad call 2009cec <_Thread_Change_priority>
200ce3c: 9e 10 40 00 mov %g1, %o7
200ce40: 81 c3 e0 08 retl <== NOT EXECUTED
020075b8 <_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)
{
20075b8: 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;
20075bc: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
20075c0: 82 00 60 01 inc %g1
20075c4: c2 26 60 68 st %g1, [ %i1 + 0x68 ]
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
20075c8: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
20075cc: 80 a0 60 00 cmp %g1, 0
20075d0: 32 80 00 07 bne,a 20075ec <_POSIX_Timer_TSR+0x34>
20075d4: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
20075d8: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
20075dc: 80 a0 60 00 cmp %g1, 0
20075e0: 02 80 00 1e be 2007658 <_POSIX_Timer_TSR+0xa0> <== NEVER TAKEN
20075e4: 82 10 20 04 mov 4, %g1
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
20075e8: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
20075ec: d4 06 60 08 ld [ %i1 + 8 ], %o2
20075f0: 90 06 60 10 add %i1, 0x10, %o0
20075f4: 17 00 80 1d sethi %hi(0x2007400), %o3
20075f8: 98 10 00 19 mov %i1, %o4
20075fc: 40 00 18 34 call 200d6cc <_POSIX_Timer_Insert_helper>
2007600: 96 12 e1 b8 or %o3, 0x1b8, %o3
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
2007604: 80 8a 20 ff btst 0xff, %o0
2007608: 02 80 00 19 be 200766c <_POSIX_Timer_TSR+0xb4> <== NEVER TAKEN
200760c: 01 00 00 00 nop
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
2007610: 40 00 05 d7 call 2008d6c <_TOD_Get_as_timestamp>
2007614: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007618: 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);
200761c: 94 10 20 00 clr %o2
2007620: 90 10 00 1c mov %i4, %o0
2007624: 92 10 00 1d mov %i5, %o1
2007628: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
200762c: 40 00 48 d0 call 201996c <__divdi3>
2007630: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007634: 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);
2007638: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
200763c: 94 10 20 00 clr %o2
2007640: 92 10 00 1d mov %i5, %o1
2007644: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007648: 40 00 49 af call 2019d04 <__moddi3>
200764c: 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;
2007650: 82 10 20 03 mov 3, %g1
2007654: 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 ) ) {
2007658: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
200765c: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
2007660: 40 00 17 0f call 200d29c <pthread_kill>
2007664: 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;
2007668: c0 26 60 68 clr [ %i1 + 0x68 ]
200766c: 81 c7 e0 08 ret
2007670: 81 e8 00 00 restore
0200eff0 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
200eff0: 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,
200eff4: 98 10 20 01 mov 1, %o4
200eff8: 90 10 00 18 mov %i0, %o0
200effc: 92 10 00 19 mov %i1, %o1
200f000: 94 07 bf f4 add %fp, -12, %o2
200f004: 40 00 00 2e call 200f0bc <_POSIX_signals_Clear_signals>
200f008: 96 10 00 1a mov %i2, %o3
200f00c: 80 8a 20 ff btst 0xff, %o0
200f010: 02 80 00 28 be 200f0b0 <_POSIX_signals_Check_signal+0xc0>
200f014: 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 )
200f018: 85 2e 60 02 sll %i1, 2, %g2
200f01c: 35 00 80 78 sethi %hi(0x201e000), %i2
200f020: b7 2e 60 04 sll %i1, 4, %i3
200f024: b4 16 a1 b0 or %i2, 0x1b0, %i2
200f028: b6 26 c0 02 sub %i3, %g2, %i3
200f02c: 84 06 80 1b add %i2, %i3, %g2
200f030: fa 00 a0 08 ld [ %g2 + 8 ], %i5
200f034: 80 a7 60 01 cmp %i5, 1
200f038: 02 80 00 1e be 200f0b0 <_POSIX_signals_Check_signal+0xc0> <== NEVER TAKEN
200f03c: 90 07 bf cc add %fp, -52, %o0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
200f040: f8 06 20 d0 ld [ %i0 + 0xd0 ], %i4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
200f044: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200f048: 82 10 40 1c or %g1, %i4, %g1
200f04c: 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,
200f050: 03 00 80 78 sethi %hi(0x201e000), %g1
200f054: d2 00 61 5c ld [ %g1 + 0x15c ], %o1 ! 201e15c <_Per_CPU_Information+0xc>
200f058: 94 10 20 28 mov 0x28, %o2
200f05c: 40 00 04 62 call 20101e4 <memcpy>
200f060: 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 ) {
200f064: c2 06 80 1b ld [ %i2 + %i3 ], %g1
200f068: 80 a0 60 02 cmp %g1, 2
200f06c: 12 80 00 07 bne 200f088 <_POSIX_signals_Check_signal+0x98>
200f070: 90 10 00 19 mov %i1, %o0
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
200f074: 92 07 bf f4 add %fp, -12, %o1
200f078: 9f c7 40 00 call %i5
200f07c: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
200f080: 10 80 00 05 b 200f094 <_POSIX_signals_Check_signal+0xa4>
200f084: 03 00 80 78 sethi %hi(0x201e000), %g1
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
200f088: 9f c7 40 00 call %i5
200f08c: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
200f090: 03 00 80 78 sethi %hi(0x201e000), %g1
200f094: d0 00 61 5c ld [ %g1 + 0x15c ], %o0 ! 201e15c <_Per_CPU_Information+0xc>
200f098: 92 07 bf cc add %fp, -52, %o1
200f09c: 90 02 20 20 add %o0, 0x20, %o0
200f0a0: 40 00 04 51 call 20101e4 <memcpy>
200f0a4: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
200f0a8: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
200f0ac: f8 26 20 d0 st %i4, [ %i0 + 0xd0 ]
return true;
}
200f0b0: b0 08 60 01 and %g1, 1, %i0
200f0b4: 81 c7 e0 08 ret
200f0b8: 81 e8 00 00 restore
0200f7d0 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
200f7d0: 9d e3 bf a0 save %sp, -96, %sp
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
200f7d4: 7f ff cb 86 call 20025ec <sparc_disable_interrupts>
200f7d8: 01 00 00 00 nop
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
200f7dc: 85 2e 20 04 sll %i0, 4, %g2
200f7e0: 83 2e 20 02 sll %i0, 2, %g1
200f7e4: 82 20 80 01 sub %g2, %g1, %g1
200f7e8: 05 00 80 78 sethi %hi(0x201e000), %g2
200f7ec: 84 10 a1 b0 or %g2, 0x1b0, %g2 ! 201e1b0 <_POSIX_signals_Vectors>
200f7f0: c4 00 80 01 ld [ %g2 + %g1 ], %g2
200f7f4: 80 a0 a0 02 cmp %g2, 2
200f7f8: 12 80 00 0a bne 200f820 <_POSIX_signals_Clear_process_signals+0x50>
200f7fc: 84 10 20 01 mov 1, %g2
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
200f800: 05 00 80 78 sethi %hi(0x201e000), %g2
200f804: 84 10 a3 a8 or %g2, 0x3a8, %g2 ! 201e3a8 <_POSIX_signals_Siginfo>
200f808: 86 00 40 02 add %g1, %g2, %g3
200f80c: 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 );
200f810: 86 00 e0 04 add %g3, 4, %g3
200f814: 80 a0 40 03 cmp %g1, %g3
200f818: 12 80 00 08 bne 200f838 <_POSIX_signals_Clear_process_signals+0x68><== NEVER TAKEN
200f81c: 84 10 20 01 mov 1, %g2
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
200f820: 03 00 80 78 sethi %hi(0x201e000), %g1
200f824: b0 06 3f ff add %i0, -1, %i0
200f828: b1 28 80 18 sll %g2, %i0, %i0
200f82c: c4 00 63 a4 ld [ %g1 + 0x3a4 ], %g2
200f830: b0 28 80 18 andn %g2, %i0, %i0
200f834: f0 20 63 a4 st %i0, [ %g1 + 0x3a4 ]
}
_ISR_Enable( level );
200f838: 7f ff cb 71 call 20025fc <sparc_enable_interrupts>
200f83c: 91 e8 00 08 restore %g0, %o0, %o0
020083bc <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
20083bc: 82 10 20 1b mov 0x1b, %g1
20083c0: 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(
20083c4: 86 00 7f ff add %g1, -1, %g3
20083c8: 87 28 80 03 sll %g2, %g3, %g3
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
20083cc: 80 88 c0 08 btst %g3, %o0
20083d0: 12 80 00 11 bne 2008414 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
20083d4: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
20083d8: 82 00 60 01 inc %g1
20083dc: 80 a0 60 20 cmp %g1, 0x20
20083e0: 12 bf ff fa bne 20083c8 <_POSIX_signals_Get_lowest+0xc>
20083e4: 86 00 7f ff add %g1, -1, %g3
20083e8: 82 10 20 01 mov 1, %g1
20083ec: 84 10 20 01 mov 1, %g2
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
20083f0: 86 00 7f ff add %g1, -1, %g3
20083f4: 87 28 80 03 sll %g2, %g3, %g3
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
20083f8: 80 88 c0 08 btst %g3, %o0
20083fc: 12 80 00 06 bne 2008414 <_POSIX_signals_Get_lowest+0x58>
2008400: 01 00 00 00 nop
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
2008404: 82 00 60 01 inc %g1
2008408: 80 a0 60 1b cmp %g1, 0x1b
200840c: 12 bf ff fa bne 20083f4 <_POSIX_signals_Get_lowest+0x38> <== ALWAYS TAKEN
2008410: 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;
}
2008414: 81 c3 e0 08 retl
2008418: 90 10 00 01 mov %g1, %o0
0201a778 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
201a778: 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 ) ) {
201a77c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201a780: 3b 04 00 20 sethi %hi(0x10008000), %i5
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
201a784: 84 06 7f ff add %i1, -1, %g2
201a788: 86 10 20 01 mov 1, %g3
201a78c: 9e 08 40 1d and %g1, %i5, %o7
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
201a790: 92 10 00 1a mov %i2, %o1
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
201a794: 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 ) ) {
201a798: 80 a3 c0 1d cmp %o7, %i5
201a79c: 12 80 00 1c bne 201a80c <_POSIX_signals_Unblock_thread+0x94>
201a7a0: 85 28 c0 02 sll %g3, %g2, %g2
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
201a7a4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
201a7a8: 80 88 80 01 btst %g2, %g1
201a7ac: 12 80 00 07 bne 201a7c8 <_POSIX_signals_Unblock_thread+0x50>
201a7b0: 82 10 20 04 mov 4, %g1
201a7b4: c2 01 20 d0 ld [ %g4 + 0xd0 ], %g1
201a7b8: 80 a8 80 01 andncc %g2, %g1, %g0
201a7bc: 02 80 00 3f be 201a8b8 <_POSIX_signals_Unblock_thread+0x140>
201a7c0: ba 10 20 00 clr %i5
the_thread->Wait.return_code = EINTR;
201a7c4: 82 10 20 04 mov 4, %g1
201a7c8: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
201a7cc: 80 a2 60 00 cmp %o1, 0
201a7d0: 12 80 00 07 bne 201a7ec <_POSIX_signals_Unblock_thread+0x74>
201a7d4: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
201a7d8: 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;
201a7dc: f2 22 00 00 st %i1, [ %o0 ]
the_info->si_code = SI_USER;
201a7e0: c2 22 20 04 st %g1, [ %o0 + 4 ]
the_info->si_value.sival_int = 0;
201a7e4: 10 80 00 04 b 201a7f4 <_POSIX_signals_Unblock_thread+0x7c>
201a7e8: c0 22 20 08 clr [ %o0 + 8 ]
} else {
*the_info = *info;
201a7ec: 7f ff d6 7e call 20101e4 <memcpy>
201a7f0: 94 10 20 0c mov 0xc, %o2
}
_Thread_queue_Extract_with_proxy( the_thread );
201a7f4: 90 10 00 18 mov %i0, %o0
201a7f8: 7f ff c0 30 call 200a8b8 <_Thread_queue_Extract_with_proxy>
201a7fc: ba 10 20 01 mov 1, %i5
201a800: b0 0f 60 01 and %i5, 1, %i0
201a804: 81 c7 e0 08 ret
201a808: 81 e8 00 00 restore
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
201a80c: c8 01 20 d0 ld [ %g4 + 0xd0 ], %g4
201a810: 80 a8 80 04 andncc %g2, %g4, %g0
201a814: 02 80 00 29 be 201a8b8 <_POSIX_signals_Unblock_thread+0x140>
201a818: ba 10 20 00 clr %i5
* 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 ) ) {
201a81c: 05 04 00 00 sethi %hi(0x10000000), %g2
201a820: 80 88 40 02 btst %g1, %g2
201a824: 02 80 00 19 be 201a888 <_POSIX_signals_Unblock_thread+0x110>
201a828: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
201a82c: 84 10 20 04 mov 4, %g2
201a830: 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) )
201a834: 05 00 00 ef sethi %hi(0x3bc00), %g2
201a838: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
201a83c: 80 88 40 02 btst %g1, %g2
201a840: 02 80 00 07 be 201a85c <_POSIX_signals_Unblock_thread+0xe4>
201a844: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
201a848: 7f ff c0 1c call 200a8b8 <_Thread_queue_Extract_with_proxy>
201a84c: 90 10 00 18 mov %i0, %o0
201a850: b0 0f 60 01 and %i5, 1, %i0
201a854: 81 c7 e0 08 ret
201a858: 81 e8 00 00 restore
else if ( _States_Is_delaying(the_thread->current_state) ) {
201a85c: 22 80 00 18 be,a 201a8bc <_POSIX_signals_Unblock_thread+0x144><== NEVER TAKEN
201a860: b0 0f 60 01 and %i5, 1, %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
201a864: 7f ff c1 e3 call 200aff0 <_Watchdog_Remove>
201a868: 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 );
201a86c: 90 10 00 18 mov %i0, %o0
201a870: 13 04 00 ff sethi %hi(0x1003fc00), %o1
201a874: 7f ff bd 64 call 2009e04 <_Thread_Clear_state>
201a878: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
201a87c: b0 0f 60 01 and %i5, 1, %i0
201a880: 81 c7 e0 08 ret
201a884: 81 e8 00 00 restore
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
201a888: 32 80 00 0d bne,a 201a8bc <_POSIX_signals_Unblock_thread+0x144><== NEVER TAKEN
201a88c: b0 0f 60 01 and %i5, 1, %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a890: 03 00 80 78 sethi %hi(0x201e000), %g1
201a894: 82 10 61 50 or %g1, 0x150, %g1 ! 201e150 <_Per_CPU_Information>
201a898: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a89c: 80 a0 a0 00 cmp %g2, 0
201a8a0: 22 80 00 07 be,a 201a8bc <_POSIX_signals_Unblock_thread+0x144>
201a8a4: b0 0f 60 01 and %i5, 1, %i0
201a8a8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a8ac: 80 a6 00 02 cmp %i0, %g2
201a8b0: 22 80 00 02 be,a 201a8b8 <_POSIX_signals_Unblock_thread+0x140><== ALWAYS TAKEN
201a8b4: c6 28 60 18 stb %g3, [ %g1 + 0x18 ]
_Thread_Dispatch_necessary = true;
}
}
return false;
}
201a8b8: b0 0f 60 01 and %i5, 1, %i0
201a8bc: 81 c7 e0 08 ret
201a8c0: 81 e8 00 00 restore
0200a324 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a324: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
200a328: 80 a6 60 00 cmp %i1, 0
200a32c: 02 80 00 73 be 200a4f8 <_RBTree_Extract_unprotected+0x1d4>
200a330: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
200a334: c2 06 20 08 ld [ %i0 + 8 ], %g1
200a338: 80 a6 40 01 cmp %i1, %g1
200a33c: 32 80 00 0d bne,a 200a370 <_RBTree_Extract_unprotected+0x4c>
200a340: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (the_node->child[RBT_RIGHT])
200a344: c2 06 60 08 ld [ %i1 + 8 ], %g1
200a348: 80 a0 60 00 cmp %g1, 0
200a34c: 22 80 00 04 be,a 200a35c <_RBTree_Extract_unprotected+0x38>
200a350: c2 06 40 00 ld [ %i1 ], %g1
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
200a354: 10 80 00 06 b 200a36c <_RBTree_Extract_unprotected+0x48>
200a358: c2 26 20 08 st %g1, [ %i0 + 8 ]
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
200a35c: 80 a6 00 01 cmp %i0, %g1
200a360: 12 80 00 03 bne 200a36c <_RBTree_Extract_unprotected+0x48>
200a364: c2 26 20 08 st %g1, [ %i0 + 8 ]
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
200a368: c0 26 20 08 clr [ %i0 + 8 ]
}
}
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
200a36c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
200a370: 80 a6 40 01 cmp %i1, %g1
200a374: 12 80 00 0b bne 200a3a0 <_RBTree_Extract_unprotected+0x7c>
200a378: c2 06 60 04 ld [ %i1 + 4 ], %g1
if (the_node->child[RBT_LEFT])
200a37c: 80 a0 60 00 cmp %g1, 0
200a380: 22 80 00 04 be,a 200a390 <_RBTree_Extract_unprotected+0x6c>
200a384: c4 06 40 00 ld [ %i1 ], %g2
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
200a388: 10 80 00 06 b 200a3a0 <_RBTree_Extract_unprotected+0x7c>
200a38c: c2 26 20 0c st %g1, [ %i0 + 0xc ]
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
200a390: 80 a6 00 02 cmp %i0, %g2
200a394: 12 80 00 03 bne 200a3a0 <_RBTree_Extract_unprotected+0x7c>
200a398: c4 26 20 0c st %g2, [ %i0 + 0xc ]
the_rbtree->first[RBT_RIGHT]))
the_rbtree->first[RBT_RIGHT] = NULL;
200a39c: c0 26 20 0c clr [ %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]) {
200a3a0: ba 90 60 00 orcc %g1, 0, %i5
200a3a4: 02 80 00 36 be 200a47c <_RBTree_Extract_unprotected+0x158>
200a3a8: f8 06 60 08 ld [ %i1 + 8 ], %i4
200a3ac: 80 a7 20 00 cmp %i4, 0
200a3b0: 32 80 00 05 bne,a 200a3c4 <_RBTree_Extract_unprotected+0xa0>
200a3b4: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a3b8: 10 80 00 35 b 200a48c <_RBTree_Extract_unprotected+0x168>
200a3bc: b8 10 00 01 mov %g1, %i4
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
200a3c0: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a3c4: 80 a0 60 00 cmp %g1, 0
200a3c8: 32 bf ff fe bne,a 200a3c0 <_RBTree_Extract_unprotected+0x9c>
200a3cc: 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];
200a3d0: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
200a3d4: 80 a7 20 00 cmp %i4, 0
200a3d8: 02 80 00 05 be 200a3ec <_RBTree_Extract_unprotected+0xc8>
200a3dc: 01 00 00 00 nop
leaf->parent = target->parent;
200a3e0: c2 07 40 00 ld [ %i5 ], %g1
200a3e4: 10 80 00 04 b 200a3f4 <_RBTree_Extract_unprotected+0xd0>
200a3e8: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
200a3ec: 7f ff ff 55 call 200a140 <_RBTree_Extract_validate_unprotected>
200a3f0: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
200a3f4: 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;
200a3f8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
dir = target != target->parent->child[0];
200a3fc: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a400: 86 1f 40 03 xor %i5, %g3, %g3
200a404: 80 a0 00 03 cmp %g0, %g3
200a408: 86 40 20 00 addx %g0, 0, %g3
target->parent->child[dir] = leaf;
200a40c: 87 28 e0 02 sll %g3, 2, %g3
200a410: 84 00 80 03 add %g2, %g3, %g2
200a414: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
200a418: c4 06 40 00 ld [ %i1 ], %g2
200a41c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a420: 86 1e 40 03 xor %i1, %g3, %g3
200a424: 80 a0 00 03 cmp %g0, %g3
200a428: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = target;
200a42c: 87 28 e0 02 sll %g3, 2, %g3
200a430: 84 00 80 03 add %g2, %g3, %g2
200a434: 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];
200a438: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a43c: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
200a440: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a444: 80 a0 a0 00 cmp %g2, 0
200a448: 32 80 00 02 bne,a 200a450 <_RBTree_Extract_unprotected+0x12c><== ALWAYS TAKEN
200a44c: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
200a450: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a454: c4 27 60 04 st %g2, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
200a458: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a45c: 80 a0 a0 00 cmp %g2, 0
200a460: 32 80 00 02 bne,a 200a468 <_RBTree_Extract_unprotected+0x144>
200a464: 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;
200a468: c4 06 40 00 ld [ %i1 ], %g2
200a46c: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
200a470: c4 06 60 0c ld [ %i1 + 0xc ], %g2
200a474: 10 80 00 14 b 200a4c4 <_RBTree_Extract_unprotected+0x1a0>
200a478: 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 ) {
200a47c: 80 a7 20 00 cmp %i4, 0
200a480: 32 80 00 04 bne,a 200a490 <_RBTree_Extract_unprotected+0x16c>
200a484: c2 06 40 00 ld [ %i1 ], %g1
200a488: 30 80 00 04 b,a 200a498 <_RBTree_Extract_unprotected+0x174>
leaf->parent = the_node->parent;
200a48c: c2 06 40 00 ld [ %i1 ], %g1
200a490: 10 80 00 04 b 200a4a0 <_RBTree_Extract_unprotected+0x17c>
200a494: 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);
200a498: 7f ff ff 2a call 200a140 <_RBTree_Extract_validate_unprotected>
200a49c: 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];
200a4a0: 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;
200a4a4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
200a4a8: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a4ac: 86 1e 40 03 xor %i1, %g3, %g3
200a4b0: 80 a0 00 03 cmp %g0, %g3
200a4b4: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = leaf;
200a4b8: 87 28 e0 02 sll %g3, 2, %g3
200a4bc: 84 00 80 03 add %g2, %g3, %g2
200a4c0: 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 */
200a4c4: 80 a0 60 00 cmp %g1, 0
200a4c8: 32 80 00 06 bne,a 200a4e0 <_RBTree_Extract_unprotected+0x1bc>
200a4cc: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
200a4d0: 80 a7 20 00 cmp %i4, 0
200a4d4: 32 80 00 02 bne,a 200a4dc <_RBTree_Extract_unprotected+0x1b8>
200a4d8: 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;
200a4dc: 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;
200a4e0: c0 26 60 08 clr [ %i1 + 8 ]
200a4e4: c0 26 60 04 clr [ %i1 + 4 ]
200a4e8: 80 a0 60 00 cmp %g1, 0
200a4ec: 02 80 00 03 be 200a4f8 <_RBTree_Extract_unprotected+0x1d4>
200a4f0: c0 26 40 00 clr [ %i1 ]
200a4f4: c0 20 60 0c clr [ %g1 + 0xc ]
200a4f8: 81 c7 e0 08 ret
200a4fc: 81 e8 00 00 restore
0200a140 <_RBTree_Extract_validate_unprotected>:
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
200a140: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
200a144: fa 06 00 00 ld [ %i0 ], %i5
if(!parent->parent) return;
200a148: c2 07 40 00 ld [ %i5 ], %g1
200a14c: 80 a0 60 00 cmp %g1, 0
200a150: 02 80 00 6c be 200a300 <_RBTree_Extract_validate_unprotected+0x1c0>
200a154: 90 10 00 18 mov %i0, %o0
sibling = _RBTree_Sibling(the_node);
200a158: 7f ff ff ca call 200a080 <_RBTree_Sibling>
200a15c: b6 10 20 01 mov 1, %i3
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
200a160: 10 80 00 5b b 200a2cc <_RBTree_Extract_validate_unprotected+0x18c>
200a164: c2 06 20 0c ld [ %i0 + 0xc ], %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a168: 22 80 00 14 be,a 200a1b8 <_RBTree_Extract_validate_unprotected+0x78><== NEVER TAKEN
200a16c: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED
200a170: c2 02 20 0c ld [ %o0 + 0xc ], %g1
200a174: 80 a0 60 01 cmp %g1, 1
200a178: 32 80 00 10 bne,a 200a1b8 <_RBTree_Extract_validate_unprotected+0x78>
200a17c: c4 02 20 08 ld [ %o0 + 8 ], %g2
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
200a180: c2 27 60 0c st %g1, [ %i5 + 0xc ]
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
200a184: c2 07 60 04 ld [ %i5 + 4 ], %g1
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
200a188: c0 22 20 0c clr [ %o0 + 0xc ]
dir = the_node != parent->child[0];
200a18c: 82 1e 00 01 xor %i0, %g1, %g1
200a190: 80 a0 00 01 cmp %g0, %g1
_RBTree_Rotate(parent, dir);
200a194: 90 10 00 1d mov %i5, %o0
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
200a198: b8 40 20 00 addx %g0, 0, %i4
_RBTree_Rotate(parent, dir);
200a19c: 7f ff ff ca call 200a0c4 <_RBTree_Rotate>
200a1a0: 92 10 00 1c mov %i4, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a1a4: b8 1f 20 01 xor %i4, 1, %i4
sibling = parent->child[_RBTree_Opposite_direction(dir)];
200a1a8: b9 2f 20 02 sll %i4, 2, %i4
200a1ac: b8 07 40 1c add %i5, %i4, %i4
200a1b0: d0 07 20 04 ld [ %i4 + 4 ], %o0
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
200a1b4: c4 02 20 08 ld [ %o0 + 8 ], %g2
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a1b8: 80 a0 a0 00 cmp %g2, 0
200a1bc: 02 80 00 06 be 200a1d4 <_RBTree_Extract_validate_unprotected+0x94>
200a1c0: 82 10 20 00 clr %g1
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
200a1c4: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
200a1c8: 82 18 60 01 xor %g1, 1, %g1
200a1cc: 80 a0 00 01 cmp %g0, %g1
200a1d0: 82 60 3f ff subx %g0, -1, %g1
_RBTree_Rotate(parent, dir);
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
200a1d4: 80 a0 60 00 cmp %g1, 0
200a1d8: 32 80 00 14 bne,a 200a228 <_RBTree_Extract_validate_unprotected+0xe8>
200a1dc: c2 07 60 04 ld [ %i5 + 4 ], %g1
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
200a1e0: c4 02 20 04 ld [ %o0 + 4 ], %g2
200a1e4: 80 a0 a0 00 cmp %g2, 0
200a1e8: 02 80 00 07 be 200a204 <_RBTree_Extract_validate_unprotected+0xc4>
200a1ec: 80 a0 60 00 cmp %g1, 0
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
200a1f0: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
200a1f4: 82 18 60 01 xor %g1, 1, %g1
200a1f8: 80 a0 00 01 cmp %g0, %g1
200a1fc: 82 60 3f ff subx %g0, -1, %g1
_RBTree_Rotate(parent, dir);
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
200a200: 80 a0 60 00 cmp %g1, 0
200a204: 32 80 00 09 bne,a 200a228 <_RBTree_Extract_validate_unprotected+0xe8>
200a208: c2 07 60 04 ld [ %i5 + 4 ], %g1
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
200a20c: f6 22 20 0c st %i3, [ %o0 + 0xc ]
200a210: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200a214: 80 a0 60 01 cmp %g1, 1
200a218: 32 80 00 3c bne,a 200a308 <_RBTree_Extract_validate_unprotected+0x1c8>
200a21c: f4 07 40 00 ld [ %i5 ], %i2
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
200a220: 10 80 00 32 b 200a2e8 <_RBTree_Extract_validate_unprotected+0x1a8>
200a224: c0 27 60 0c clr [ %i5 + 0xc ]
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
200a228: 82 1e 00 01 xor %i0, %g1, %g1
200a22c: 80 a0 00 01 cmp %g0, %g1
200a230: b6 40 20 00 addx %g0, 0, %i3
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a234: b8 1e e0 01 xor %i3, 1, %i4
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
200a238: 83 2f 20 02 sll %i4, 2, %g1
200a23c: 82 02 00 01 add %o0, %g1, %g1
200a240: c4 00 60 04 ld [ %g1 + 4 ], %g2
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a244: 80 a0 a0 00 cmp %g2, 0
200a248: 02 80 00 06 be 200a260 <_RBTree_Extract_validate_unprotected+0x120>
200a24c: 82 10 20 00 clr %g1
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
200a250: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
200a254: 82 18 60 01 xor %g1, 1, %g1
200a258: 80 a0 00 01 cmp %g0, %g1
200a25c: 82 60 3f ff subx %g0, -1, %g1
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
200a260: 80 a0 60 00 cmp %g1, 0
200a264: 32 80 00 0e bne,a 200a29c <_RBTree_Extract_validate_unprotected+0x15c>
200a268: c2 07 60 0c ld [ %i5 + 0xc ], %g1
sibling->color = RBT_RED;
200a26c: 82 10 20 01 mov 1, %g1
200a270: c2 22 20 0c st %g1, [ %o0 + 0xc ]
sibling->child[dir]->color = RBT_BLACK;
200a274: 83 2e e0 02 sll %i3, 2, %g1
200a278: 82 02 00 01 add %o0, %g1, %g1
200a27c: c2 00 60 04 ld [ %g1 + 4 ], %g1
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
200a280: 92 10 00 1c mov %i4, %o1
200a284: 7f ff ff 90 call 200a0c4 <_RBTree_Rotate>
200a288: c0 20 60 0c clr [ %g1 + 0xc ]
sibling = parent->child[_RBTree_Opposite_direction(dir)];
200a28c: 83 2f 20 02 sll %i4, 2, %g1
200a290: 82 07 40 01 add %i5, %g1, %g1
200a294: d0 00 60 04 ld [ %g1 + 4 ], %o0
}
sibling->color = parent->color;
200a298: c2 07 60 0c ld [ %i5 + 0xc ], %g1
parent->color = RBT_BLACK;
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
200a29c: b9 2f 20 02 sll %i4, 2, %i4
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
200a2a0: c2 22 20 0c st %g1, [ %o0 + 0xc ]
parent->color = RBT_BLACK;
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
200a2a4: 90 02 00 1c add %o0, %i4, %o0
200a2a8: c2 02 20 04 ld [ %o0 + 4 ], %g1
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
parent->color = RBT_BLACK;
200a2ac: c0 27 60 0c clr [ %i5 + 0xc ]
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
200a2b0: c0 20 60 0c clr [ %g1 + 0xc ]
_RBTree_Rotate(parent, dir);
200a2b4: 90 10 00 1d mov %i5, %o0
200a2b8: 7f ff ff 83 call 200a0c4 <_RBTree_Rotate>
200a2bc: 92 10 00 1b mov %i3, %o1
break; /* done */
200a2c0: 10 80 00 0b b 200a2ec <_RBTree_Extract_validate_unprotected+0x1ac>
200a2c4: c2 06 00 00 ld [ %i0 ], %g1
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
200a2c8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
200a2cc: 80 a0 60 01 cmp %g1, 1
200a2d0: 22 80 00 07 be,a 200a2ec <_RBTree_Extract_validate_unprotected+0x1ac>
200a2d4: c2 06 00 00 ld [ %i0 ], %g1
200a2d8: c2 07 40 00 ld [ %i5 ], %g1
200a2dc: 80 a0 60 00 cmp %g1, 0
200a2e0: 12 bf ff a2 bne 200a168 <_RBTree_Extract_validate_unprotected+0x28>
200a2e4: 80 a2 20 00 cmp %o0, 0
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
200a2e8: c2 06 00 00 ld [ %i0 ], %g1
200a2ec: c2 00 40 00 ld [ %g1 ], %g1
200a2f0: 80 a0 60 00 cmp %g1, 0
200a2f4: 12 80 00 0a bne 200a31c <_RBTree_Extract_validate_unprotected+0x1dc>
200a2f8: 01 00 00 00 nop
200a2fc: c0 26 20 0c clr [ %i0 + 0xc ]
200a300: 81 c7 e0 08 ret
200a304: 81 e8 00 00 restore
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
sibling = _RBTree_Sibling(the_node);
200a308: 90 10 00 1d mov %i5, %o0
200a30c: 7f ff ff 5d call 200a080 <_RBTree_Sibling>
200a310: b0 10 00 1d mov %i5, %i0
200a314: 10 bf ff ed b 200a2c8 <_RBTree_Extract_validate_unprotected+0x188>
200a318: ba 10 00 1a mov %i2, %i5
200a31c: 81 c7 e0 08 ret
200a320: 81 e8 00 00 restore
0200b4e0 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
200b4e0: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
200b4e4: 80 a6 20 00 cmp %i0, 0
200b4e8: 02 80 00 10 be 200b528 <_RBTree_Initialize+0x48> <== NEVER TAKEN
200b4ec: 01 00 00 00 nop
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
200b4f0: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
200b4f4: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
200b4f8: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
200b4fc: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
200b500: 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-- ) {
200b504: 10 80 00 06 b 200b51c <_RBTree_Initialize+0x3c>
200b508: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert(the_rbtree, next);
200b50c: 90 10 00 18 mov %i0, %o0
200b510: 7f ff ff ba call 200b3f8 <_RBTree_Insert>
200b514: b4 06 80 1c add %i2, %i4, %i2
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
200b518: 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-- ) {
200b51c: 80 a6 e0 00 cmp %i3, 0
200b520: 12 bf ff fb bne 200b50c <_RBTree_Initialize+0x2c>
200b524: 92 10 00 1a mov %i2, %o1
200b528: 81 c7 e0 08 ret
200b52c: 81 e8 00 00 restore
0200a5a0 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a5a0: 9d e3 bf a0 save %sp, -96, %sp
200a5a4: ba 10 00 18 mov %i0, %i5
if(!the_node) return (RBTree_Node*)-1;
200a5a8: 80 a6 60 00 cmp %i1, 0
200a5ac: 02 80 00 0d be 200a5e0 <_RBTree_Insert_unprotected+0x40>
200a5b0: b0 10 3f ff mov -1, %i0
RBTree_Node *iter_node = the_rbtree->root;
200a5b4: f0 07 60 04 ld [ %i5 + 4 ], %i0
int compare_result;
if (!iter_node) { /* special case: first node inserted */
200a5b8: b8 96 20 00 orcc %i0, 0, %i4
200a5bc: 32 80 00 22 bne,a 200a644 <_RBTree_Insert_unprotected+0xa4>
200a5c0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
the_node->color = RBT_BLACK;
200a5c4: c0 26 60 0c clr [ %i1 + 0xc ]
the_rbtree->root = the_node;
200a5c8: f2 27 60 04 st %i1, [ %i5 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
200a5cc: f2 27 60 0c st %i1, [ %i5 + 0xc ]
200a5d0: f2 27 60 08 st %i1, [ %i5 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
200a5d4: fa 26 40 00 st %i5, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a5d8: c0 26 60 08 clr [ %i1 + 8 ]
200a5dc: c0 26 60 04 clr [ %i1 + 4 ]
200a5e0: 81 c7 e0 08 ret
200a5e4: 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);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200a5e8: 02 bf ff fe be 200a5e0 <_RBTree_Insert_unprotected+0x40>
200a5ec: 82 38 00 08 xnor %g0, %o0, %g1
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
200a5f0: 83 30 60 1f srl %g1, 0x1f, %g1
if (!iter_node->child[dir]) {
200a5f4: 85 28 60 02 sll %g1, 2, %g2
200a5f8: 84 06 00 02 add %i0, %g2, %g2
200a5fc: f0 00 a0 04 ld [ %g2 + 4 ], %i0
200a600: 80 a6 20 00 cmp %i0, 0
200a604: 32 80 00 0f bne,a 200a640 <_RBTree_Insert_unprotected+0xa0>
200a608: b8 10 00 18 mov %i0, %i4
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a60c: c0 26 60 08 clr [ %i1 + 8 ]
200a610: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
iter_node->child[dir] = the_node;
200a614: f2 20 a0 04 st %i1, [ %g2 + 4 ]
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
200a618: 82 00 60 02 add %g1, 2, %g1
200a61c: 83 28 60 02 sll %g1, 2, %g1
the_node->parent = iter_node;
/* update min/max */
if (_RBTree_Is_first(the_rbtree, iter_node, dir)) {
200a620: c4 07 40 01 ld [ %i5 + %g1 ], %g2
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;
200a624: 86 10 20 01 mov 1, %g3
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
200a628: f8 26 40 00 st %i4, [ %i1 ]
/* update min/max */
if (_RBTree_Is_first(the_rbtree, iter_node, dir)) {
200a62c: 80 a7 00 02 cmp %i4, %g2
200a630: 12 80 00 2d bne 200a6e4 <_RBTree_Insert_unprotected+0x144>
200a634: c6 26 60 0c st %g3, [ %i1 + 0xc ]
the_rbtree->first[dir] = the_node;
200a638: 10 80 00 2b b 200a6e4 <_RBTree_Insert_unprotected+0x144>
200a63c: f2 27 40 01 st %i1, [ %i5 + %g1 ]
the_node->parent = (RBTree_Node *) the_rbtree;
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} 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);
200a640: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200a644: 90 10 00 19 mov %i1, %o0
200a648: 9f c0 40 00 call %g1
200a64c: 92 10 00 18 mov %i0, %o1
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200a650: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
200a654: 80 a0 60 00 cmp %g1, 0
200a658: 12 bf ff e4 bne 200a5e8 <_RBTree_Insert_unprotected+0x48>
200a65c: 80 a2 20 00 cmp %o0, 0
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
200a660: 10 bf ff e4 b 200a5f0 <_RBTree_Insert_unprotected+0x50>
200a664: 82 38 00 08 xnor %g0, %o0, %g1
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
200a668: 80 a0 60 00 cmp %g1, 0
200a66c: 02 80 00 2c be 200a71c <_RBTree_Insert_unprotected+0x17c> <== NEVER TAKEN
200a670: c2 07 60 04 ld [ %i5 + 4 ], %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])
200a674: 80 a2 00 01 cmp %o0, %g1
200a678: 22 80 00 02 be,a 200a680 <_RBTree_Insert_unprotected+0xe0>
200a67c: 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);
200a680: 80 a0 60 00 cmp %g1, 0
200a684: 22 80 00 26 be,a 200a71c <_RBTree_Insert_unprotected+0x17c>
200a688: c2 07 60 04 ld [ %i5 + 4 ], %g1
200a68c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200a690: 80 a0 a0 01 cmp %g2, 1
200a694: 32 80 00 22 bne,a 200a71c <_RBTree_Insert_unprotected+0x17c>
200a698: c2 07 60 04 ld [ %i5 + 4 ], %g1
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
200a69c: c0 22 20 0c clr [ %o0 + 0xc ]
u->color = RBT_BLACK;
200a6a0: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a6a4: c4 27 60 0c st %g2, [ %i5 + 0xc ]
200a6a8: 10 80 00 10 b 200a6e8 <_RBTree_Insert_unprotected+0x148>
200a6ac: b2 10 00 1d mov %i5, %i1
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
200a6b0: 7f ff ff 9d call 200a524 <_RBTree_Rotate>
200a6b4: 92 10 00 1c mov %i4, %o1
the_node = the_node->child[pdir];
200a6b8: 83 2f 20 02 sll %i4, 2, %g1
200a6bc: b2 06 40 01 add %i1, %g1, %i1
200a6c0: f2 06 60 04 ld [ %i1 + 4 ], %i1
}
the_node->parent->color = RBT_BLACK;
200a6c4: c2 06 40 00 ld [ %i1 ], %g1
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
200a6c8: 90 10 00 1d mov %i5, %o0
/* 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;
200a6cc: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a6d0: f6 27 60 0c st %i3, [ %i5 + 0xc ]
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
200a6d4: 7f ff ff 94 call 200a524 <_RBTree_Rotate>
200a6d8: 92 26 c0 1c sub %i3, %i4, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
200a6dc: 10 80 00 04 b 200a6ec <_RBTree_Insert_unprotected+0x14c>
200a6e0: d0 06 40 00 ld [ %i1 ], %o0
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
200a6e4: b6 10 20 01 mov 1, %i3
200a6e8: d0 06 40 00 ld [ %i1 ], %o0
200a6ec: fa 02 00 00 ld [ %o0 ], %i5
200a6f0: 80 a7 60 00 cmp %i5, 0
200a6f4: 22 bf ff bb be,a 200a5e0 <_RBTree_Insert_unprotected+0x40>
200a6f8: c0 26 60 0c clr [ %i1 + 0xc ]
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a6fc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
200a700: 80 a0 60 01 cmp %g1, 1
200a704: 12 80 00 04 bne 200a714 <_RBTree_Insert_unprotected+0x174>
200a708: 01 00 00 00 nop
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
200a70c: 10 bf ff d7 b 200a668 <_RBTree_Insert_unprotected+0xc8>
200a710: c2 07 40 00 ld [ %i5 ], %g1
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
200a714: 81 c7 e0 08 ret
200a718: 81 e8 00 00 restore
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
200a71c: 82 1a 00 01 xor %o0, %g1, %g1
200a720: 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];
200a724: c2 02 20 04 ld [ %o0 + 4 ], %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
200a728: 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];
200a72c: 82 1e 40 01 xor %i1, %g1, %g1
200a730: 80 a0 00 01 cmp %g0, %g1
200a734: 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) {
200a738: 80 a0 40 1c cmp %g1, %i4
200a73c: 12 bf ff dd bne 200a6b0 <_RBTree_Insert_unprotected+0x110>
200a740: 01 00 00 00 nop
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
200a744: 10 bf ff e1 b 200a6c8 <_RBTree_Insert_unprotected+0x128>
200a748: c2 06 40 00 ld [ %i1 ], %g1
0200a760 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
200a760: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a764: 80 a0 00 19 cmp %g0, %i1
200a768: 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];
200a76c: 82 00 60 02 add %g1, 2, %g1
200a770: 83 28 60 02 sll %g1, 2, %g1
200a774: 10 80 00 0d b 200a7a8 <_RBTree_Iterate_unprotected+0x48>
200a778: fa 06 00 01 ld [ %i0 + %g1 ], %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 ) {
stop = (*visitor)( current, dir, visitor_arg );
200a77c: 92 10 00 19 mov %i1, %o1
200a780: 9f c6 80 00 call %i2
200a784: 94 10 00 1b mov %i3, %o2
current = _RBTree_Next_unprotected( rbtree, current, dir );
200a788: 92 10 00 1d mov %i5, %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 );
200a78c: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( rbtree, current, dir );
200a790: 94 10 00 19 mov %i1, %o2
200a794: 40 00 00 0a call 200a7bc <_RBTree_Next_unprotected>
200a798: 90 10 00 18 mov %i0, %o0
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
200a79c: 80 8f 20 ff btst 0xff, %i4
200a7a0: 12 80 00 05 bne 200a7b4 <_RBTree_Iterate_unprotected+0x54><== NEVER TAKEN
200a7a4: ba 10 00 08 mov %o0, %i5
200a7a8: 80 a7 60 00 cmp %i5, 0
200a7ac: 12 bf ff f4 bne 200a77c <_RBTree_Iterate_unprotected+0x1c>
200a7b0: 90 10 00 1d mov %i5, %o0
200a7b4: 81 c7 e0 08 ret
200a7b8: 81 e8 00 00 restore
0200a080 <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
200a080: 80 a2 20 00 cmp %o0, 0
200a084: 02 80 00 0e be 200a0bc <_RBTree_Sibling+0x3c>
200a088: 82 10 20 00 clr %g1
if(!(the_node->parent)) return NULL;
200a08c: c4 02 00 00 ld [ %o0 ], %g2
200a090: 80 a0 a0 00 cmp %g2, 0
200a094: 02 80 00 0a be 200a0bc <_RBTree_Sibling+0x3c> <== NEVER TAKEN
200a098: 01 00 00 00 nop
if(!(the_node->parent->parent)) return NULL;
200a09c: c6 00 80 00 ld [ %g2 ], %g3
200a0a0: 80 a0 e0 00 cmp %g3, 0
200a0a4: 02 80 00 06 be 200a0bc <_RBTree_Sibling+0x3c>
200a0a8: 01 00 00 00 nop
if(the_node == the_node->parent->child[RBT_LEFT])
200a0ac: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200a0b0: 80 a2 00 01 cmp %o0, %g1
200a0b4: 22 80 00 02 be,a 200a0bc <_RBTree_Sibling+0x3c>
200a0b8: c2 00 a0 08 ld [ %g2 + 8 ], %g1
return the_node->parent->child[RBT_RIGHT];
else
return the_node->parent->child[RBT_LEFT];
}
200a0bc: 81 c3 e0 08 retl
200a0c0: 90 10 00 01 mov %g1, %o0
0203e77c <_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
)
{
203e77c: 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;
203e780: fa 06 20 40 ld [ %i0 + 0x40 ], %i5
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
203e784: 7f ff b1 8a call 202adac <_TOD_Get_uptime>
203e788: 90 07 bf f8 add %fp, -8, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
203e78c: c4 1e 20 50 ldd [ %i0 + 0x50 ], %g2
_Timestamp_Subtract(
203e790: 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;
203e794: 82 10 20 01 mov 1, %g1
203e798: 86 a3 40 03 subcc %o5, %g3, %g3
203e79c: 84 63 00 02 subx %o4, %g2, %g2
203e7a0: 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) {
203e7a4: 05 00 81 be sethi %hi(0x206f800), %g2
203e7a8: 84 10 a0 00 mov %g2, %g2 ! 206f800 <_Per_CPU_Information>
203e7ac: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
203e7b0: 80 a7 40 03 cmp %i5, %g3
203e7b4: 12 80 00 15 bne 203e808 <_Rate_monotonic_Get_status+0x8c>
203e7b8: d4 1f 60 80 ldd [ %i5 + 0x80 ], %o2
203e7bc: c4 18 a0 20 ldd [ %g2 + 0x20 ], %g2
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
203e7c0: f0 1e 20 48 ldd [ %i0 + 0x48 ], %i0
203e7c4: 86 a3 40 03 subcc %o5, %g3, %g3
203e7c8: 84 63 00 02 subx %o4, %g2, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
203e7cc: 96 82 c0 03 addcc %o3, %g3, %o3
203e7d0: 94 42 80 02 addx %o2, %g2, %o2
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
203e7d4: 80 a6 00 0a cmp %i0, %o2
203e7d8: 34 80 00 0c bg,a 203e808 <_Rate_monotonic_Get_status+0x8c><== NEVER TAKEN
203e7dc: 82 10 20 00 clr %g1 <== NOT EXECUTED
203e7e0: 32 80 00 06 bne,a 203e7f8 <_Rate_monotonic_Get_status+0x7c>
203e7e4: 96 a2 c0 19 subcc %o3, %i1, %o3
203e7e8: 80 a6 40 0b cmp %i1, %o3
203e7ec: 18 80 00 06 bgu 203e804 <_Rate_monotonic_Get_status+0x88>
203e7f0: 96 a2 c0 19 subcc %o3, %i1, %o3
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
203e7f4: 82 10 20 01 mov 1, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
203e7f8: 94 62 80 18 subx %o2, %i0, %o2
203e7fc: 10 80 00 03 b 203e808 <_Rate_monotonic_Get_status+0x8c>
203e800: d4 3e 80 00 std %o2, [ %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;
203e804: 82 10 20 00 clr %g1
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
203e808: b0 08 60 01 and %g1, 1, %i0
203e80c: 81 c7 e0 08 ret
203e810: 81 e8 00 00 restore
0203eb74 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
203eb74: 9d e3 bf 98 save %sp, -104, %sp
203eb78: 11 00 81 bf sethi %hi(0x206fc00), %o0
203eb7c: 92 10 00 18 mov %i0, %o1
203eb80: 90 12 22 70 or %o0, 0x270, %o0
203eb84: 7f ff 40 f4 call 200ef54 <_Objects_Get>
203eb88: 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 ) {
203eb8c: c2 07 bf fc ld [ %fp + -4 ], %g1
203eb90: 80 a0 60 00 cmp %g1, 0
203eb94: 12 80 00 25 bne 203ec28 <_Rate_monotonic_Timeout+0xb4> <== NEVER TAKEN
203eb98: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
203eb9c: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
203eba0: 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);
203eba4: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
203eba8: 80 88 80 01 btst %g2, %g1
203ebac: 22 80 00 0b be,a 203ebd8 <_Rate_monotonic_Timeout+0x64>
203ebb0: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
203ebb4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
203ebb8: c2 07 60 08 ld [ %i5 + 8 ], %g1
203ebbc: 80 a0 80 01 cmp %g2, %g1
203ebc0: 32 80 00 06 bne,a 203ebd8 <_Rate_monotonic_Timeout+0x64>
203ebc4: 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 );
203ebc8: 13 04 00 ff sethi %hi(0x1003fc00), %o1
203ebcc: 7f ff 43 c2 call 200fad4 <_Thread_Clear_state>
203ebd0: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
203ebd4: 30 80 00 06 b,a 203ebec <_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 ) {
203ebd8: 80 a0 60 01 cmp %g1, 1
203ebdc: 12 80 00 0d bne 203ec10 <_Rate_monotonic_Timeout+0x9c>
203ebe0: 82 10 20 04 mov 4, %g1
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
203ebe4: 82 10 20 03 mov 3, %g1
203ebe8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
203ebec: 7f ff ff 53 call 203e938 <_Rate_monotonic_Initiate_statistics>
203ebf0: 90 10 00 1d mov %i5, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203ebf4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203ebf8: 11 00 81 bc sethi %hi(0x206f000), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203ebfc: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203ec00: 90 12 23 80 or %o0, 0x380, %o0
203ec04: 7f ff 47 d5 call 2010b58 <_Watchdog_Insert>
203ec08: 92 07 60 10 add %i5, 0x10, %o1
203ec0c: 30 80 00 02 b,a 203ec14 <_Rate_monotonic_Timeout+0xa0>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
203ec10: 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--;
203ec14: 03 00 81 bc sethi %hi(0x206f000), %g1
203ec18: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 206f2c0 <_Thread_Dispatch_disable_level>
203ec1c: 84 00 bf ff add %g2, -1, %g2
203ec20: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ]
return _Thread_Dispatch_disable_level;
203ec24: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1
203ec28: 81 c7 e0 08 ret
203ec2c: 81 e8 00 00 restore
0203e814 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
203e814: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
203e818: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
203e81c: 82 00 60 01 inc %g1
203e820: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
203e824: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
203e828: 80 a0 60 04 cmp %g1, 4
203e82c: 12 80 00 05 bne 203e840 <_Rate_monotonic_Update_statistics+0x2c>
203e830: 90 10 00 18 mov %i0, %o0
stats->missed_count++;
203e834: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
203e838: 82 00 60 01 inc %g1
203e83c: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
/*
* Grab status for time statistics.
*/
valid_status =
203e840: 92 07 bf f8 add %fp, -8, %o1
203e844: 7f ff ff ce call 203e77c <_Rate_monotonic_Get_status>
203e848: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
203e84c: 80 8a 20 ff btst 0xff, %o0
203e850: 02 80 00 38 be 203e930 <_Rate_monotonic_Update_statistics+0x11c>
203e854: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
203e858: d8 1e 20 70 ldd [ %i0 + 0x70 ], %o4
* 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 ) )
203e85c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
203e860: 9a 83 40 03 addcc %o5, %g3, %o5
203e864: 98 43 00 02 addx %o4, %g2, %o4
203e868: 80 a0 40 02 cmp %g1, %g2
203e86c: 14 80 00 09 bg 203e890 <_Rate_monotonic_Update_statistics+0x7c>
203e870: d8 3e 20 70 std %o4, [ %i0 + 0x70 ]
203e874: 80 a0 40 02 cmp %g1, %g2
203e878: 32 80 00 08 bne,a 203e898 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
203e87c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
203e880: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
203e884: 80 a0 40 03 cmp %g1, %g3
203e888: 28 80 00 04 bleu,a 203e898 <_Rate_monotonic_Update_statistics+0x84>
203e88c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
203e890: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
203e894: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
203e898: 80 a0 40 02 cmp %g1, %g2
203e89c: 26 80 00 0a bl,a 203e8c4 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
203e8a0: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
203e8a4: 80 a0 40 02 cmp %g1, %g2
203e8a8: 32 80 00 08 bne,a 203e8c8 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
203e8ac: c4 1f bf f8 ldd [ %fp + -8 ], %g2 <== NOT EXECUTED
203e8b0: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
203e8b4: 80 a0 40 03 cmp %g1, %g3
203e8b8: 3a 80 00 04 bcc,a 203e8c8 <_Rate_monotonic_Update_statistics+0xb4>
203e8bc: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
203e8c0: 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 );
203e8c4: c4 1f bf f8 ldd [ %fp + -8 ], %g2
203e8c8: d8 1e 20 88 ldd [ %i0 + 0x88 ], %o4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
203e8cc: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
203e8d0: 9a 83 40 03 addcc %o5, %g3, %o5
203e8d4: 98 43 00 02 addx %o4, %g2, %o4
203e8d8: 80 a0 40 02 cmp %g1, %g2
203e8dc: 14 80 00 09 bg 203e900 <_Rate_monotonic_Update_statistics+0xec>
203e8e0: d8 3e 20 88 std %o4, [ %i0 + 0x88 ]
203e8e4: 80 a0 40 02 cmp %g1, %g2
203e8e8: 32 80 00 08 bne,a 203e908 <_Rate_monotonic_Update_statistics+0xf4><== NEVER TAKEN
203e8ec: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
203e8f0: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
203e8f4: 80 a0 40 03 cmp %g1, %g3
203e8f8: 28 80 00 04 bleu,a 203e908 <_Rate_monotonic_Update_statistics+0xf4>
203e8fc: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
203e900: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
203e904: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
203e908: 80 a0 40 02 cmp %g1, %g2
203e90c: 26 80 00 09 bl,a 203e930 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
203e910: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
203e914: 80 a0 40 02 cmp %g1, %g2
203e918: 12 80 00 06 bne 203e930 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
203e91c: 01 00 00 00 nop
203e920: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
203e924: 80 a0 40 03 cmp %g1, %g3
203e928: 2a 80 00 02 bcs,a 203e930 <_Rate_monotonic_Update_statistics+0x11c>
203e92c: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
203e930: 81 c7 e0 08 ret
203e934: 81 e8 00 00 restore
0200b4dc <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
200b4dc: 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;
200b4e0: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200b4e4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200b4e8: 80 a0 40 09 cmp %g1, %o1
200b4ec: 32 80 00 02 bne,a 200b4f4 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
200b4f0: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200b4f4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200b4f8: 80 a0 40 09 cmp %g1, %o1
200b4fc: 02 80 00 04 be 200b50c <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
200b500: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200b504: 40 00 01 90 call 200bb44 <_Thread_Change_priority>
200b508: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
200b50c: f0 06 20 88 ld [ %i0 + 0x88 ], %i0
if ( sched_info->cbs_server->cbs_budget_overrun ) {
200b510: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200b514: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200b518: 80 a0 a0 00 cmp %g2, 0
200b51c: 02 80 00 09 be 200b540 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
200b520: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
200b524: d0 00 40 00 ld [ %g1 ], %o0
200b528: 7f ff ff d7 call 200b484 <_Scheduler_CBS_Get_server_id>
200b52c: 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 );
200b530: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200b534: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200b538: 9f c0 40 00 call %g1
200b53c: d0 07 bf fc ld [ %fp + -4 ], %o0
200b540: 81 c7 e0 08 ret
200b544: 81 e8 00 00 restore
0200b0f8 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
200b0f8: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
200b0fc: c2 06 20 04 ld [ %i0 + 4 ], %g1
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
200b100: ba 10 00 18 mov %i0, %i5
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
200b104: 80 a0 60 00 cmp %g1, 0
200b108: 04 80 00 1c ble 200b178 <_Scheduler_CBS_Create_server+0x80>
200b10c: b0 10 3f ee mov -18, %i0
200b110: c2 07 40 00 ld [ %i5 ], %g1
200b114: 80 a0 60 00 cmp %g1, 0
200b118: 04 80 00 18 ble 200b178 <_Scheduler_CBS_Create_server+0x80>
200b11c: 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++ ) {
200b120: c6 00 61 48 ld [ %g1 + 0x148 ], %g3 ! 2020548 <_Scheduler_CBS_Maximum_servers>
if ( !_Scheduler_CBS_Server_list[i] )
200b124: 03 00 80 86 sethi %hi(0x2021800), %g1
200b128: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 ! 2021828 <_Scheduler_CBS_Server_list>
200b12c: 10 80 00 15 b 200b180 <_Scheduler_CBS_Create_server+0x88>
200b130: 82 10 20 00 clr %g1
200b134: c8 00 80 1b ld [ %g2 + %i3 ], %g4
200b138: 80 a1 20 00 cmp %g4, 0
200b13c: 32 80 00 11 bne,a 200b180 <_Scheduler_CBS_Create_server+0x88>
200b140: 82 00 60 01 inc %g1
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
200b144: 39 00 80 86 sethi %hi(0x2021800), %i4
200b148: f0 07 20 28 ld [ %i4 + 0x28 ], %i0 ! 2021828 <_Scheduler_CBS_Server_list>
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
200b14c: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
200b150: 40 00 07 ae call 200d008 <_Workspace_Allocate>
200b154: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
200b158: 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 *)
200b15c: d0 26 00 1b st %o0, [ %i0 + %i3 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
200b160: c4 07 20 28 ld [ %i4 + 0x28 ], %g2
200b164: 83 28 60 02 sll %g1, 2, %g1
200b168: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
200b16c: 80 a0 60 00 cmp %g1, 0
200b170: 12 80 00 09 bne 200b194 <_Scheduler_CBS_Create_server+0x9c><== ALWAYS TAKEN
200b174: b0 10 3f ef mov -17, %i0
200b178: 81 c7 e0 08 ret
200b17c: 81 e8 00 00 restore
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++ ) {
200b180: 80 a0 40 03 cmp %g1, %g3
200b184: 12 bf ff ec bne 200b134 <_Scheduler_CBS_Create_server+0x3c>
200b188: b7 28 60 02 sll %g1, 2, %i3
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
200b18c: 81 c7 e0 08 ret
200b190: 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;
200b194: c4 07 40 00 ld [ %i5 ], %g2
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
200b198: b0 10 20 00 clr %i0
_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;
200b19c: c4 20 60 04 st %g2, [ %g1 + 4 ]
200b1a0: c4 07 60 04 ld [ %i5 + 4 ], %g2
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
200b1a4: 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;
200b1a8: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
200b1ac: 84 10 3f ff mov -1, %g2
200b1b0: c4 20 40 00 st %g2, [ %g1 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
}
200b1b4: 81 c7 e0 08 ret
200b1b8: 81 e8 00 00 restore
0200b230 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
200b230: 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);
200b234: 90 10 00 19 mov %i1, %o0
200b238: 40 00 03 75 call 200c00c <_Thread_Get>
200b23c: 92 07 bf fc add %fp, -4, %o1
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
200b240: ba 92 20 00 orcc %o0, 0, %i5
200b244: 22 80 00 05 be,a 200b258 <_Scheduler_CBS_Detach_thread+0x28>
200b248: 03 00 80 81 sethi %hi(0x2020400), %g1
_Thread_Enable_dispatch();
200b24c: 40 00 03 63 call 200bfd8 <_Thread_Enable_dispatch>
200b250: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
200b254: 03 00 80 81 sethi %hi(0x2020400), %g1
200b258: c4 00 61 48 ld [ %g1 + 0x148 ], %g2 ! 2020548 <_Scheduler_CBS_Maximum_servers>
200b25c: 80 a6 00 02 cmp %i0, %g2
200b260: 1a 80 00 1b bcc 200b2cc <_Scheduler_CBS_Detach_thread+0x9c>
200b264: 82 10 3f ee mov -18, %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
200b268: 80 a7 60 00 cmp %i5, 0
200b26c: 02 80 00 18 be 200b2cc <_Scheduler_CBS_Detach_thread+0x9c>
200b270: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
200b274: 03 00 80 86 sethi %hi(0x2021800), %g1
200b278: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 ! 2021828 <_Scheduler_CBS_Server_list>
200b27c: b1 2e 20 02 sll %i0, 2, %i0
200b280: c4 00 40 18 ld [ %g1 + %i0 ], %g2
200b284: 80 a0 a0 00 cmp %g2, 0
200b288: 02 80 00 11 be 200b2cc <_Scheduler_CBS_Detach_thread+0x9c>
200b28c: 82 10 3f e7 mov -25, %g1
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
200b290: c6 00 80 00 ld [ %g2 ], %g3
200b294: 80 a0 c0 19 cmp %g3, %i1
200b298: 12 80 00 0d bne 200b2cc <_Scheduler_CBS_Detach_thread+0x9c><== NEVER TAKEN
200b29c: 82 10 3f ee mov -18, %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
200b2a0: 82 10 3f ff mov -1, %g1
200b2a4: c2 20 80 00 st %g1, [ %g2 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
200b2a8: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
200b2ac: c0 20 60 18 clr [ %g1 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
200b2b0: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
200b2b4: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
200b2b8: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
200b2bc: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
200b2c0: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
200b2c4: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
200b2c8: 82 10 20 00 clr %g1
}
200b2cc: 81 c7 e0 08 ret
200b2d0: 91 e8 00 01 restore %g0, %g1, %o0
0200b548 <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
200b548: 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*) );
200b54c: 3b 00 80 81 sethi %hi(0x2020400), %i5
200b550: d0 07 61 48 ld [ %i5 + 0x148 ], %o0 ! 2020548 <_Scheduler_CBS_Maximum_servers>
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
200b554: b0 10 3f ef mov -17, %i0
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
200b558: 40 00 06 ac call 200d008 <_Workspace_Allocate>
200b55c: 91 2a 20 02 sll %o0, 2, %o0
200b560: 05 00 80 86 sethi %hi(0x2021800), %g2
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
200b564: 80 a2 20 00 cmp %o0, 0
200b568: 02 80 00 0c be 200b598 <_Scheduler_CBS_Initialize+0x50> <== NEVER TAKEN
200b56c: d0 20 a0 28 st %o0, [ %g2 + 0x28 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b570: c6 07 61 48 ld [ %i5 + 0x148 ], %g3
200b574: 10 80 00 05 b 200b588 <_Scheduler_CBS_Initialize+0x40>
200b578: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b57c: 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++) {
200b580: 82 00 60 01 inc %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b584: 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++) {
200b588: 80 a0 40 03 cmp %g1, %g3
200b58c: 12 bf ff fc bne 200b57c <_Scheduler_CBS_Initialize+0x34>
200b590: fa 00 a0 28 ld [ %g2 + 0x28 ], %i5
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
200b594: b0 10 20 00 clr %i0
}
200b598: 81 c7 e0 08 ret
200b59c: 81 e8 00 00 restore
0200a144 <_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;
200a144: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
200a148: 80 a2 60 00 cmp %o1, 0
200a14c: 02 80 00 10 be 200a18c <_Scheduler_CBS_Release_job+0x48>
200a150: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
200a154: 80 a0 60 00 cmp %g1, 0
200a158: 02 80 00 08 be 200a178 <_Scheduler_CBS_Release_job+0x34>
200a15c: 05 00 80 7e sethi %hi(0x201f800), %g2
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
200a160: d2 00 a0 30 ld [ %g2 + 0x30 ], %o1 ! 201f830 <_Watchdog_Ticks_since_boot>
200a164: c4 00 60 04 ld [ %g1 + 4 ], %g2
200a168: 92 02 40 02 add %o1, %g2, %o1
200a16c: 05 20 00 00 sethi %hi(0x80000000), %g2
200a170: 10 80 00 0a b 200a198 <_Scheduler_CBS_Release_job+0x54>
200a174: 92 2a 40 02 andn %o1, %g2, %o1
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
200a178: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1
200a17c: 92 02 40 01 add %o1, %g1, %o1
200a180: 03 20 00 00 sethi %hi(0x80000000), %g1
200a184: 10 80 00 07 b 200a1a0 <_Scheduler_CBS_Release_job+0x5c>
200a188: 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)
200a18c: 80 a0 60 00 cmp %g1, 0
200a190: 02 80 00 04 be 200a1a0 <_Scheduler_CBS_Release_job+0x5c> <== NEVER TAKEN
200a194: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
200a198: c2 00 60 08 ld [ %g1 + 8 ], %g1
200a19c: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
200a1a0: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
200a1a4: 94 10 20 01 mov 1, %o2
200a1a8: 82 13 c0 00 mov %o7, %g1
200a1ac: 40 00 01 35 call 200a680 <_Thread_Change_priority>
200a1b0: 9e 10 40 00 mov %g1, %o7
0200a1b4 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
200a1b4: 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);
200a1b8: 40 00 00 57 call 200a314 <_Scheduler_EDF_Enqueue>
200a1bc: 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;
200a1c0: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
200a1c4: 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) {
200a1c8: 80 a7 60 00 cmp %i5, 0
200a1cc: 02 80 00 18 be 200a22c <_Scheduler_CBS_Unblock+0x78>
200a1d0: 03 00 80 7e sethi %hi(0x201f800), %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 ) {
200a1d4: 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 -
200a1d8: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
200a1dc: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
200a1e0: 40 00 3f 81 call 2019fe4 <.umul>
200a1e4: 90 27 00 08 sub %i4, %o0, %o0
200a1e8: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
200a1ec: b6 10 00 08 mov %o0, %i3
200a1f0: 40 00 3f 7d call 2019fe4 <.umul>
200a1f4: d0 07 60 08 ld [ %i5 + 8 ], %o0
200a1f8: 80 a6 c0 08 cmp %i3, %o0
200a1fc: 24 80 00 0d ble,a 200a230 <_Scheduler_CBS_Unblock+0x7c>
200a200: 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;
200a204: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200a208: 80 a7 00 09 cmp %i4, %o1
200a20c: 32 80 00 02 bne,a 200a214 <_Scheduler_CBS_Unblock+0x60>
200a210: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200a214: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a218: 80 a0 40 09 cmp %g1, %o1
200a21c: 02 80 00 04 be 200a22c <_Scheduler_CBS_Unblock+0x78>
200a220: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200a224: 40 00 01 17 call 200a680 <_Thread_Change_priority>
200a228: 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,
200a22c: 3b 00 80 7f sethi %hi(0x201fc00), %i5
200a230: ba 17 60 60 or %i5, 0x60, %i5 ! 201fc60 <_Per_CPU_Information>
200a234: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200a238: 03 00 80 7a sethi %hi(0x201e800), %g1
200a23c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
200a240: c2 00 61 dc ld [ %g1 + 0x1dc ], %g1
200a244: 9f c0 40 00 call %g1
200a248: d2 00 a0 14 ld [ %g2 + 0x14 ], %o1
200a24c: 80 a2 20 00 cmp %o0, 0
200a250: 04 80 00 0f ble 200a28c <_Scheduler_CBS_Unblock+0xd8>
200a254: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a258: 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;
200a25c: f0 27 60 10 st %i0, [ %i5 + 0x10 ]
if ( _Thread_Executing->is_preemptible ||
200a260: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a264: 80 a0 60 00 cmp %g1, 0
200a268: 12 80 00 06 bne 200a280 <_Scheduler_CBS_Unblock+0xcc>
200a26c: 84 10 20 01 mov 1, %g2
200a270: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a274: 80 a0 60 00 cmp %g1, 0
200a278: 12 80 00 05 bne 200a28c <_Scheduler_CBS_Unblock+0xd8> <== ALWAYS TAKEN
200a27c: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a280: 03 00 80 7f sethi %hi(0x201fc00), %g1
200a284: 82 10 60 60 or %g1, 0x60, %g1 ! 201fc60 <_Per_CPU_Information>
200a288: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
200a28c: 81 c7 e0 08 ret
200a290: 81 e8 00 00 restore
0200a294 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
200a294: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
200a298: 40 00 06 52 call 200bbe0 <_Workspace_Allocate>
200a29c: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
200a2a0: 80 a2 20 00 cmp %o0, 0
200a2a4: 02 80 00 05 be 200a2b8 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
200a2a8: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a2ac: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
200a2b0: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a2b4: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
200a2b8: 81 c7 e0 08 ret
200a2bc: 91 e8 00 08 restore %g0, %o0, %o0
0200a31c <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
200a31c: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
200a320: 7f ff ff a9 call 200a1c4 <_Scheduler_EDF_Enqueue>
200a324: 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(
200a328: 3b 00 80 7e sethi %hi(0x201f800), %i5
200a32c: ba 17 63 c0 or %i5, 0x3c0, %i5 ! 201fbc0 <_Per_CPU_Information>
200a330: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200a334: 03 00 80 7a sethi %hi(0x201e800), %g1
200a338: d0 00 a0 14 ld [ %g2 + 0x14 ], %o0
200a33c: c2 00 61 3c ld [ %g1 + 0x13c ], %g1
200a340: 9f c0 40 00 call %g1
200a344: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
200a348: 80 a2 20 00 cmp %o0, 0
200a34c: 16 80 00 0f bge 200a388 <_Scheduler_EDF_Unblock+0x6c>
200a350: 01 00 00 00 nop
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a354: 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;
200a358: f0 27 60 10 st %i0, [ %i5 + 0x10 ]
if ( _Thread_Executing->is_preemptible ||
200a35c: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a360: 80 a0 60 00 cmp %g1, 0
200a364: 12 80 00 06 bne 200a37c <_Scheduler_EDF_Unblock+0x60>
200a368: 84 10 20 01 mov 1, %g2
200a36c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a370: 80 a0 60 00 cmp %g1, 0
200a374: 12 80 00 05 bne 200a388 <_Scheduler_EDF_Unblock+0x6c> <== ALWAYS TAKEN
200a378: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a37c: 03 00 80 7e sethi %hi(0x201f800), %g1
200a380: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 201fbc0 <_Per_CPU_Information>
200a384: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
200a388: 81 c7 e0 08 ret
200a38c: 81 e8 00 00 restore
02009a2c <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
2009a2c: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing;
executing = _Thread_Executing;
2009a30: 03 00 80 78 sethi %hi(0x201e000), %g1
2009a34: fa 00 61 5c ld [ %g1 + 0x15c ], %i5 ! 201e15c <_Per_CPU_Information+0xc>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
2009a38: c2 0f 60 70 ldub [ %i5 + 0x70 ], %g1
2009a3c: 80 a0 60 00 cmp %g1, 0
2009a40: 02 80 00 25 be 2009ad4 <_Scheduler_priority_Tick+0xa8>
2009a44: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
2009a48: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2009a4c: 80 a0 60 00 cmp %g1, 0
2009a50: 12 80 00 21 bne 2009ad4 <_Scheduler_priority_Tick+0xa8>
2009a54: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
2009a58: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
2009a5c: 80 a0 60 01 cmp %g1, 1
2009a60: 0a 80 00 14 bcs 2009ab0 <_Scheduler_priority_Tick+0x84>
2009a64: 80 a0 60 02 cmp %g1, 2
2009a68: 28 80 00 07 bleu,a 2009a84 <_Scheduler_priority_Tick+0x58>
2009a6c: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
2009a70: 80 a0 60 03 cmp %g1, 3
2009a74: 12 80 00 18 bne 2009ad4 <_Scheduler_priority_Tick+0xa8> <== NEVER TAKEN
2009a78: 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 )
2009a7c: 10 80 00 0f b 2009ab8 <_Scheduler_priority_Tick+0x8c>
2009a80: 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 ) {
2009a84: 82 00 7f ff add %g1, -1, %g1
2009a88: 80 a0 60 00 cmp %g1, 0
2009a8c: 14 80 00 09 bg 2009ab0 <_Scheduler_priority_Tick+0x84>
2009a90: 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();
2009a94: 03 00 80 73 sethi %hi(0x201cc00), %g1
2009a98: c2 00 63 28 ld [ %g1 + 0x328 ], %g1 ! 201cf28 <_Scheduler+0xc>
2009a9c: 9f c0 40 00 call %g1
2009aa0: 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;
2009aa4: 03 00 80 76 sethi %hi(0x201d800), %g1
2009aa8: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 201db74 <_Thread_Ticks_per_timeslice>
2009aac: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
2009ab0: 81 c7 e0 08 ret
2009ab4: 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 )
2009ab8: 82 00 7f ff add %g1, -1, %g1
2009abc: 80 a0 60 00 cmp %g1, 0
2009ac0: 12 bf ff fc bne 2009ab0 <_Scheduler_priority_Tick+0x84>
2009ac4: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*executing->budget_callout)( executing );
2009ac8: c2 07 60 7c ld [ %i5 + 0x7c ], %g1
2009acc: 9f c0 40 00 call %g1
2009ad0: 90 10 00 1d mov %i5, %o0
2009ad4: 81 c7 e0 08 ret
2009ad8: 81 e8 00 00 restore
020087d0 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
20087d0: 9d e3 bf a0 save %sp, -96, %sp
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
20087d4: 03 00 80 73 sethi %hi(0x201cc00), %g1
20087d8: c2 00 62 3c ld [ %g1 + 0x23c ], %g1 ! 201ce3c <Configuration+0x10>
const Timestamp64_Control *_add
)
{
Timestamp64_Control _start = *_time / 1000000000L;
*_time += *_add;
if ( ((*_time) / 1000000000L) != _start ) {
20087dc: 94 10 20 00 clr %o2
20087e0: 85 28 60 02 sll %g1, 2, %g2
20087e4: 91 28 60 07 sll %g1, 7, %o0
20087e8: 90 22 00 02 sub %o0, %g2, %o0
20087ec: 90 02 00 01 add %o0, %g1, %o0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
20087f0: 03 00 80 77 sethi %hi(0x201dc00), %g1
20087f4: c4 00 61 20 ld [ %g1 + 0x120 ], %g2 ! 201dd20 <_Watchdog_Ticks_since_boot>
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
20087f8: 91 2a 20 03 sll %o0, 3, %o0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
20087fc: 84 00 a0 01 inc %g2
2008800: c4 20 61 20 st %g2, [ %g1 + 0x120 ]
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2008804: 03 00 80 77 sethi %hi(0x201dc00), %g1
2008808: c4 18 60 90 ldd [ %g1 + 0x90 ], %g2 ! 201dc90 <_TOD_Uptime>
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
200880c: 92 10 00 08 mov %o0, %o1
2008810: 90 10 20 00 clr %o0
2008814: 86 80 c0 09 addcc %g3, %o1, %g3
2008818: 84 40 80 08 addx %g2, %o0, %g2
200881c: c4 38 60 90 std %g2, [ %g1 + 0x90 ]
static inline uint32_t _Timestamp64_Add_to_at_tick(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
Timestamp64_Control _start = *_time / 1000000000L;
2008820: 03 00 80 77 sethi %hi(0x201dc00), %g1
2008824: f8 18 60 a0 ldd [ %g1 + 0xa0 ], %i4 ! 201dca0 <_TOD_Now>
*_time += *_add;
if ( ((*_time) / 1000000000L) != _start ) {
2008828: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
Timestamp64_Control _start = *_time / 1000000000L;
*_time += *_add;
200882c: 92 87 40 09 addcc %i5, %o1, %o1
if ( ((*_time) / 1000000000L) != _start ) {
2008830: 96 12 e2 00 or %o3, 0x200, %o3
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
Timestamp64_Control _start = *_time / 1000000000L;
*_time += *_add;
2008834: 90 47 00 08 addx %i4, %o0, %o0
if ( ((*_time) / 1000000000L) != _start ) {
2008838: 40 00 41 4f call 2018d74 <__divdi3>
200883c: d0 38 60 a0 std %o0, [ %g1 + 0xa0 ]
static inline uint32_t _Timestamp64_Add_to_at_tick(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
Timestamp64_Control _start = *_time / 1000000000L;
2008840: 94 10 20 00 clr %o2
*_time += *_add;
if ( ((*_time) / 1000000000L) != _start ) {
2008844: b4 10 00 08 mov %o0, %i2
2008848: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_Add_to_at_tick(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
Timestamp64_Control _start = *_time / 1000000000L;
200884c: 90 10 00 1c mov %i4, %o0
2008850: 92 10 00 1d mov %i5, %o1
2008854: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2008858: 40 00 41 47 call 2018d74 <__divdi3>
200885c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_Timestamp_Add_to( &_TOD_Uptime, &tick );
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
while ( seconds ) {
2008860: 80 a6 80 08 cmp %i2, %o0
2008864: 12 80 00 05 bne 2008878 <_TOD_Tickle_ticks+0xa8> <== NEVER TAKEN
2008868: 31 00 80 77 sethi %hi(0x201dc00), %i0
200886c: 80 a6 c0 09 cmp %i3, %o1
2008870: 02 80 00 04 be 2008880 <_TOD_Tickle_ticks+0xb0>
2008874: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
2008878: 40 00 0a 07 call 200b094 <_Watchdog_Tickle>
200887c: 91 ee 20 c4 restore %i0, 0xc4, %o0
2008880: 81 c7 e0 08 ret
2008884: 81 e8 00 00 restore
02008664 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
2008664: 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 /
rtems_configuration_get_microseconds_per_tick();
2008668: 03 00 80 7d sethi %hi(0x201f400), %g1
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
200866c: ba 10 20 00 clr %i5
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
2008670: 80 a6 20 00 cmp %i0, 0
2008674: 02 80 00 2b be 2008720 <_TOD_Validate+0xbc> <== NEVER TAKEN
2008678: d2 00 61 7c ld [ %g1 + 0x17c ], %o1
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
200867c: 11 00 03 d0 sethi %hi(0xf4000), %o0
2008680: 40 00 48 8c call 201a8b0 <.udiv>
2008684: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
2008688: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200868c: 80 a0 40 08 cmp %g1, %o0
2008690: 3a 80 00 25 bcc,a 2008724 <_TOD_Validate+0xc0>
2008694: b0 0f 60 01 and %i5, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
2008698: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200869c: 80 a0 60 3b cmp %g1, 0x3b
20086a0: 38 80 00 21 bgu,a 2008724 <_TOD_Validate+0xc0>
20086a4: b0 0f 60 01 and %i5, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
20086a8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20086ac: 80 a0 60 3b cmp %g1, 0x3b
20086b0: 38 80 00 1d bgu,a 2008724 <_TOD_Validate+0xc0>
20086b4: b0 0f 60 01 and %i5, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
20086b8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20086bc: 80 a0 60 17 cmp %g1, 0x17
20086c0: 38 80 00 19 bgu,a 2008724 <_TOD_Validate+0xc0>
20086c4: b0 0f 60 01 and %i5, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
20086c8: 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) ||
20086cc: 80 a0 60 00 cmp %g1, 0
20086d0: 02 80 00 14 be 2008720 <_TOD_Validate+0xbc> <== NEVER TAKEN
20086d4: 80 a0 60 0c cmp %g1, 0xc
(the_tod->month == 0) ||
20086d8: 38 80 00 13 bgu,a 2008724 <_TOD_Validate+0xc0>
20086dc: b0 0f 60 01 and %i5, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
20086e0: c6 06 00 00 ld [ %i0 ], %g3
(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) ||
20086e4: 80 a0 e7 c3 cmp %g3, 0x7c3
20086e8: 28 80 00 0f bleu,a 2008724 <_TOD_Validate+0xc0>
20086ec: b0 0f 60 01 and %i5, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
20086f0: c4 06 20 08 ld [ %i0 + 8 ], %g2
(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) ||
20086f4: 80 a0 a0 00 cmp %g2, 0
20086f8: 02 80 00 0a be 2008720 <_TOD_Validate+0xbc> <== NEVER TAKEN
20086fc: 80 88 e0 03 btst 3, %g3
2008700: 07 00 80 77 sethi %hi(0x201dc00), %g3
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
2008704: 12 80 00 03 bne 2008710 <_TOD_Validate+0xac>
2008708: 86 10 e3 b8 or %g3, 0x3b8, %g3 ! 201dfb8 <_TOD_Days_per_month>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
200870c: 82 00 60 0d add %g1, 0xd, %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
2008710: 83 28 60 02 sll %g1, 2, %g1
2008714: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
2008718: 80 a0 40 02 cmp %g1, %g2
200871c: ba 60 3f ff subx %g0, -1, %i5
if ( the_tod->day > days_in_month )
return false;
return true;
}
2008720: b0 0f 60 01 and %i5, 1, %i0
2008724: 81 c7 e0 08 ret
2008728: 81 e8 00 00 restore
02009cec <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
2009cec: 9d e3 bf a0 save %sp, -96, %sp
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
2009cf0: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
/*
* 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 );
2009cf4: 40 00 03 67 call 200aa90 <_Thread_Set_transient>
2009cf8: 90 10 00 18 mov %i0, %o0
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
2009cfc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2009d00: 80 a0 40 19 cmp %g1, %i1
2009d04: 02 80 00 05 be 2009d18 <_Thread_Change_priority+0x2c>
2009d08: ba 10 00 18 mov %i0, %i5
_Thread_Set_priority( the_thread, new_priority );
2009d0c: 90 10 00 18 mov %i0, %o0
2009d10: 40 00 03 47 call 200aa2c <_Thread_Set_priority>
2009d14: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
2009d18: 7f ff e2 35 call 20025ec <sparc_disable_interrupts>
2009d1c: 01 00 00 00 nop
2009d20: 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;
2009d24: f2 07 60 10 ld [ %i5 + 0x10 ], %i1
if ( state != STATES_TRANSIENT ) {
2009d28: 80 a6 60 04 cmp %i1, 4
2009d2c: 02 80 00 10 be 2009d6c <_Thread_Change_priority+0x80>
2009d30: b8 0f 20 04 and %i4, 4, %i4
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
2009d34: 80 a7 20 00 cmp %i4, 0
2009d38: 12 80 00 03 bne 2009d44 <_Thread_Change_priority+0x58> <== NEVER TAKEN
2009d3c: 82 0e 7f fb and %i1, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
2009d40: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
2009d44: 7f ff e2 2e call 20025fc <sparc_enable_interrupts>
2009d48: 90 10 00 1b mov %i3, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
2009d4c: 03 00 00 ef sethi %hi(0x3bc00), %g1
2009d50: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
2009d54: 80 8e 40 01 btst %i1, %g1
2009d58: 02 80 00 29 be 2009dfc <_Thread_Change_priority+0x110>
2009d5c: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
2009d60: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
2009d64: 40 00 03 04 call 200a974 <_Thread_queue_Requeue>
2009d68: 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 ) ) {
2009d6c: 80 a7 20 00 cmp %i4, 0
2009d70: 12 80 00 0b bne 2009d9c <_Thread_Change_priority+0xb0> <== NEVER TAKEN
2009d74: 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 );
2009d78: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( prepend_it )
2009d7c: 80 a6 a0 00 cmp %i2, 0
2009d80: 02 80 00 04 be 2009d90 <_Thread_Change_priority+0xa4>
2009d84: 82 10 63 1c or %g1, 0x31c, %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
2009d88: 10 80 00 03 b 2009d94 <_Thread_Change_priority+0xa8>
2009d8c: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
2009d90: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2009d94: 9f c0 40 00 call %g1
2009d98: 90 10 00 1d mov %i5, %o0
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
2009d9c: 7f ff e2 18 call 20025fc <sparc_enable_interrupts>
2009da0: 90 10 00 1b mov %i3, %o0
2009da4: 7f ff e2 12 call 20025ec <sparc_disable_interrupts>
2009da8: 01 00 00 00 nop
2009dac: 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();
2009db0: 03 00 80 73 sethi %hi(0x201cc00), %g1
2009db4: c2 00 63 24 ld [ %g1 + 0x324 ], %g1 ! 201cf24 <_Scheduler+0x8>
2009db8: 9f c0 40 00 call %g1
2009dbc: 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 );
2009dc0: 03 00 80 78 sethi %hi(0x201e000), %g1
2009dc4: 82 10 61 50 or %g1, 0x150, %g1 ! 201e150 <_Per_CPU_Information>
2009dc8: 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() &&
2009dcc: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
2009dd0: 80 a0 80 03 cmp %g2, %g3
2009dd4: 02 80 00 08 be 2009df4 <_Thread_Change_priority+0x108>
2009dd8: 01 00 00 00 nop
2009ddc: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
2009de0: 80 a0 a0 00 cmp %g2, 0
2009de4: 02 80 00 04 be 2009df4 <_Thread_Change_priority+0x108>
2009de8: 01 00 00 00 nop
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
2009dec: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
2009df0: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
_ISR_Enable( level );
2009df4: 7f ff e2 02 call 20025fc <sparc_enable_interrupts>
2009df8: 81 e8 00 00 restore
2009dfc: 81 c7 e0 08 ret
2009e00: 81 e8 00 00 restore
02009ff0 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
2009ff0: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
2009ff4: 90 10 00 18 mov %i0, %o0
2009ff8: 40 00 00 6f call 200a1b4 <_Thread_Get>
2009ffc: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a000: c2 07 bf fc ld [ %fp + -4 ], %g1
200a004: 80 a0 60 00 cmp %g1, 0
200a008: 12 80 00 09 bne 200a02c <_Thread_Delay_ended+0x3c> <== NEVER TAKEN
200a00c: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
200a010: 7f ff ff 7d call 2009e04 <_Thread_Clear_state>
200a014: 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--;
200a018: 03 00 80 77 sethi %hi(0x201dc00), %g1
200a01c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201dc10 <_Thread_Dispatch_disable_level>
200a020: 84 00 bf ff add %g2, -1, %g2
200a024: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
return _Thread_Dispatch_disable_level;
200a028: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200a02c: 81 c7 e0 08 ret
200a030: 81 e8 00 00 restore
0200a034 <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
200a034: 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++;
200a038: 03 00 80 77 sethi %hi(0x201dc00), %g1
200a03c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201dc10 <_Thread_Dispatch_disable_level>
200a040: 84 00 a0 01 inc %g2
200a044: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
return _Thread_Dispatch_disable_level;
200a048: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
200a04c: 37 00 80 78 sethi %hi(0x201e000), %i3
200a050: 82 16 e1 50 or %i3, 0x150, %g1 ! 201e150 <_Per_CPU_Information>
_ISR_Disable( level );
200a054: 7f ff e1 66 call 20025ec <sparc_disable_interrupts>
200a058: fa 00 60 0c ld [ %g1 + 0xc ], %i5
#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;
200a05c: 35 00 80 76 sethi %hi(0x201d800), %i2
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
200a060: 31 00 80 77 sethi %hi(0x201dc00), %i0
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
200a064: 10 80 00 37 b 200a140 <_Thread_Dispatch+0x10c>
200a068: 33 00 80 77 sethi %hi(0x201dc00), %i1
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
200a06c: 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 )
200a070: 80 a7 00 1d cmp %i4, %i5
200a074: 02 80 00 38 be 200a154 <_Thread_Dispatch+0x120>
200a078: f8 20 60 0c st %i4, [ %g1 + 0xc ]
*/
#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 )
200a07c: c2 07 20 78 ld [ %i4 + 0x78 ], %g1
200a080: 80 a0 60 01 cmp %g1, 1
200a084: 12 80 00 03 bne 200a090 <_Thread_Dispatch+0x5c>
200a088: c2 06 a3 74 ld [ %i2 + 0x374 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a08c: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
_ISR_Enable( level );
200a090: 7f ff e1 5b call 20025fc <sparc_enable_interrupts>
200a094: 01 00 00 00 nop
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
200a098: 40 00 0d 3a call 200d580 <_TOD_Get_uptime>
200a09c: 90 07 bf f8 add %fp, -8, %o0
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
200a0a0: c4 1f 60 80 ldd [ %i5 + 0x80 ], %g2
_Timestamp_Subtract(
200a0a4: d4 1f bf f8 ldd [ %fp + -8 ], %o2
200a0a8: 82 16 e1 50 or %i3, 0x150, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
200a0ac: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
200a0b0: 9a a2 c0 0d subcc %o3, %o5, %o5
200a0b4: 98 62 80 0c subx %o2, %o4, %o4
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
200a0b8: 86 80 c0 0d addcc %g3, %o5, %g3
200a0bc: 84 40 80 0c addx %g2, %o4, %g2
200a0c0: c4 3f 60 80 std %g2, [ %i5 + 0x80 ]
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
200a0c4: d4 38 60 20 std %o2, [ %g1 + 0x20 ]
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
200a0c8: c2 06 20 9c ld [ %i0 + 0x9c ], %g1
200a0cc: 80 a0 60 00 cmp %g1, 0
200a0d0: 02 80 00 06 be 200a0e8 <_Thread_Dispatch+0xb4> <== NEVER TAKEN
200a0d4: 90 10 00 1d mov %i5, %o0
executing->libc_reent = *_Thread_libc_reent;
200a0d8: c4 00 40 00 ld [ %g1 ], %g2
200a0dc: c4 27 61 54 st %g2, [ %i5 + 0x154 ]
*_Thread_libc_reent = heir->libc_reent;
200a0e0: c4 07 21 54 ld [ %i4 + 0x154 ], %g2
200a0e4: c4 20 40 00 st %g2, [ %g1 ]
}
_User_extensions_Thread_switch( executing, heir );
200a0e8: 40 00 03 59 call 200ae4c <_User_extensions_Thread_switch>
200a0ec: 92 10 00 1c mov %i4, %o1
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
200a0f0: 90 07 60 c8 add %i5, 0xc8, %o0
200a0f4: 40 00 04 85 call 200b308 <_CPU_Context_switch>
200a0f8: 92 07 20 c8 add %i4, 0xc8, %o1
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
200a0fc: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
200a100: 80 a0 60 00 cmp %g1, 0
200a104: 02 80 00 0c be 200a134 <_Thread_Dispatch+0x100>
200a108: d0 06 60 98 ld [ %i1 + 0x98 ], %o0
200a10c: 80 a7 40 08 cmp %i5, %o0
200a110: 02 80 00 09 be 200a134 <_Thread_Dispatch+0x100>
200a114: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200a118: 02 80 00 04 be 200a128 <_Thread_Dispatch+0xf4>
200a11c: 01 00 00 00 nop
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200a120: 40 00 04 40 call 200b220 <_CPU_Context_save_fp>
200a124: 90 02 21 50 add %o0, 0x150, %o0
_Context_Restore_fp( &executing->fp_context );
200a128: 40 00 04 5b call 200b294 <_CPU_Context_restore_fp>
200a12c: 90 07 61 50 add %i5, 0x150, %o0
_Thread_Allocated_fp = executing;
200a130: fa 26 60 98 st %i5, [ %i1 + 0x98 ]
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
200a134: 82 16 e1 50 or %i3, 0x150, %g1
_ISR_Disable( level );
200a138: 7f ff e1 2d call 20025ec <sparc_disable_interrupts>
200a13c: fa 00 60 0c ld [ %g1 + 0xc ], %i5
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
200a140: 82 16 e1 50 or %i3, 0x150, %g1
200a144: c4 08 60 18 ldub [ %g1 + 0x18 ], %g2
200a148: 80 a0 a0 00 cmp %g2, 0
200a14c: 32 bf ff c8 bne,a 200a06c <_Thread_Dispatch+0x38>
200a150: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
_ISR_Disable( level );
}
post_switch:
_ISR_Enable( level );
200a154: 7f ff e1 2a call 20025fc <sparc_enable_interrupts>
200a158: 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--;
200a15c: 03 00 80 77 sethi %hi(0x201dc00), %g1
200a160: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201dc10 <_Thread_Dispatch_disable_level>
200a164: 84 00 bf ff add %g2, -1, %g2
200a168: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
return _Thread_Dispatch_disable_level;
200a16c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
200a170: 7f ff f8 14 call 20081c0 <_API_extensions_Run_postswitch>
200a174: 01 00 00 00 nop
}
200a178: 81 c7 e0 08 ret
200a17c: 81 e8 00 00 restore
0200f628 <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
200f628: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
200f62c: 03 00 80 78 sethi %hi(0x201e000), %g1
200f630: fa 00 61 5c ld [ %g1 + 0x15c ], %i5 ! 201e15c <_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();
200f634: 3f 00 80 3d sethi %hi(0x200f400), %i7
200f638: be 17 e2 28 or %i7, 0x228, %i7 ! 200f628 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
200f63c: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
200f640: 7f ff cb ef call 20025fc <sparc_enable_interrupts>
200f644: 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;
200f648: 03 00 80 76 sethi %hi(0x201d800), %g1
doneConstructors = true;
200f64c: 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;
200f650: f8 08 60 38 ldub [ %g1 + 0x38 ], %i4
doneConstructors = true;
200f654: c4 28 60 38 stb %g2, [ %g1 + 0x38 ]
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
200f658: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
200f65c: 80 a0 60 00 cmp %g1, 0
200f660: 02 80 00 0c be 200f690 <_Thread_Handler+0x68>
200f664: 03 00 80 77 sethi %hi(0x201dc00), %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 );
200f668: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 ! 201dc98 <_Thread_Allocated_fp>
200f66c: 80 a7 40 08 cmp %i5, %o0
200f670: 02 80 00 08 be 200f690 <_Thread_Handler+0x68>
200f674: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200f678: 22 80 00 06 be,a 200f690 <_Thread_Handler+0x68>
200f67c: fa 20 60 98 st %i5, [ %g1 + 0x98 ]
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200f680: 7f ff ee e8 call 200b220 <_CPU_Context_save_fp>
200f684: 90 02 21 50 add %o0, 0x150, %o0
_Thread_Allocated_fp = executing;
200f688: 03 00 80 77 sethi %hi(0x201dc00), %g1
200f68c: fa 20 60 98 st %i5, [ %g1 + 0x98 ] ! 201dc98 <_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 );
200f690: 7f ff ed 80 call 200ac90 <_User_extensions_Thread_begin>
200f694: 90 10 00 1d mov %i5, %o0
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
200f698: 7f ff ea ba call 200a180 <_Thread_Enable_dispatch>
200f69c: 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) */ {
200f6a0: 80 8f 20 ff btst 0xff, %i4
200f6a4: 32 80 00 05 bne,a 200f6b8 <_Thread_Handler+0x90>
200f6a8: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
INIT_NAME ();
200f6ac: 40 00 35 cf call 201cde8 <_init>
200f6b0: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
200f6b4: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
200f6b8: 80 a0 60 00 cmp %g1, 0
200f6bc: 12 80 00 05 bne 200f6d0 <_Thread_Handler+0xa8>
200f6c0: 80 a0 60 01 cmp %g1, 1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
200f6c4: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f6c8: 10 80 00 06 b 200f6e0 <_Thread_Handler+0xb8>
200f6cc: 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 ) {
200f6d0: 12 80 00 07 bne 200f6ec <_Thread_Handler+0xc4> <== NEVER TAKEN
200f6d4: 01 00 00 00 nop
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
200f6d8: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f6dc: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
200f6e0: 9f c0 40 00 call %g1
200f6e4: 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 =
200f6e8: 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 );
200f6ec: 7f ff ed 7a call 200acd4 <_User_extensions_Thread_exitted>
200f6f0: 90 10 00 1d mov %i5, %o0
_Internal_error_Occurred(
200f6f4: 90 10 20 00 clr %o0
200f6f8: 92 10 20 01 mov 1, %o1
200f6fc: 7f ff e5 5c call 2008c6c <_Internal_error_Occurred>
200f700: 94 10 20 05 mov 5, %o2
0200a454 <_Thread_Handler_initialization>:
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
200a454: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
200a458: 05 00 80 73 sethi %hi(0x201cc00), %g2
200a45c: 84 10 a2 2c or %g2, 0x22c, %g2 ! 201ce2c <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200a460: c6 00 a0 28 ld [ %g2 + 0x28 ], %g3
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
200a464: fa 00 a0 14 ld [ %g2 + 0x14 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
200a468: f8 00 a0 0c ld [ %g2 + 0xc ], %i4
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200a46c: 80 a0 e0 00 cmp %g3, 0
200a470: 02 80 00 06 be 200a488 <_Thread_Handler_initialization+0x34>
200a474: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1
200a478: c6 00 a0 2c ld [ %g2 + 0x2c ], %g3
200a47c: 80 a0 e0 00 cmp %g3, 0
200a480: 12 80 00 06 bne 200a498 <_Thread_Handler_initialization+0x44><== ALWAYS TAKEN
200a484: 80 a0 60 00 cmp %g1, 0
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
200a488: 90 10 20 00 clr %o0
200a48c: 92 10 20 01 mov 1, %o1
200a490: 7f ff f9 f7 call 2008c6c <_Internal_error_Occurred>
200a494: 94 10 20 0e mov 0xe, %o2
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
200a498: 22 80 00 05 be,a 200a4ac <_Thread_Handler_initialization+0x58>
200a49c: 03 00 80 78 sethi %hi(0x201e000), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
200a4a0: 9f c0 40 00 call %g1
200a4a4: d0 00 a0 08 ld [ %g2 + 8 ], %o0
_Thread_Dispatch_necessary = false;
200a4a8: 03 00 80 78 sethi %hi(0x201e000), %g1
200a4ac: 82 10 61 50 or %g1, 0x150, %g1 ! 201e150 <_Per_CPU_Information>
200a4b0: c0 28 60 18 clrb [ %g1 + 0x18 ]
_Thread_Executing = NULL;
200a4b4: c0 20 60 0c clr [ %g1 + 0xc ]
_Thread_Heir = NULL;
200a4b8: c0 20 60 10 clr [ %g1 + 0x10 ]
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
200a4bc: 03 00 80 77 sethi %hi(0x201dc00), %g1
200a4c0: c0 20 60 98 clr [ %g1 + 0x98 ] ! 201dc98 <_Thread_Allocated_fp>
#endif
_Thread_Maximum_extensions = maximum_extensions;
200a4c4: 03 00 80 77 sethi %hi(0x201dc00), %g1
200a4c8: f8 20 60 a8 st %i4, [ %g1 + 0xa8 ] ! 201dca8 <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
200a4cc: 03 00 80 76 sethi %hi(0x201d800), %g1
200a4d0: fa 20 63 74 st %i5, [ %g1 + 0x374 ] ! 201db74 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
200a4d4: 82 10 20 08 mov 8, %g1
200a4d8: 11 00 80 77 sethi %hi(0x201dc00), %o0
200a4dc: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200a4e0: 90 12 21 28 or %o0, 0x128, %o0
200a4e4: 92 10 20 01 mov 1, %o1
200a4e8: 94 10 20 01 mov 1, %o2
200a4ec: 96 10 20 01 mov 1, %o3
200a4f0: 98 10 21 68 mov 0x168, %o4
200a4f4: 7f ff fb 63 call 2009280 <_Objects_Initialize_information>
200a4f8: 9a 10 20 00 clr %o5
false, /* true if this is a global object class */
NULL /* Proxy extraction support callout */
#endif
);
}
200a4fc: 81 c7 e0 08 ret
200a500: 81 e8 00 00 restore
0200a264 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
200a264: 9d e3 bf a0 save %sp, -96, %sp
200a268: 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;
200a26c: c0 26 61 58 clr [ %i1 + 0x158 ]
200a270: c0 26 61 5c clr [ %i1 + 0x15c ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
200a274: 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
)
{
200a278: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
200a27c: 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 ) {
200a280: 80 a6 a0 00 cmp %i2, 0
200a284: 12 80 00 0d bne 200a2b8 <_Thread_Initialize+0x54>
200a288: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
200a28c: 90 10 00 19 mov %i1, %o0
200a290: 40 00 02 0f call 200aacc <_Thread_Stack_Allocate>
200a294: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
200a298: 80 a2 00 1b cmp %o0, %i3
200a29c: 0a 80 00 6a bcs 200a444 <_Thread_Initialize+0x1e0>
200a2a0: 80 a2 20 00 cmp %o0, 0
200a2a4: 02 80 00 68 be 200a444 <_Thread_Initialize+0x1e0> <== NEVER TAKEN
200a2a8: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
200a2ac: f4 06 60 c0 ld [ %i1 + 0xc0 ], %i2
the_thread->Start.core_allocated_stack = true;
200a2b0: 10 80 00 04 b 200a2c0 <_Thread_Initialize+0x5c>
200a2b4: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
200a2b8: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
200a2bc: 90 10 00 1b mov %i3, %o0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
200a2c0: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
the_stack->size = size;
200a2c4: 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 ) {
200a2c8: 80 a7 20 00 cmp %i4, 0
200a2cc: 02 80 00 07 be 200a2e8 <_Thread_Initialize+0x84>
200a2d0: b6 10 20 00 clr %i3
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
200a2d4: 40 00 03 b7 call 200b1b0 <_Workspace_Allocate>
200a2d8: 90 10 20 88 mov 0x88, %o0
if ( !fp_area )
200a2dc: b6 92 20 00 orcc %o0, 0, %i3
200a2e0: 02 80 00 4a be 200a408 <_Thread_Initialize+0x1a4>
200a2e4: b8 10 20 00 clr %i4
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a2e8: 03 00 80 77 sethi %hi(0x201dc00), %g1
200a2ec: d0 00 60 a8 ld [ %g1 + 0xa8 ], %o0 ! 201dca8 <_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;
200a2f0: f6 26 61 50 st %i3, [ %i1 + 0x150 ]
the_thread->Start.fp_context = fp_area;
200a2f4: f6 26 60 bc st %i3, [ %i1 + 0xbc ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
200a2f8: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
200a2fc: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
200a300: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
200a304: c0 26 60 6c clr [ %i1 + 0x6c ]
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a308: 80 a2 20 00 cmp %o0, 0
200a30c: 02 80 00 08 be 200a32c <_Thread_Initialize+0xc8>
200a310: b8 10 20 00 clr %i4
extensions_area = _Workspace_Allocate(
200a314: 90 02 20 01 inc %o0
200a318: 40 00 03 a6 call 200b1b0 <_Workspace_Allocate>
200a31c: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
200a320: b8 92 20 00 orcc %o0, 0, %i4
200a324: 02 80 00 3a be 200a40c <_Thread_Initialize+0x1a8>
200a328: 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 ) {
200a32c: 80 a7 20 00 cmp %i4, 0
200a330: 02 80 00 0c be 200a360 <_Thread_Initialize+0xfc>
200a334: f8 26 61 60 st %i4, [ %i1 + 0x160 ]
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
200a338: 03 00 80 77 sethi %hi(0x201dc00), %g1
200a33c: c4 00 60 a8 ld [ %g1 + 0xa8 ], %g2 ! 201dca8 <_Thread_Maximum_extensions>
200a340: 10 80 00 05 b 200a354 <_Thread_Initialize+0xf0>
200a344: 82 10 20 00 clr %g1
the_thread->extensions[i] = NULL;
200a348: 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++ )
200a34c: 82 00 60 01 inc %g1
the_thread->extensions[i] = NULL;
200a350: 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++ )
200a354: 80 a0 40 02 cmp %g1, %g2
200a358: 28 bf ff fc bleu,a 200a348 <_Thread_Initialize+0xe4>
200a35c: 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;
200a360: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
200a364: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
200a368: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
200a36c: 80 a4 20 02 cmp %l0, 2
200a370: 12 80 00 05 bne 200a384 <_Thread_Initialize+0x120>
200a374: 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;
200a378: 03 00 80 76 sethi %hi(0x201d800), %g1
200a37c: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 201db74 <_Thread_Ticks_per_timeslice>
200a380: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a384: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.queue = NULL;
200a388: c0 26 60 44 clr [ %i1 + 0x44 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a38c: c2 26 60 a8 st %g1, [ %i1 + 0xa8 ]
the_thread->current_state = STATES_DORMANT;
200a390: 82 10 20 01 mov 1, %g1
200a394: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
200a398: 03 00 80 73 sethi %hi(0x201cc00), %g1
200a39c: c2 00 63 34 ld [ %g1 + 0x334 ], %g1 ! 201cf34 <_Scheduler+0x18>
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
200a3a0: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
200a3a4: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
200a3a8: fa 26 60 ac st %i5, [ %i1 + 0xac ]
200a3ac: 9f c0 40 00 call %g1
200a3b0: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
200a3b4: b4 92 20 00 orcc %o0, 0, %i2
200a3b8: 02 80 00 15 be 200a40c <_Thread_Initialize+0x1a8>
200a3bc: 90 10 00 19 mov %i1, %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
200a3c0: 40 00 01 9b call 200aa2c <_Thread_Set_priority>
200a3c4: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a3c8: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
200a3cc: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
200a3d0: c0 26 60 80 clr [ %i1 + 0x80 ]
200a3d4: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a3d8: 83 28 60 02 sll %g1, 2, %g1
200a3dc: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200a3e0: 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 );
200a3e4: 90 10 00 19 mov %i1, %o0
200a3e8: 40 00 02 5c call 200ad58 <_User_extensions_Thread_create>
200a3ec: b0 10 20 01 mov 1, %i0
if ( extension_status )
200a3f0: 80 8a 20 ff btst 0xff, %o0
200a3f4: 02 80 00 06 be 200a40c <_Thread_Initialize+0x1a8>
200a3f8: 01 00 00 00 nop
200a3fc: b0 0e 20 01 and %i0, 1, %i0
200a400: 81 c7 e0 08 ret
200a404: 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;
200a408: 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 );
200a40c: 40 00 03 71 call 200b1d0 <_Workspace_Free>
200a410: d0 06 61 54 ld [ %i1 + 0x154 ], %o0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
200a414: 40 00 03 6f call 200b1d0 <_Workspace_Free>
200a418: d0 06 61 58 ld [ %i1 + 0x158 ], %o0
200a41c: 40 00 03 6d call 200b1d0 <_Workspace_Free>
200a420: d0 06 61 5c ld [ %i1 + 0x15c ], %o0
_Workspace_Free( extensions_area );
200a424: 40 00 03 6b call 200b1d0 <_Workspace_Free>
200a428: 90 10 00 1c mov %i4, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
200a42c: 40 00 03 69 call 200b1d0 <_Workspace_Free>
200a430: 90 10 00 1b mov %i3, %o0
#endif
_Workspace_Free( sched );
200a434: 40 00 03 67 call 200b1d0 <_Workspace_Free>
200a438: 90 10 00 1a mov %i2, %o0
_Thread_Stack_Free( the_thread );
200a43c: 40 00 01 b5 call 200ab10 <_Thread_Stack_Free>
200a440: 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 */
200a444: b0 10 20 00 clr %i0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
200a448: b0 0e 20 01 and %i0, 1, %i0
200a44c: 81 c7 e0 08 ret
200a450: 81 e8 00 00 restore
0200ab10 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
200ab10: 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 )
200ab14: c4 0e 20 b0 ldub [ %i0 + 0xb0 ], %g2
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
200ab18: 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 )
200ab1c: 80 a0 a0 00 cmp %g2, 0
200ab20: 02 80 00 04 be 200ab30 <_Thread_Stack_Free+0x20> <== NEVER TAKEN
200ab24: c2 00 62 58 ld [ %g1 + 0x258 ], %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 );
200ab28: 9f c0 40 00 call %g1
200ab2c: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
200ab30: 81 c7 e0 08 ret
200ab34: 81 e8 00 00 restore
0200a974 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
200a974: 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 )
200a978: 80 a6 20 00 cmp %i0, 0
200a97c: 02 80 00 19 be 200a9e0 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a980: 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 ) {
200a984: f8 06 20 34 ld [ %i0 + 0x34 ], %i4
200a988: 80 a7 20 01 cmp %i4, 1
200a98c: 12 80 00 15 bne 200a9e0 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a990: 01 00 00 00 nop
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
200a994: 7f ff df 16 call 20025ec <sparc_disable_interrupts>
200a998: 01 00 00 00 nop
200a99c: ba 10 00 08 mov %o0, %i5
200a9a0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
200a9a4: 03 00 00 ef sethi %hi(0x3bc00), %g1
200a9a8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
200a9ac: 80 88 80 01 btst %g2, %g1
200a9b0: 02 80 00 0a be 200a9d8 <_Thread_queue_Requeue+0x64> <== NEVER TAKEN
200a9b4: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
200a9b8: 92 10 00 19 mov %i1, %o1
200a9bc: 94 10 20 01 mov 1, %o2
200a9c0: 40 00 0c c5 call 200dcd4 <_Thread_queue_Extract_priority_helper>
200a9c4: f8 26 20 30 st %i4, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
200a9c8: 90 10 00 18 mov %i0, %o0
200a9cc: 92 10 00 19 mov %i1, %o1
200a9d0: 7f ff ff 50 call 200a710 <_Thread_queue_Enqueue_priority>
200a9d4: 94 07 bf fc add %fp, -4, %o2
}
_ISR_Enable( level );
200a9d8: 7f ff df 09 call 20025fc <sparc_enable_interrupts>
200a9dc: 90 10 00 1d mov %i5, %o0
200a9e0: 81 c7 e0 08 ret
200a9e4: 81 e8 00 00 restore
0200a9e8 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200a9e8: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200a9ec: 90 10 00 18 mov %i0, %o0
200a9f0: 7f ff fd f1 call 200a1b4 <_Thread_Get>
200a9f4: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a9f8: c2 07 bf fc ld [ %fp + -4 ], %g1
200a9fc: 80 a0 60 00 cmp %g1, 0
200aa00: 12 80 00 09 bne 200aa24 <_Thread_queue_Timeout+0x3c> <== NEVER TAKEN
200aa04: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200aa08: 40 00 0c ea call 200ddb0 <_Thread_queue_Process_timeout>
200aa0c: 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--;
200aa10: 03 00 80 77 sethi %hi(0x201dc00), %g1
200aa14: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201dc10 <_Thread_Dispatch_disable_level>
200aa18: 84 00 bf ff add %g2, -1, %g2
200aa1c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
return _Thread_Dispatch_disable_level;
200aa20: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200aa24: 81 c7 e0 08 ret
200aa28: 81 e8 00 00 restore
020188e0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
20188e0: 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;
20188e4: 25 00 80 f3 sethi %hi(0x203cc00), %l2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
20188e8: a6 07 bf e8 add %fp, -24, %l3
20188ec: a2 07 bf ec add %fp, -20, %l1
20188f0: b8 07 bf f4 add %fp, -12, %i4
20188f4: b6 07 bf f8 add %fp, -8, %i3
20188f8: e2 27 bf e8 st %l1, [ %fp + -24 ]
head->previous = NULL;
20188fc: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
2018900: e6 27 bf f0 st %l3, [ %fp + -16 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2018904: f6 27 bf f4 st %i3, [ %fp + -12 ]
head->previous = NULL;
2018908: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
201890c: 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 );
2018910: b4 06 20 30 add %i0, 0x30, %i2
/*
* 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 );
2018914: ba 06 20 68 add %i0, 0x68, %i5
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
2018918: a0 06 20 08 add %i0, 8, %l0
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
201891c: b2 06 20 40 add %i0, 0x40, %i1
{
/*
* 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;
2018920: e6 26 20 78 st %l3, [ %i0 + 0x78 ]
2018924: 29 00 80 f3 sethi %hi(0x203cc00), %l4
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
2018928: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
201892c: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018930: 90 10 00 1a mov %i2, %o0
2018934: 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;
2018938: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
201893c: 40 00 11 d8 call 201d09c <_Watchdog_Adjust_to_chain>
2018940: 94 10 00 1c mov %i4, %o2
2018944: d0 1d 20 e0 ldd [ %l4 + 0xe0 ], %o0
2018948: 94 10 20 00 clr %o2
201894c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018950: 40 00 4f 7a call 202c738 <__divdi3>
2018954: 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;
2018958: 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 ) {
201895c: 80 a2 40 0a cmp %o1, %o2
2018960: 08 80 00 07 bleu 201897c <_Timer_server_Body+0x9c>
2018964: aa 10 00 09 mov %o1, %l5
/*
* 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 );
2018968: 92 22 40 0a sub %o1, %o2, %o1
201896c: 90 10 00 1d mov %i5, %o0
2018970: 40 00 11 cb call 201d09c <_Watchdog_Adjust_to_chain>
2018974: 94 10 00 1c mov %i4, %o2
2018978: 30 80 00 06 b,a 2018990 <_Timer_server_Body+0xb0>
} else if ( snapshot < last_snapshot ) {
201897c: 1a 80 00 05 bcc 2018990 <_Timer_server_Body+0xb0>
2018980: 90 10 00 1d mov %i5, %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 );
2018984: 92 10 20 01 mov 1, %o1
2018988: 40 00 11 9e call 201d000 <_Watchdog_Adjust>
201898c: 94 22 80 15 sub %o2, %l5, %o2
}
watchdogs->last_snapshot = snapshot;
2018990: ea 26 20 74 st %l5, [ %i0 + 0x74 ]
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
2018994: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
2018998: 40 00 02 db call 2019504 <_Chain_Get>
201899c: 01 00 00 00 nop
if ( timer == NULL ) {
20189a0: 92 92 20 00 orcc %o0, 0, %o1
20189a4: 02 80 00 0c be 20189d4 <_Timer_server_Body+0xf4>
20189a8: 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 ) {
20189ac: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
20189b0: 80 a0 60 01 cmp %g1, 1
20189b4: 02 80 00 05 be 20189c8 <_Timer_server_Body+0xe8>
20189b8: 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 ) {
20189bc: 80 a0 60 03 cmp %g1, 3
20189c0: 12 bf ff f5 bne 2018994 <_Timer_server_Body+0xb4> <== NEVER TAKEN
20189c4: 90 10 00 1d mov %i5, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
20189c8: 40 00 11 e7 call 201d164 <_Watchdog_Insert>
20189cc: 92 02 60 10 add %o1, 0x10, %o1
20189d0: 30 bf ff f1 b,a 2018994 <_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 );
20189d4: 7f ff de df call 2010550 <sparc_disable_interrupts>
20189d8: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
20189dc: c2 07 bf e8 ld [ %fp + -24 ], %g1
20189e0: 80 a0 40 11 cmp %g1, %l1
20189e4: 12 80 00 0a bne 2018a0c <_Timer_server_Body+0x12c> <== NEVER TAKEN
20189e8: 01 00 00 00 nop
ts->insert_chain = NULL;
20189ec: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
20189f0: 7f ff de dc call 2010560 <sparc_enable_interrupts>
20189f4: 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 ) ) {
20189f8: c2 07 bf f4 ld [ %fp + -12 ], %g1
20189fc: 80 a0 40 1b cmp %g1, %i3
2018a00: 12 80 00 06 bne 2018a18 <_Timer_server_Body+0x138>
2018a04: 01 00 00 00 nop
2018a08: 30 80 00 18 b,a 2018a68 <_Timer_server_Body+0x188>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
2018a0c: 7f ff de d5 call 2010560 <sparc_enable_interrupts> <== NOT EXECUTED
2018a10: 01 00 00 00 nop <== NOT EXECUTED
2018a14: 30 bf ff c5 b,a 2018928 <_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 );
2018a18: 7f ff de ce call 2010550 <sparc_disable_interrupts>
2018a1c: 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;
2018a20: e8 07 bf f4 ld [ %fp + -12 ], %l4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
2018a24: 80 a5 00 1b cmp %l4, %i3
2018a28: 02 80 00 0d be 2018a5c <_Timer_server_Body+0x17c>
2018a2c: 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;
2018a30: c2 05 00 00 ld [ %l4 ], %g1
head->next = new_first;
new_first->previous = head;
2018a34: 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;
2018a38: c2 27 bf f4 st %g1, [ %fp + -12 ]
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
2018a3c: c0 25 20 08 clr [ %l4 + 8 ]
_ISR_Enable( level );
2018a40: 7f ff de c8 call 2010560 <sparc_enable_interrupts>
2018a44: 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 );
2018a48: c2 05 20 1c ld [ %l4 + 0x1c ], %g1
2018a4c: d0 05 20 20 ld [ %l4 + 0x20 ], %o0
2018a50: 9f c0 40 00 call %g1
2018a54: d2 05 20 24 ld [ %l4 + 0x24 ], %o1
}
2018a58: 30 bf ff f0 b,a 2018a18 <_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 );
2018a5c: 7f ff de c1 call 2010560 <sparc_enable_interrupts>
2018a60: 01 00 00 00 nop
2018a64: 30 bf ff af b,a 2018920 <_Timer_server_Body+0x40>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
2018a68: c0 2e 20 7c clrb [ %i0 + 0x7c ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
2018a6c: 7f ff ff 6e call 2018824 <_Thread_Disable_dispatch>
2018a70: 01 00 00 00 nop
_Thread_Set_state( ts->thread, STATES_DELAYING );
2018a74: d0 06 00 00 ld [ %i0 ], %o0
2018a78: 40 00 10 40 call 201cb78 <_Thread_Set_state>
2018a7c: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
2018a80: 7f ff ff 70 call 2018840 <_Timer_server_Reset_interval_system_watchdog>
2018a84: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
2018a88: 7f ff ff 82 call 2018890 <_Timer_server_Reset_tod_system_watchdog>
2018a8c: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
2018a90: 40 00 0d e4 call 201c220 <_Thread_Enable_dispatch>
2018a94: 01 00 00 00 nop
ts->active = true;
2018a98: 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 );
2018a9c: 90 10 00 10 mov %l0, %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;
2018aa0: 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 );
2018aa4: 40 00 12 0a call 201d2cc <_Watchdog_Remove>
2018aa8: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
2018aac: 40 00 12 08 call 201d2cc <_Watchdog_Remove>
2018ab0: 90 10 00 19 mov %i1, %o0
2018ab4: 30 bf ff 9b b,a 2018920 <_Timer_server_Body+0x40>
02018ab8 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
2018ab8: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
2018abc: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2018ac0: 80 a0 60 00 cmp %g1, 0
2018ac4: 12 80 00 4e bne 2018bfc <_Timer_server_Schedule_operation_method+0x144>
2018ac8: ba 10 00 19 mov %i1, %i5
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
2018acc: 7f ff ff 56 call 2018824 <_Thread_Disable_dispatch>
2018ad0: 01 00 00 00 nop
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
2018ad4: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2018ad8: 80 a0 60 01 cmp %g1, 1
2018adc: 12 80 00 1f bne 2018b58 <_Timer_server_Schedule_operation_method+0xa0>
2018ae0: 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 );
2018ae4: 7f ff de 9b call 2010550 <sparc_disable_interrupts>
2018ae8: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
2018aec: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2018af0: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 203cd60 <_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;
2018af4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
2018af8: 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 );
2018afc: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
2018b00: 80 a0 40 03 cmp %g1, %g3
2018b04: 02 80 00 08 be 2018b24 <_Timer_server_Schedule_operation_method+0x6c>
2018b08: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
2018b0c: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
2018b10: 80 a7 00 04 cmp %i4, %g4
2018b14: 08 80 00 03 bleu 2018b20 <_Timer_server_Schedule_operation_method+0x68>
2018b18: 86 10 20 00 clr %g3
delta_interval -= delta;
2018b1c: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
2018b20: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
2018b24: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
2018b28: 7f ff de 8e call 2010560 <sparc_enable_interrupts>
2018b2c: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
2018b30: 90 06 20 30 add %i0, 0x30, %o0
2018b34: 40 00 11 8c call 201d164 <_Watchdog_Insert>
2018b38: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018b3c: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018b40: 80 a0 60 00 cmp %g1, 0
2018b44: 12 80 00 2c bne 2018bf4 <_Timer_server_Schedule_operation_method+0x13c>
2018b48: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
2018b4c: 7f ff ff 3d call 2018840 <_Timer_server_Reset_interval_system_watchdog>
2018b50: 90 10 00 18 mov %i0, %o0
2018b54: 30 80 00 28 b,a 2018bf4 <_Timer_server_Schedule_operation_method+0x13c>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2018b58: 12 80 00 27 bne 2018bf4 <_Timer_server_Schedule_operation_method+0x13c>
2018b5c: 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 );
2018b60: 7f ff de 7c call 2010550 <sparc_disable_interrupts>
2018b64: 01 00 00 00 nop
2018b68: b8 10 00 08 mov %o0, %i4
2018b6c: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2018b70: d0 18 60 e0 ldd [ %g1 + 0xe0 ], %o0 ! 203cce0 <_TOD_Now>
2018b74: 94 10 20 00 clr %o2
2018b78: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018b7c: 40 00 4e ef call 202c738 <__divdi3>
2018b80: 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;
2018b84: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
2018b88: c8 06 20 74 ld [ %i0 + 0x74 ], %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: 84 06 20 6c add %i0, 0x6c, %g2
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
2018b90: 80 a0 40 02 cmp %g1, %g2
2018b94: 02 80 00 0c be 2018bc4 <_Timer_server_Schedule_operation_method+0x10c>
2018b98: 80 a2 40 04 cmp %o1, %g4
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
2018b9c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
2018ba0: 84 00 c0 04 add %g3, %g4, %g2
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
2018ba4: 08 80 00 07 bleu 2018bc0 <_Timer_server_Schedule_operation_method+0x108>
2018ba8: 84 20 80 09 sub %g2, %o1, %g2
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
2018bac: 88 22 40 04 sub %o1, %g4, %g4
if (delta_interval > delta) {
2018bb0: 80 a0 c0 04 cmp %g3, %g4
2018bb4: 08 80 00 03 bleu 2018bc0 <_Timer_server_Schedule_operation_method+0x108><== NEVER TAKEN
2018bb8: 84 10 20 00 clr %g2
delta_interval -= delta;
2018bbc: 84 20 c0 04 sub %g3, %g4, %g2
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
2018bc0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
2018bc4: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
2018bc8: 7f ff de 66 call 2010560 <sparc_enable_interrupts>
2018bcc: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018bd0: 90 06 20 68 add %i0, 0x68, %o0
2018bd4: 40 00 11 64 call 201d164 <_Watchdog_Insert>
2018bd8: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018bdc: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018be0: 80 a0 60 00 cmp %g1, 0
2018be4: 12 80 00 04 bne 2018bf4 <_Timer_server_Schedule_operation_method+0x13c>
2018be8: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
2018bec: 7f ff ff 29 call 2018890 <_Timer_server_Reset_tod_system_watchdog>
2018bf0: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
2018bf4: 40 00 0d 8b call 201c220 <_Thread_Enable_dispatch>
2018bf8: 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 );
2018bfc: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
2018c00: 40 00 02 36 call 20194d8 <_Chain_Append>
2018c04: 81 e8 00 00 restore
0200c7a4 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
200c7a4: 82 10 00 08 mov %o0, %g1
uint32_t seconds = add->tv_sec;
200c7a8: d0 02 40 00 ld [ %o1 ], %o0
/* Add the basics */
time->tv_sec += add->tv_sec;
200c7ac: c4 00 40 00 ld [ %g1 ], %g2
time->tv_nsec += add->tv_nsec;
200c7b0: c6 00 60 04 ld [ %g1 + 4 ], %g3
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
200c7b4: 84 00 80 08 add %g2, %o0, %g2
200c7b8: c4 20 40 00 st %g2, [ %g1 ]
time->tv_nsec += add->tv_nsec;
200c7bc: c4 02 60 04 ld [ %o1 + 4 ], %g2
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
200c7c0: 09 0e e6 b2 sethi %hi(0x3b9ac800), %g4
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
200c7c4: 84 00 c0 02 add %g3, %g2, %g2
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
200c7c8: 88 11 21 ff or %g4, 0x1ff, %g4
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
200c7cc: 07 31 19 4d sethi %hi(0xc4653400), %g3
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
200c7d0: c4 20 60 04 st %g2, [ %g1 + 4 ]
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
200c7d4: 10 80 00 07 b 200c7f0 <_Timespec_Add_to+0x4c>
200c7d8: 86 10 e2 00 or %g3, 0x200, %g3
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
200c7dc: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
time->tv_sec++;
200c7e0: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
seconds++;
200c7e4: 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++;
200c7e8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
200c7ec: 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 ) {
200c7f0: c4 00 60 04 ld [ %g1 + 4 ], %g2
200c7f4: 80 a0 80 04 cmp %g2, %g4
200c7f8: 18 bf ff f9 bgu 200c7dc <_Timespec_Add_to+0x38> <== NEVER TAKEN
200c7fc: 84 00 80 03 add %g2, %g3, %g2
time->tv_sec++;
seconds++;
}
return seconds;
}
200c800: 81 c3 e0 08 retl
0200a544 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
200a544: 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;
200a548: d6 06 40 00 ld [ %i1 ], %o3
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
200a54c: a0 10 00 1a mov %i2, %l0
* 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;
200a550: 95 3a e0 1f sra %o3, 0x1f, %o2
200a554: b9 2a a0 03 sll %o2, 3, %i4
200a558: 87 2a e0 03 sll %o3, 3, %g3
200a55c: b5 32 e0 1d srl %o3, 0x1d, %i2
200a560: 9b 28 e0 05 sll %g3, 5, %o5
200a564: 84 16 80 1c or %i2, %i4, %g2
200a568: b9 30 e0 1b srl %g3, 0x1b, %i4
200a56c: 99 28 a0 05 sll %g2, 5, %o4
200a570: 86 a3 40 03 subcc %o5, %g3, %g3
200a574: 98 17 00 0c or %i4, %o4, %o4
200a578: 84 63 00 02 subx %o4, %g2, %g2
200a57c: b9 30 e0 1a srl %g3, 0x1a, %i4
200a580: 99 28 a0 06 sll %g2, 6, %o4
200a584: 9b 28 e0 06 sll %g3, 6, %o5
200a588: 98 17 00 0c or %i4, %o4, %o4
200a58c: 9a a3 40 03 subcc %o5, %g3, %o5
200a590: 98 63 00 02 subx %o4, %g2, %o4
200a594: 96 83 40 0b addcc %o5, %o3, %o3
200a598: 85 32 e0 1e srl %o3, 0x1e, %g2
200a59c: 94 43 00 0a addx %o4, %o2, %o2
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
200a5a0: a2 10 00 1b mov %i3, %l1
* 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;
200a5a4: b5 2a a0 02 sll %o2, 2, %i2
200a5a8: b7 2a e0 02 sll %o3, 2, %i3
200a5ac: b4 10 80 1a or %g2, %i2, %i2
200a5b0: 96 82 c0 1b addcc %o3, %i3, %o3
200a5b4: 94 42 80 1a addx %o2, %i2, %o2
200a5b8: 85 32 e0 1e srl %o3, 0x1e, %g2
200a5bc: b9 2a a0 02 sll %o2, 2, %i4
200a5c0: bb 2a e0 02 sll %o3, 2, %i5
200a5c4: b8 10 80 1c or %g2, %i4, %i4
200a5c8: 96 82 c0 1d addcc %o3, %i5, %o3
200a5cc: 94 42 80 1c addx %o2, %i4, %o2
200a5d0: 85 32 e0 1e srl %o3, 0x1e, %g2
200a5d4: b9 2a a0 02 sll %o2, 2, %i4
200a5d8: bb 2a e0 02 sll %o3, 2, %i5
200a5dc: b8 10 80 1c or %g2, %i4, %i4
200a5e0: 96 82 c0 1d addcc %o3, %i5, %o3
200a5e4: 94 42 80 1c addx %o2, %i4, %o2
200a5e8: 87 2a a0 09 sll %o2, 9, %g3
200a5ec: b9 32 e0 17 srl %o3, 0x17, %i4
200a5f0: 94 17 00 03 or %i4, %g3, %o2
right += rhs->tv_nsec;
200a5f4: c6 06 60 04 ld [ %i1 + 4 ], %g3
* 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;
200a5f8: 85 2a e0 09 sll %o3, 9, %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;
200a5fc: c2 06 00 00 ld [ %i0 ], %g1
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a600: 96 10 00 02 mov %g2, %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;
200a604: c8 06 20 04 ld [ %i0 + 4 ], %g4
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
200a608: b2 82 c0 03 addcc %o3, %g3, %i1
200a60c: 85 38 e0 1f sra %g3, 0x1f, %g2
200a610: b0 42 80 02 addx %o2, %g2, %i0
if ( right == 0 ) {
200a614: 80 96 00 19 orcc %i0, %i1, %g0
200a618: 32 80 00 06 bne,a 200a630 <_Timespec_Divide+0xec> <== NEVER TAKEN
200a61c: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED
*ival_percentage = 0;
200a620: c0 24 00 00 clr [ %l0 ]
*fval_percentage = 0;
200a624: c0 24 40 00 clr [ %l1 ]
return;
200a628: 81 c7 e0 08 ret
200a62c: 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;
200a630: 95 38 60 1f sra %g1, 0x1f, %o2 <== NOT EXECUTED
200a634: b9 30 60 1d srl %g1, 0x1d, %i4 <== NOT EXECUTED
200a638: 83 2a a0 03 sll %o2, 3, %g1 <== NOT EXECUTED
200a63c: 87 2a e0 03 sll %o3, 3, %g3 <== NOT EXECUTED
200a640: 84 17 00 01 or %i4, %g1, %g2 <== NOT EXECUTED
200a644: 83 30 e0 1b srl %g3, 0x1b, %g1 <== NOT EXECUTED
200a648: 99 28 a0 05 sll %g2, 5, %o4 <== NOT EXECUTED
200a64c: 9b 28 e0 05 sll %g3, 5, %o5 <== NOT EXECUTED
200a650: 98 10 40 0c or %g1, %o4, %o4 <== NOT EXECUTED
200a654: 9a a3 40 03 subcc %o5, %g3, %o5 <== NOT EXECUTED
200a658: 83 33 60 1a srl %o5, 0x1a, %g1 <== NOT EXECUTED
200a65c: 98 63 00 02 subx %o4, %g2, %o4 <== NOT EXECUTED
200a660: 87 2b 60 06 sll %o5, 6, %g3 <== NOT EXECUTED
200a664: 85 2b 20 06 sll %o4, 6, %g2 <== NOT EXECUTED
200a668: 92 a0 c0 0d subcc %g3, %o5, %o1 <== NOT EXECUTED
200a66c: 84 10 40 02 or %g1, %g2, %g2 <== NOT EXECUTED
200a670: 90 60 80 0c subx %g2, %o4, %o0 <== NOT EXECUTED
200a674: 92 82 40 0b addcc %o1, %o3, %o1 <== NOT EXECUTED
200a678: 83 32 60 1e srl %o1, 0x1e, %g1 <== NOT EXECUTED
200a67c: 90 42 00 0a addx %o0, %o2, %o0 <== NOT EXECUTED
200a680: b7 2a 60 02 sll %o1, 2, %i3 <== NOT EXECUTED
200a684: b5 2a 20 02 sll %o0, 2, %i2 <== NOT EXECUTED
200a688: 92 82 40 1b addcc %o1, %i3, %o1 <== NOT EXECUTED
200a68c: b4 10 40 1a or %g1, %i2, %i2 <== NOT EXECUTED
200a690: 83 32 60 1e srl %o1, 0x1e, %g1 <== NOT EXECUTED
200a694: 90 42 00 1a addx %o0, %i2, %o0 <== NOT EXECUTED
200a698: bb 2a 60 02 sll %o1, 2, %i5 <== NOT EXECUTED
200a69c: b9 2a 20 02 sll %o0, 2, %i4 <== NOT EXECUTED
200a6a0: 92 82 40 1d addcc %o1, %i5, %o1 <== NOT EXECUTED
200a6a4: b8 10 40 1c or %g1, %i4, %i4 <== NOT EXECUTED
200a6a8: 83 32 60 1e srl %o1, 0x1e, %g1 <== NOT EXECUTED
200a6ac: 90 42 00 1c addx %o0, %i4, %o0 <== NOT EXECUTED
200a6b0: bb 2a 60 02 sll %o1, 2, %i5 <== NOT EXECUTED
200a6b4: b9 2a 20 02 sll %o0, 2, %i4 <== NOT EXECUTED
200a6b8: 92 82 40 1d addcc %o1, %i5, %o1 <== NOT EXECUTED
200a6bc: b8 10 40 1c or %g1, %i4, %i4 <== NOT EXECUTED
200a6c0: 83 2a 60 09 sll %o1, 9, %g1 <== NOT EXECUTED
200a6c4: 90 42 00 1c addx %o0, %i4, %o0 <== NOT EXECUTED
left += lhs->tv_nsec;
200a6c8: 95 39 20 1f sra %g4, 0x1f, %o2 <== NOT EXECUTED
200a6cc: 96 80 40 04 addcc %g1, %g4, %o3 <== 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;
200a6d0: 87 32 60 17 srl %o1, 0x17, %g3 <== NOT EXECUTED
200a6d4: 85 2a 20 09 sll %o0, 9, %g2 <== NOT EXECUTED
200a6d8: 90 10 c0 02 or %g3, %g2, %o0 <== NOT EXECUTED
left += lhs->tv_nsec;
200a6dc: 94 42 00 0a addx %o0, %o2, %o2 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
200a6e0: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
200a6e4: 9b 2a e0 02 sll %o3, 2, %o5 <== NOT EXECUTED
200a6e8: 85 32 e0 1e srl %o3, 0x1e, %g2 <== NOT EXECUTED
200a6ec: 98 10 80 01 or %g2, %g1, %o4 <== NOT EXECUTED
200a6f0: 83 33 60 1b srl %o5, 0x1b, %g1 <== NOT EXECUTED
200a6f4: 85 2b 20 05 sll %o4, 5, %g2 <== NOT EXECUTED
200a6f8: 87 2b 60 05 sll %o5, 5, %g3 <== NOT EXECUTED
200a6fc: 84 10 40 02 or %g1, %g2, %g2 <== NOT EXECUTED
200a700: 86 a0 c0 0d subcc %g3, %o5, %g3 <== NOT EXECUTED
200a704: 84 60 80 0c subx %g2, %o4, %g2 <== NOT EXECUTED
200a708: 96 80 c0 0b addcc %g3, %o3, %o3 <== NOT EXECUTED
200a70c: 83 32 e0 1e srl %o3, 0x1e, %g1 <== NOT EXECUTED
200a710: 94 40 80 0a addx %g2, %o2, %o2 <== NOT EXECUTED
200a714: bb 2a e0 02 sll %o3, 2, %i5 <== NOT EXECUTED
200a718: b9 2a a0 02 sll %o2, 2, %i4 <== NOT EXECUTED
200a71c: ba 82 c0 1d addcc %o3, %i5, %i5 <== NOT EXECUTED
200a720: b8 10 40 1c or %g1, %i4, %i4 <== NOT EXECUTED
200a724: 83 37 60 1e srl %i5, 0x1e, %g1 <== NOT EXECUTED
200a728: b8 42 80 1c addx %o2, %i4, %i4 <== NOT EXECUTED
200a72c: 93 2f 60 02 sll %i5, 2, %o1 <== NOT EXECUTED
200a730: 91 2f 20 02 sll %i4, 2, %o0 <== NOT EXECUTED
200a734: 92 87 40 09 addcc %i5, %o1, %o1 <== NOT EXECUTED
200a738: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED
200a73c: 87 32 60 1b srl %o1, 0x1b, %g3 <== NOT EXECUTED
200a740: 90 47 00 08 addx %i4, %o0, %o0 <== NOT EXECUTED
200a744: 83 2a 60 05 sll %o1, 5, %g1 <== NOT EXECUTED
200a748: 85 2a 20 05 sll %o0, 5, %g2 <== NOT EXECUTED
200a74c: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
200a750: 90 10 c0 02 or %g3, %g2, %o0 <== NOT EXECUTED
200a754: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
200a758: 40 00 3a 49 call 201907c <__udivdi3> <== NOT EXECUTED
200a75c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
*ival_percentage = answer / 1000;
200a760: 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;
200a764: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
200a768: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
*ival_percentage = answer / 1000;
200a76c: 40 00 3a 44 call 201907c <__udivdi3> <== NOT EXECUTED
200a770: 96 10 23 e8 mov 0x3e8, %o3 <== NOT EXECUTED
*fval_percentage = answer % 1000;
200a774: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
200a778: d2 24 00 00 st %o1, [ %l0 ] <== NOT EXECUTED
*fval_percentage = answer % 1000;
200a77c: 94 10 20 00 clr %o2 <== NOT EXECUTED
200a780: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
200a784: 40 00 3b 13 call 20193d0 <__umoddi3> <== NOT EXECUTED
200a788: 96 10 23 e8 mov 0x3e8, %o3 <== NOT EXECUTED
200a78c: d2 24 40 00 st %o1, [ %l1 ] <== NOT EXECUTED
200a790: 81 c7 e0 08 ret <== NOT EXECUTED
200a794: 81 e8 00 00 restore <== NOT EXECUTED
0200c540 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
200c540: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
200c544: d4 1e 40 00 ldd [ %i1 ], %o2
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
200c548: a2 10 00 1a mov %i2, %l1
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
200c54c: 80 92 80 0b orcc %o2, %o3, %g0
200c550: 12 80 00 06 bne 200c568 <_Timestamp64_Divide+0x28> <== ALWAYS TAKEN
200c554: a0 10 00 1b mov %i3, %l0
*_ival_percentage = 0;
200c558: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*_fval_percentage = 0;
200c55c: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
200c560: 81 c7 e0 08 ret <== NOT EXECUTED
200c564: 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;
200c568: d0 1e 00 00 ldd [ %i0 ], %o0
200c56c: 83 2a 20 02 sll %o0, 2, %g1
200c570: 89 32 60 1e srl %o1, 0x1e, %g4
200c574: 87 2a 60 02 sll %o1, 2, %g3
200c578: 84 11 00 01 or %g4, %g1, %g2
200c57c: 83 30 e0 1b srl %g3, 0x1b, %g1
200c580: 9b 28 e0 05 sll %g3, 5, %o5
200c584: 99 28 a0 05 sll %g2, 5, %o4
200c588: 86 a3 40 03 subcc %o5, %g3, %g3
200c58c: 98 10 40 0c or %g1, %o4, %o4
200c590: 84 63 00 02 subx %o4, %g2, %g2
200c594: 92 80 c0 09 addcc %g3, %o1, %o1
200c598: 83 32 60 1e srl %o1, 0x1e, %g1
200c59c: 90 40 80 08 addx %g2, %o0, %o0
200c5a0: b7 2a 60 02 sll %o1, 2, %i3
200c5a4: b5 2a 20 02 sll %o0, 2, %i2
200c5a8: b6 82 40 1b addcc %o1, %i3, %i3
200c5ac: b4 10 40 1a or %g1, %i2, %i2
200c5b0: 83 36 e0 1e srl %i3, 0x1e, %g1
200c5b4: b4 42 00 1a addx %o0, %i2, %i2
200c5b8: bb 2e e0 02 sll %i3, 2, %i5
200c5bc: b9 2e a0 02 sll %i2, 2, %i4
200c5c0: 92 86 c0 1d addcc %i3, %i5, %o1
200c5c4: b8 10 40 1c or %g1, %i4, %i4
200c5c8: 87 32 60 1b srl %o1, 0x1b, %g3
200c5cc: 90 46 80 1c addx %i2, %i4, %o0
200c5d0: 83 2a 60 05 sll %o1, 5, %g1
200c5d4: 85 2a 20 05 sll %o0, 5, %g2
200c5d8: 92 10 00 01 mov %g1, %o1
200c5dc: 40 00 3a 0d call 201ae10 <__divdi3>
200c5e0: 90 10 c0 02 or %g3, %g2, %o0
*_ival_percentage = answer / 1000;
200c5e4: 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;
200c5e8: b4 10 00 08 mov %o0, %i2
200c5ec: b8 10 00 09 mov %o1, %i4
*_ival_percentage = answer / 1000;
200c5f0: 40 00 3a 08 call 201ae10 <__divdi3>
200c5f4: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
200c5f8: 90 10 00 1a mov %i2, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
200c5fc: d2 24 40 00 st %o1, [ %l1 ]
*_fval_percentage = answer % 1000;
200c600: 94 10 20 00 clr %o2
200c604: 92 10 00 1c mov %i4, %o1
200c608: 40 00 3a e8 call 201b1a8 <__moddi3>
200c60c: 96 10 23 e8 mov 0x3e8, %o3
200c610: d2 24 00 00 st %o1, [ %l0 ]
200c614: 81 c7 e0 08 ret
200c618: 81 e8 00 00 restore
0200abd8 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
200abd8: 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;
200abdc: 03 00 80 73 sethi %hi(0x201cc00), %g1
200abe0: 82 10 62 2c or %g1, 0x22c, %g1 ! 201ce2c <Configuration>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200abe4: 05 00 80 77 sethi %hi(0x201dc00), %g2
initial_extensions = Configuration.User_extension_table;
200abe8: f4 00 60 44 ld [ %g1 + 0x44 ], %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;
200abec: f6 00 60 40 ld [ %g1 + 0x40 ], %i3
200abf0: 82 10 a1 f8 or %g2, 0x1f8, %g1
200abf4: 86 00 60 04 add %g1, 4, %g3
head->previous = NULL;
200abf8: c0 20 60 04 clr [ %g1 + 4 ]
tail->previous = head;
200abfc: 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;
200ac00: c6 20 a1 f8 st %g3, [ %g2 + 0x1f8 ]
200ac04: 05 00 80 77 sethi %hi(0x201dc00), %g2
200ac08: 82 10 a0 14 or %g2, 0x14, %g1 ! 201dc14 <_User_extensions_Switches_list>
200ac0c: 86 00 60 04 add %g1, 4, %g3
head->previous = NULL;
200ac10: c0 20 60 04 clr [ %g1 + 4 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ac14: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
initial_extensions = Configuration.User_extension_table;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
200ac18: 80 a6 a0 00 cmp %i2, 0
200ac1c: 02 80 00 1b be 200ac88 <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN
200ac20: c2 20 60 08 st %g1, [ %g1 + 8 ]
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
200ac24: 83 2e e0 02 sll %i3, 2, %g1
200ac28: bb 2e e0 04 sll %i3, 4, %i5
200ac2c: ba 27 40 01 sub %i5, %g1, %i5
200ac30: ba 07 40 1b add %i5, %i3, %i5
200ac34: bb 2f 60 02 sll %i5, 2, %i5
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
200ac38: 40 00 01 6c call 200b1e8 <_Workspace_Allocate_or_fatal_error>
200ac3c: 90 10 00 1d mov %i5, %o0
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
200ac40: 94 10 00 1d mov %i5, %o2
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
200ac44: b8 10 00 08 mov %o0, %i4
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
200ac48: 92 10 20 00 clr %o1
200ac4c: 40 00 15 a2 call 20102d4 <memset>
200ac50: ba 10 20 00 clr %i5
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
200ac54: 10 80 00 0b b 200ac80 <_User_extensions_Handler_initialization+0xa8>
200ac58: 80 a7 40 1b cmp %i5, %i3
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
200ac5c: 90 07 20 14 add %i4, 0x14, %o0
200ac60: 92 06 80 09 add %i2, %o1, %o1
200ac64: 40 00 15 60 call 20101e4 <memcpy>
200ac68: 94 10 20 20 mov 0x20, %o2
_User_extensions_Add_set( extension );
200ac6c: 90 10 00 1c mov %i4, %o0
200ac70: 40 00 0c 95 call 200dec4 <_User_extensions_Add_set>
200ac74: ba 07 60 01 inc %i5
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
200ac78: b8 07 20 34 add %i4, 0x34, %i4
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
200ac7c: 80 a7 40 1b cmp %i5, %i3
200ac80: 12 bf ff f7 bne 200ac5c <_User_extensions_Handler_initialization+0x84>
200ac84: 93 2f 60 05 sll %i5, 5, %o1
200ac88: 81 c7 e0 08 ret
200ac8c: 81 e8 00 00 restore
0200c90c <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
200c90c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
200c910: 7f ff da d6 call 2003468 <sparc_disable_interrupts>
200c914: ba 10 00 18 mov %i0, %i5
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200c918: 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 );
200c91c: 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 ) ) {
200c920: 80 a0 40 1c cmp %g1, %i4
200c924: 02 80 00 1f be 200c9a0 <_Watchdog_Adjust+0x94>
200c928: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
200c92c: 02 80 00 1a be 200c994 <_Watchdog_Adjust+0x88>
200c930: b6 10 20 01 mov 1, %i3
200c934: 80 a6 60 01 cmp %i1, 1
200c938: 12 80 00 1a bne 200c9a0 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
200c93c: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
200c940: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c944: 10 80 00 07 b 200c960 <_Watchdog_Adjust+0x54>
200c948: b4 00 80 1a add %g2, %i2, %i2
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
200c94c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c950: 80 a6 80 02 cmp %i2, %g2
200c954: 3a 80 00 05 bcc,a 200c968 <_Watchdog_Adjust+0x5c>
200c958: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
200c95c: b4 20 80 1a sub %g2, %i2, %i2
break;
200c960: 10 80 00 10 b 200c9a0 <_Watchdog_Adjust+0x94>
200c964: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
} else {
units -= _Watchdog_First( header )->delta_interval;
200c968: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
200c96c: 7f ff da c3 call 2003478 <sparc_enable_interrupts>
200c970: 01 00 00 00 nop
_Watchdog_Tickle( header );
200c974: 40 00 00 90 call 200cbb4 <_Watchdog_Tickle>
200c978: 90 10 00 1d mov %i5, %o0
_ISR_Disable( level );
200c97c: 7f ff da bb call 2003468 <sparc_disable_interrupts>
200c980: 01 00 00 00 nop
if ( _Chain_Is_empty( header ) )
200c984: c2 07 40 00 ld [ %i5 ], %g1
200c988: 80 a0 40 1c cmp %g1, %i4
200c98c: 02 80 00 05 be 200c9a0 <_Watchdog_Adjust+0x94>
200c990: 01 00 00 00 nop
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200c994: 80 a6 a0 00 cmp %i2, 0
200c998: 32 bf ff ed bne,a 200c94c <_Watchdog_Adjust+0x40> <== ALWAYS TAKEN
200c99c: c2 07 40 00 ld [ %i5 ], %g1
}
break;
}
}
_ISR_Enable( level );
200c9a0: 7f ff da b6 call 2003478 <sparc_enable_interrupts>
200c9a4: 91 e8 00 08 restore %g0, %o0, %o0
0200aff0 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
200aff0: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
200aff4: 7f ff dd 7e call 20025ec <sparc_disable_interrupts>
200aff8: ba 10 00 18 mov %i0, %i5
previous_state = the_watchdog->state;
200affc: f0 06 20 08 ld [ %i0 + 8 ], %i0
switch ( previous_state ) {
200b000: 80 a6 20 01 cmp %i0, 1
200b004: 22 80 00 1d be,a 200b078 <_Watchdog_Remove+0x88>
200b008: c0 27 60 08 clr [ %i5 + 8 ]
200b00c: 0a 80 00 1c bcs 200b07c <_Watchdog_Remove+0x8c>
200b010: 03 00 80 77 sethi %hi(0x201dc00), %g1
200b014: 80 a6 20 03 cmp %i0, 3
200b018: 18 80 00 19 bgu 200b07c <_Watchdog_Remove+0x8c> <== NEVER TAKEN
200b01c: 01 00 00 00 nop
200b020: c2 07 40 00 ld [ %i5 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
200b024: c0 27 60 08 clr [ %i5 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
200b028: c4 00 40 00 ld [ %g1 ], %g2
200b02c: 80 a0 a0 00 cmp %g2, 0
200b030: 02 80 00 07 be 200b04c <_Watchdog_Remove+0x5c>
200b034: 05 00 80 77 sethi %hi(0x201dc00), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
200b038: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200b03c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200b040: 84 00 c0 02 add %g3, %g2, %g2
200b044: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
200b048: 05 00 80 77 sethi %hi(0x201dc00), %g2
200b04c: c4 00 a1 1c ld [ %g2 + 0x11c ], %g2 ! 201dd1c <_Watchdog_Sync_count>
200b050: 80 a0 a0 00 cmp %g2, 0
200b054: 22 80 00 07 be,a 200b070 <_Watchdog_Remove+0x80>
200b058: c4 07 60 04 ld [ %i5 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
200b05c: 05 00 80 78 sethi %hi(0x201e000), %g2
200b060: c6 00 a1 58 ld [ %g2 + 0x158 ], %g3 ! 201e158 <_Per_CPU_Information+0x8>
200b064: 05 00 80 77 sethi %hi(0x201dc00), %g2
200b068: c6 20 a0 bc st %g3, [ %g2 + 0xbc ] ! 201dcbc <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200b06c: c4 07 60 04 ld [ %i5 + 4 ], %g2
next->previous = previous;
200b070: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
200b074: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200b078: 03 00 80 77 sethi %hi(0x201dc00), %g1
200b07c: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 201dd20 <_Watchdog_Ticks_since_boot>
200b080: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_ISR_Enable( level );
200b084: 7f ff dd 5e call 20025fc <sparc_enable_interrupts>
200b088: 01 00 00 00 nop
return( previous_state );
}
200b08c: 81 c7 e0 08 ret
200b090: 81 e8 00 00 restore
0200c248 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
200c248: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
200c24c: 7f ff db 57 call 2002fa8 <sparc_disable_interrupts>
200c250: ba 10 00 18 mov %i0, %i5
200c254: b0 10 00 08 mov %o0, %i0
printk( "Watchdog Chain: %s %p\n", name, header );
200c258: 11 00 80 76 sethi %hi(0x201d800), %o0
200c25c: 94 10 00 19 mov %i1, %o2
200c260: 90 12 21 80 or %o0, 0x180, %o0
200c264: 7f ff e3 3e call 2004f5c <printk>
200c268: 92 10 00 1d mov %i5, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200c26c: f8 06 40 00 ld [ %i1 ], %i4
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200c270: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
200c274: 80 a7 00 19 cmp %i4, %i1
200c278: 12 80 00 04 bne 200c288 <_Watchdog_Report_chain+0x40>
200c27c: 92 10 00 1c mov %i4, %o1
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
200c280: 10 80 00 0d b 200c2b4 <_Watchdog_Report_chain+0x6c>
200c284: 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 );
200c288: 40 00 00 0f call 200c2c4 <_Watchdog_Report>
200c28c: 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 )
200c290: f8 07 00 00 ld [ %i4 ], %i4
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
200c294: 80 a7 00 19 cmp %i4, %i1
200c298: 12 bf ff fc bne 200c288 <_Watchdog_Report_chain+0x40> <== NEVER TAKEN
200c29c: 92 10 00 1c mov %i4, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
200c2a0: 11 00 80 76 sethi %hi(0x201d800), %o0
200c2a4: 92 10 00 1d mov %i5, %o1
200c2a8: 7f ff e3 2d call 2004f5c <printk>
200c2ac: 90 12 21 98 or %o0, 0x198, %o0
200c2b0: 30 80 00 03 b,a 200c2bc <_Watchdog_Report_chain+0x74>
} else {
printk( "Chain is empty\n" );
200c2b4: 7f ff e3 2a call 2004f5c <printk>
200c2b8: 90 12 21 a8 or %o0, 0x1a8, %o0
}
_ISR_Enable( level );
200c2bc: 7f ff db 3f call 2002fb8 <sparc_enable_interrupts>
200c2c0: 81 e8 00 00 restore
02025e28 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
2025e28: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
2025e2c: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
2025e30: c0 27 bf fc clr [ %fp + -4 ]
uint32_t c = 0;
while (count > 0)
2025e34: 10 80 00 18 b 2025e94 <_fat_block_read+0x6c>
2025e38: b0 10 20 00 clr %i0
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
2025e3c: 92 10 00 19 mov %i1, %o1
2025e40: 94 10 20 01 mov 1, %o2
2025e44: 7f ff ff 22 call 2025acc <fat_buf_access>
2025e48: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2025e4c: 80 a2 20 00 cmp %o0, 0
2025e50: 12 80 00 16 bne 2025ea8 <_fat_block_read+0x80> <== NEVER TAKEN
2025e54: 01 00 00 00 nop
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
2025e58: e0 17 40 00 lduh [ %i5 ], %l0
2025e5c: a0 24 00 1a sub %l0, %i2, %l0
2025e60: 80 a4 00 1b cmp %l0, %i3
2025e64: 38 80 00 02 bgu,a 2025e6c <_fat_block_read+0x44>
2025e68: a0 10 00 1b mov %i3, %l0
memcpy((buff + cmpltd), (block->buffer + ofs), c);
2025e6c: c2 07 bf fc ld [ %fp + -4 ], %g1
2025e70: 90 07 00 18 add %i4, %i0, %o0
2025e74: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2025e78: 94 10 00 10 mov %l0, %o2
2025e7c: 92 02 40 1a add %o1, %i2, %o1
2025e80: 40 00 7c c9 call 20451a4 <memcpy>
2025e84: b6 26 c0 10 sub %i3, %l0, %i3
count -= c;
cmpltd += c;
2025e88: b0 04 00 18 add %l0, %i0, %i0
blk++;
2025e8c: b2 06 60 01 inc %i1
ofs = 0;
2025e90: 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)
2025e94: 80 a6 e0 00 cmp %i3, 0
2025e98: 12 bf ff e9 bne 2025e3c <_fat_block_read+0x14>
2025e9c: 90 10 00 1d mov %i5, %o0
2025ea0: 81 c7 e0 08 ret
2025ea4: 81 e8 00 00 restore
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
2025ea8: 81 c7 e0 08 ret <== NOT EXECUTED
2025eac: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02025f48 <_fat_block_release>:
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
2025f48: d0 02 20 20 ld [ %o0 + 0x20 ], %o0 <== NOT EXECUTED
2025f4c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2025f50: 7f ff ff 5d call 2025cc4 <fat_buf_release> <== NOT EXECUTED
2025f54: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02025eb0 <_fat_block_write>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
2025eb0: 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;
2025eb4: a2 10 20 01 mov 1, %l1
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
2025eb8: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
2025ebc: c0 27 bf fc clr [ %fp + -4 ]
uint32_t c = 0;
while(count > 0)
2025ec0: 10 80 00 1b b 2025f2c <_fat_block_write+0x7c>
2025ec4: b0 10 20 00 clr %i0
{
c = MIN(count, (fs_info->vol.bps - ofs));
2025ec8: a0 20 40 1a sub %g1, %i2, %l0
2025ecc: 80 a4 00 1b cmp %l0, %i3
2025ed0: 38 80 00 02 bgu,a 2025ed8 <_fat_block_write+0x28>
2025ed4: a0 10 00 1b mov %i3, %l0
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
2025ed8: 90 10 00 1d mov %i5, %o0
2025edc: 92 10 00 19 mov %i1, %o1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
2025ee0: 80 a4 00 01 cmp %l0, %g1
2025ee4: 02 80 00 03 be 2025ef0 <_fat_block_write+0x40>
2025ee8: 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);
2025eec: 94 10 20 01 mov 1, %o2
2025ef0: 7f ff fe f7 call 2025acc <fat_buf_access>
2025ef4: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2025ef8: 80 a2 20 00 cmp %o0, 0
2025efc: 12 80 00 11 bne 2025f40 <_fat_block_write+0x90> <== NEVER TAKEN
2025f00: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
2025f04: 92 07 00 18 add %i4, %i0, %o1
2025f08: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2025f0c: 94 10 00 10 mov %l0, %o2
2025f10: 90 02 00 1a add %o0, %i2, %o0
2025f14: 40 00 7c a4 call 20451a4 <memcpy>
2025f18: b6 26 c0 10 sub %i3, %l0, %i3
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
2025f1c: b0 04 00 18 add %l0, %i0, %i0
2025f20: e2 2f 60 7c stb %l1, [ %i5 + 0x7c ]
blk++;
2025f24: b2 06 60 01 inc %i1
ofs = 0;
2025f28: 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)
2025f2c: 80 a6 e0 00 cmp %i3, 0
2025f30: 32 bf ff e6 bne,a 2025ec8 <_fat_block_write+0x18>
2025f34: c2 17 40 00 lduh [ %i5 ], %g1
2025f38: 81 c7 e0 08 ret
2025f3c: 81 e8 00 00 restore
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
2025f40: 81 c7 e0 08 ret <== NOT EXECUTED
2025f44: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02024df0 <_hash_search>:
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
2024df0: 9d e3 bf a0 save %sp, -96, %sp
uint32_t mod = (key1) % FAT_HASH_MODULE;
2024df4: 84 0e a0 01 and %i2, 1, %g2
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
2024df8: 87 28 a0 02 sll %g2, 2, %g3
2024dfc: 83 28 a0 04 sll %g2, 4, %g1
2024e00: 82 20 40 03 sub %g1, %g3, %g1
2024e04: 84 06 40 01 add %i1, %g1, %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2024e08: fa 06 40 01 ld [ %i1 + %g1 ], %i5
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
2024e0c: 10 80 00 11 b 2024e50 <_hash_search+0x60>
2024e10: b2 00 a0 04 add %g2, 4, %i1
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
2024e14: 7f ff ff e5 call 2024da8 <fat_construct_key>
2024e18: 92 07 60 20 add %i5, 0x20, %o1
if ( (key1) == ck)
2024e1c: 80 a6 80 08 cmp %i2, %o0
2024e20: 32 80 00 0c bne,a 2024e50 <_hash_search+0x60>
2024e24: fa 07 40 00 ld [ %i5 ], %i5
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
2024e28: 80 a6 e0 00 cmp %i3, 0
2024e2c: 22 80 00 07 be,a 2024e48 <_hash_search+0x58> <== ALWAYS TAKEN
2024e30: fa 27 00 00 st %i5, [ %i4 ]
2024e34: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2024e38: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2024e3c: 32 80 00 05 bne,a 2024e50 <_hash_search+0x60> <== NOT EXECUTED
2024e40: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
{
*ret = (void *)the_node;
2024e44: fa 27 00 00 st %i5, [ %i4 ] <== NOT EXECUTED
return 0;
2024e48: 81 c7 e0 08 ret
2024e4c: 91 e8 20 00 restore %g0, 0, %o0
)
{
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) ; )
2024e50: 80 a7 40 19 cmp %i5, %i1
2024e54: 12 bf ff f0 bne 2024e14 <_hash_search+0x24>
2024e58: 90 10 00 18 mov %i0, %o0
}
}
the_node = the_node->next;
}
return -1;
}
2024e5c: 81 c7 e0 08 ret
2024e60: 91 e8 3f ff restore %g0, -1, %o0
020286f0 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
20286f0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
20286f4: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
20286f8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
20286fc: 7f ff ff e9 call 20286a0 <lstat> <== NOT EXECUTED
2028700: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004754 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2004754: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2004758: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
200475c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004760: 7f ff ff e9 call 2004704 <stat> <== NOT EXECUTED
2004764: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02007978 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
2007978: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
200797c: 3b 00 80 80 sethi %hi(0x2020000), %i5
2007980: 40 00 04 66 call 2008b18 <pthread_mutex_lock>
2007984: 90 17 60 24 or %i5, 0x24, %o0 ! 2020024 <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
2007988: 90 10 00 18 mov %i0, %o0
200798c: 40 00 1a ab call 200e438 <fcntl>
2007990: 92 10 20 01 mov 1, %o1
2007994: 80 a2 20 00 cmp %o0, 0
2007998: 16 80 00 08 bge 20079b8 <aio_cancel+0x40>
200799c: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
20079a0: 40 00 04 7e call 2008b98 <pthread_mutex_unlock>
20079a4: 90 17 60 24 or %i5, 0x24, %o0
rtems_set_errno_and_return_minus_one (EBADF);
20079a8: 40 00 28 7e call 2011ba0 <__errno>
20079ac: 01 00 00 00 nop
20079b0: 10 80 00 4e b 2007ae8 <aio_cancel+0x170>
20079b4: 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) {
20079b8: 32 80 00 2f bne,a 2007a74 <aio_cancel+0xfc>
20079bc: 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);
20079c0: 11 00 80 80 sethi %hi(0x2020000), %o0
20079c4: 92 10 00 18 mov %i0, %o1
20079c8: 90 12 20 6c or %o0, 0x6c, %o0
20079cc: 40 00 01 6f call 2007f88 <rtems_aio_search_fd>
20079d0: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20079d4: b8 92 20 00 orcc %o0, 0, %i4
20079d8: 32 80 00 1a bne,a 2007a40 <aio_cancel+0xc8>
20079dc: b2 07 20 1c add %i4, 0x1c, %i1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
20079e0: ba 17 60 24 or %i5, 0x24, %i5
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
20079e4: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
20079e8: 82 07 60 58 add %i5, 0x58, %g1
20079ec: 80 a0 80 01 cmp %g2, %g1
20079f0: 02 80 00 48 be 2007b10 <aio_cancel+0x198> <== NEVER TAKEN
20079f4: 90 07 60 54 add %i5, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
20079f8: 92 10 00 18 mov %i0, %o1
20079fc: 40 00 01 63 call 2007f88 <rtems_aio_search_fd>
2007a00: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007a04: b8 92 20 00 orcc %o0, 0, %i4
2007a08: 22 80 00 43 be,a 2007b14 <aio_cancel+0x19c>
2007a0c: 90 10 00 1d mov %i5, %o0
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2007a10: 40 00 0a ca call 200a538 <_Chain_Extract>
2007a14: b2 07 20 1c add %i4, 0x1c, %i1
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007a18: 40 00 01 87 call 2008034 <rtems_aio_remove_fd>
2007a1c: 90 10 00 1c mov %i4, %o0
pthread_mutex_destroy (&r_chain->mutex);
2007a20: 40 00 03 99 call 2008884 <pthread_mutex_destroy>
2007a24: 90 10 00 19 mov %i1, %o0
pthread_cond_destroy (&r_chain->mutex);
2007a28: 40 00 02 be call 2008520 <pthread_cond_destroy>
2007a2c: 90 10 00 19 mov %i1, %o0
free (r_chain);
2007a30: 7f ff f0 9e call 2003ca8 <free>
2007a34: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007a38: 10 80 00 0b b 2007a64 <aio_cancel+0xec>
2007a3c: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007a40: 40 00 04 36 call 2008b18 <pthread_mutex_lock>
2007a44: 90 10 00 19 mov %i1, %o0
2007a48: 40 00 0a bc call 200a538 <_Chain_Extract>
2007a4c: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007a50: 40 00 01 79 call 2008034 <rtems_aio_remove_fd>
2007a54: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
2007a58: 40 00 04 50 call 2008b98 <pthread_mutex_unlock>
2007a5c: 90 10 00 19 mov %i1, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007a60: 90 17 60 24 or %i5, 0x24, %o0
2007a64: 40 00 04 4d call 2008b98 <pthread_mutex_unlock>
2007a68: b0 10 20 00 clr %i0
return AIO_CANCELED;
2007a6c: 81 c7 e0 08 ret
2007a70: 81 e8 00 00 restore
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
2007a74: 80 a7 00 18 cmp %i4, %i0
2007a78: 12 80 00 17 bne 2007ad4 <aio_cancel+0x15c>
2007a7c: 90 17 60 24 or %i5, 0x24, %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);
2007a80: 11 00 80 80 sethi %hi(0x2020000), %o0
2007a84: 92 10 00 1c mov %i4, %o1
2007a88: 90 12 20 6c or %o0, 0x6c, %o0
2007a8c: 40 00 01 3f call 2007f88 <rtems_aio_search_fd>
2007a90: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007a94: b0 92 20 00 orcc %o0, 0, %i0
2007a98: 32 80 00 23 bne,a 2007b24 <aio_cancel+0x1ac>
2007a9c: b8 06 20 1c add %i0, 0x1c, %i4
2007aa0: ba 17 60 24 or %i5, 0x24, %i5
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
2007aa4: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
2007aa8: 82 07 60 58 add %i5, 0x58, %g1
2007aac: 80 a0 80 01 cmp %g2, %g1
2007ab0: 02 80 00 18 be 2007b10 <aio_cancel+0x198> <== NEVER TAKEN
2007ab4: 90 07 60 54 add %i5, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
2007ab8: 92 10 00 1c mov %i4, %o1
2007abc: 40 00 01 33 call 2007f88 <rtems_aio_search_fd>
2007ac0: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007ac4: 80 a2 20 00 cmp %o0, 0
2007ac8: 12 80 00 0b bne 2007af4 <aio_cancel+0x17c>
2007acc: 92 10 00 19 mov %i1, %o1
pthread_mutex_unlock (&aio_request_queue.mutex);
2007ad0: 90 10 00 1d mov %i5, %o0
2007ad4: 40 00 04 31 call 2008b98 <pthread_mutex_unlock>
2007ad8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one (EINVAL);
2007adc: 40 00 28 31 call 2011ba0 <__errno>
2007ae0: 01 00 00 00 nop
2007ae4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007ae8: c2 22 00 00 st %g1, [ %o0 ]
2007aec: 81 c7 e0 08 ret
2007af0: 91 e8 3f ff restore %g0, -1, %o0
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007af4: 40 00 01 64 call 2008084 <rtems_aio_remove_req>
2007af8: 90 02 20 08 add %o0, 8, %o0
2007afc: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007b00: 40 00 04 26 call 2008b98 <pthread_mutex_unlock>
2007b04: 90 10 00 1d mov %i5, %o0
return result;
2007b08: 81 c7 e0 08 ret
2007b0c: 81 e8 00 00 restore
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
2007b10: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2007b14: 40 00 04 21 call 2008b98 <pthread_mutex_unlock>
2007b18: b0 10 20 02 mov 2, %i0
return AIO_ALLDONE;
2007b1c: 81 c7 e0 08 ret
2007b20: 81 e8 00 00 restore
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007b24: 40 00 03 fd call 2008b18 <pthread_mutex_lock>
2007b28: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007b2c: 92 10 00 19 mov %i1, %o1
2007b30: 40 00 01 55 call 2008084 <rtems_aio_remove_req>
2007b34: 90 06 20 08 add %i0, 8, %o0
2007b38: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
2007b3c: 40 00 04 17 call 2008b98 <pthread_mutex_unlock>
2007b40: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007b44: 40 00 04 15 call 2008b98 <pthread_mutex_unlock>
2007b48: 90 17 60 24 or %i5, 0x24, %o0
return result;
}
return AIO_ALLDONE;
}
2007b4c: 81 c7 e0 08 ret
2007b50: 81 e8 00 00 restore
02007b5c <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
2007b5c: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
2007b60: 03 00 00 08 sethi %hi(0x2000), %g1
2007b64: 80 a6 00 01 cmp %i0, %g1
2007b68: 12 80 00 10 bne 2007ba8 <aio_fsync+0x4c>
2007b6c: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
2007b70: d0 06 40 00 ld [ %i1 ], %o0
2007b74: 40 00 1a 31 call 200e438 <fcntl>
2007b78: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2007b7c: 90 0a 20 03 and %o0, 3, %o0
2007b80: 90 02 3f ff add %o0, -1, %o0
2007b84: 80 a2 20 01 cmp %o0, 1
2007b88: 18 80 00 08 bgu 2007ba8 <aio_fsync+0x4c>
2007b8c: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2007b90: 7f ff f1 9d call 2004204 <malloc>
2007b94: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2007b98: 80 a2 20 00 cmp %o0, 0
2007b9c: 32 80 00 0b bne,a 2007bc8 <aio_fsync+0x6c> <== ALWAYS TAKEN
2007ba0: f2 22 20 14 st %i1, [ %o0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2007ba4: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
2007ba8: 82 10 3f ff mov -1, %g1
2007bac: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
2007bb0: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
2007bb4: 40 00 27 fb call 2011ba0 <__errno>
2007bb8: b0 10 3f ff mov -1, %i0
2007bbc: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
2007bc0: 81 c7 e0 08 ret
2007bc4: 81 e8 00 00 restore
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
2007bc8: 82 10 20 03 mov 3, %g1
2007bcc: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
2007bd0: 40 00 01 4a call 20080f8 <rtems_aio_enqueue>
2007bd4: 91 e8 00 08 restore %g0, %o0, %o0
02008328 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
2008328: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
200832c: d0 06 00 00 ld [ %i0 ], %o0
2008330: 40 00 18 42 call 200e438 <fcntl>
2008334: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2008338: 90 0a 20 03 and %o0, 3, %o0
200833c: 80 a2 20 02 cmp %o0, 2
2008340: 02 80 00 05 be 2008354 <aio_read+0x2c>
2008344: ba 10 00 18 mov %i0, %i5
2008348: 80 a2 20 00 cmp %o0, 0
200834c: 12 80 00 10 bne 200838c <aio_read+0x64> <== ALWAYS TAKEN
2008350: 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)
2008354: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2008358: 80 a0 60 00 cmp %g1, 0
200835c: 32 80 00 0c bne,a 200838c <aio_read+0x64>
2008360: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
2008364: c2 07 60 08 ld [ %i5 + 8 ], %g1
2008368: 80 a0 60 00 cmp %g1, 0
200836c: 26 80 00 08 bl,a 200838c <aio_read+0x64>
2008370: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2008374: 7f ff ef a4 call 2004204 <malloc>
2008378: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
200837c: 80 a2 20 00 cmp %o0, 0
2008380: 32 80 00 0b bne,a 20083ac <aio_read+0x84> <== ALWAYS TAKEN
2008384: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
2008388: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
200838c: 82 10 3f ff mov -1, %g1
2008390: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
2008394: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
2008398: 40 00 26 02 call 2011ba0 <__errno>
200839c: b0 10 3f ff mov -1, %i0
20083a0: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
20083a4: 81 c7 e0 08 ret
20083a8: 81 e8 00 00 restore
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
20083ac: 82 10 20 01 mov 1, %g1
20083b0: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
20083b4: 7f ff ff 51 call 20080f8 <rtems_aio_enqueue>
20083b8: 91 e8 00 08 restore %g0, %o0, %o0
020083c4 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
20083c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
20083c8: d0 06 00 00 ld [ %i0 ], %o0
20083cc: 40 00 18 1b call 200e438 <fcntl>
20083d0: 92 10 20 03 mov 3, %o1
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
20083d4: 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)))
20083d8: 90 0a 20 03 and %o0, 3, %o0
20083dc: 90 02 3f ff add %o0, -1, %o0
20083e0: 80 a2 20 01 cmp %o0, 1
20083e4: 18 80 00 10 bgu 2008424 <aio_write+0x60>
20083e8: 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)
20083ec: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20083f0: 80 a0 60 00 cmp %g1, 0
20083f4: 32 80 00 0c bne,a 2008424 <aio_write+0x60>
20083f8: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
20083fc: c2 06 20 08 ld [ %i0 + 8 ], %g1
2008400: 80 a0 60 00 cmp %g1, 0
2008404: 26 80 00 08 bl,a 2008424 <aio_write+0x60>
2008408: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
200840c: 7f ff ef 7e call 2004204 <malloc>
2008410: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2008414: 80 a2 20 00 cmp %o0, 0
2008418: 32 80 00 0b bne,a 2008444 <aio_write+0x80> <== ALWAYS TAKEN
200841c: f0 22 20 14 st %i0, [ %o0 + 0x14 ]
2008420: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2008424: 82 10 3f ff mov -1, %g1
2008428: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
200842c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
2008430: 40 00 25 dc call 2011ba0 <__errno>
2008434: b0 10 3f ff mov -1, %i0
2008438: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
200843c: 81 c7 e0 08 ret
2008440: 81 e8 00 00 restore
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
2008444: 82 10 20 02 mov 2, %g1
2008448: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
200844c: 7f ff ff 2b call 20080f8 <rtems_aio_enqueue>
2008450: 91 e8 00 08 restore %g0, %o0, %o0
02027534 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
2027534: 9d e3 bf 40 save %sp, -192, %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(
2027538: 94 10 20 19 mov 0x19, %o2
202753c: 92 10 00 18 mov %i0, %o1
2027540: 90 07 bf a4 add %fp, -92, %o0
2027544: 17 00 81 ac sethi %hi(0x206b000), %o3
2027548: 96 12 e0 dc or %o3, 0xdc, %o3 ! 206b0dc <rtems_global_user_env+0x4>
202754c: 7f ff 8b 17 call 200a1a8 <rtems_filesystem_eval_path_start_with_root_and_current>
2027550: 98 02 ff fc add %o3, -4, %o4
2027554: 90 07 bf e0 add %fp, -32, %o0
2027558: 7f ff 8b eb call 200a504 <rtems_filesystem_location_copy_and_detach>
202755c: 92 07 bf bc add %fp, -68, %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 );
2027560: 7f ff 8c 61 call 200a6e4 <rtems_filesystem_location_transform_to_global>
2027564: 90 07 bf e0 add %fp, -32, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
2027568: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
&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 );
202756c: d0 27 bf fc st %o0, [ %fp + -4 ]
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
2027570: 3b 00 81 7d sethi %hi(0x205f400), %i5
2027574: ba 17 61 f4 or %i5, 0x1f4, %i5 ! 205f5f4 <rtems_filesystem_null_handlers>
2027578: 80 a0 40 1d cmp %g1, %i5
202757c: 02 80 00 2a be 2027624 <chroot+0xf0>
2027580: b0 10 3f ff mov -1, %i0
rtems_filesystem_global_location_t *new_root_loc =
2027584: 7f ff 8c 25 call 200a618 <rtems_filesystem_global_location_obtain>
2027588: 90 07 bf fc add %fp, -4, %o0
rtems_filesystem_global_location_obtain( &new_current_loc );
rtems_filesystem_node_types_t type =
(*new_root_loc->location.ops->node_type_h)( &new_root_loc->location );
202758c: c2 02 20 14 ld [ %o0 + 0x14 ], %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 =
2027590: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2027594: 9f c0 40 00 call %g1
2027598: b0 10 00 08 mov %o0, %i0
(*new_root_loc->location.ops->node_type_h)( &new_root_loc->location );
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
202759c: 80 a2 20 00 cmp %o0, 0
20275a0: 32 80 00 17 bne,a 20275fc <chroot+0xc8>
20275a4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
sc = rtems_libio_set_private_env();
20275a8: 40 00 05 67 call 2028b44 <rtems_libio_set_private_env>
20275ac: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
20275b0: 80 a2 20 00 cmp %o0, 0
20275b4: 12 80 00 0c bne 20275e4 <chroot+0xb0>
20275b8: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
20275bc: 3b 00 81 ac sethi %hi(0x206b000), %i5
20275c0: d0 07 60 d4 ld [ %i5 + 0xd4 ], %o0 ! 206b0d4 <rtems_current_user_env>
20275c4: 92 10 00 18 mov %i0, %o1
20275c8: 7f ff 8c 0b call 200a5f4 <rtems_filesystem_global_location_assign>
20275cc: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
20275d0: d0 07 60 d4 ld [ %i5 + 0xd4 ], %o0
20275d4: d2 07 bf fc ld [ %fp + -4 ], %o1
20275d8: 7f ff 8c 07 call 200a5f4 <rtems_filesystem_global_location_assign>
20275dc: b0 10 20 00 clr %i0
20275e0: 30 80 00 11 b,a 2027624 <chroot+0xf0>
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
20275e4: 22 80 00 0e be,a 202761c <chroot+0xe8> <== NEVER TAKEN
20275e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
errno = ENOMEM;
20275ec: 40 00 69 ad call 2041ca0 <__errno>
20275f0: 01 00 00 00 nop
20275f4: 10 80 00 08 b 2027614 <chroot+0xe0>
20275f8: 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 ) ) {
20275fc: 80 a0 40 1d cmp %g1, %i5
2027600: 22 80 00 07 be,a 202761c <chroot+0xe8> <== NEVER TAKEN
2027604: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
errno = eno;
2027608: 40 00 69 a6 call 2041ca0 <__errno>
202760c: 01 00 00 00 nop
2027610: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2027614: c2 22 00 00 st %g1, [ %o0 ]
rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
rv = -1;
}
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
2027618: 90 10 00 18 mov %i0, %o0
202761c: 7f ff 8b df call 200a598 <rtems_filesystem_global_location_release>
2027620: b0 10 3f ff mov -1, %i0
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2027624: 7f ff 8b 04 call 200a234 <rtems_filesystem_eval_path_cleanup>
2027628: 90 07 bf a4 add %fp, -92, %o0
if ( rv != 0 ) {
202762c: 80 a6 20 00 cmp %i0, 0
2027630: 02 80 00 04 be 2027640 <chroot+0x10c>
2027634: 01 00 00 00 nop
rtems_filesystem_global_location_release( new_current_loc );
2027638: 7f ff 8b d8 call 200a598 <rtems_filesystem_global_location_release>
202763c: d0 07 bf fc ld [ %fp + -4 ], %o0
}
return rv;
}
2027640: 81 c7 e0 08 ret
2027644: 81 e8 00 00 restore
02007504 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
2007504: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2007508: 80 a6 60 00 cmp %i1, 0
200750c: 12 80 00 06 bne 2007524 <clock_gettime+0x20>
2007510: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
2007514: 40 00 25 1d call 2010988 <__errno>
2007518: 01 00 00 00 nop
200751c: 10 80 00 24 b 20075ac <clock_gettime+0xa8>
2007520: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
if ( clock_id == CLOCK_REALTIME ) {
2007524: 12 80 00 14 bne 2007574 <clock_gettime+0x70>
2007528: 80 a6 20 04 cmp %i0, 4
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
200752c: 40 00 08 21 call 20095b0 <_TOD_Get_as_timestamp>
2007530: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007534: 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);
2007538: 94 10 20 00 clr %o2
200753c: 90 10 00 1c mov %i4, %o0
2007540: 92 10 00 1d mov %i5, %o1
2007544: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007548: 40 00 53 a0 call 201c3c8 <__divdi3>
200754c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007550: 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);
2007554: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007558: 94 10 20 00 clr %o2
200755c: 92 10 00 1d mov %i5, %o1
2007560: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007564: 40 00 54 7f call 201c760 <__moddi3>
2007568: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
200756c: 10 80 00 09 b 2007590 <clock_gettime+0x8c>
2007570: d2 26 60 04 st %o1, [ %i1 + 4 ]
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
2007574: 02 80 00 05 be 2007588 <clock_gettime+0x84> <== NEVER TAKEN
2007578: 01 00 00 00 nop
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
200757c: 80 a6 20 02 cmp %i0, 2
2007580: 12 80 00 06 bne 2007598 <clock_gettime+0x94>
2007584: 80 a6 20 03 cmp %i0, 3
_TOD_Get_uptime_as_timespec( tp );
2007588: 40 00 08 1d call 20095fc <_TOD_Get_uptime_as_timespec>
200758c: 90 10 00 19 mov %i1, %o0
return 0;
2007590: 81 c7 e0 08 ret
2007594: 91 e8 20 00 restore %g0, 0, %o0
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
2007598: 12 80 00 08 bne 20075b8 <clock_gettime+0xb4>
200759c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
20075a0: 40 00 24 fa call 2010988 <__errno>
20075a4: 01 00 00 00 nop
20075a8: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
20075ac: c2 22 00 00 st %g1, [ %o0 ]
20075b0: 81 c7 e0 08 ret
20075b4: 91 e8 3f ff restore %g0, -1, %o0
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
20075b8: 40 00 24 f4 call 2010988 <__errno>
20075bc: b0 10 3f ff mov -1, %i0
20075c0: 82 10 20 16 mov 0x16, %g1
20075c4: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
20075c8: 81 c7 e0 08 ret
20075cc: 81 e8 00 00 restore
02029474 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
2029474: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2029478: 80 a6 60 00 cmp %i1, 0
202947c: 02 80 00 0b be 20294a8 <clock_settime+0x34> <== NEVER TAKEN
2029480: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
2029484: 80 a6 20 01 cmp %i0, 1
2029488: 12 80 00 46 bne 20295a0 <clock_settime+0x12c>
202948c: 80 a6 20 02 cmp %i0, 2
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
2029490: c4 06 40 00 ld [ %i1 ], %g2
2029494: 03 08 76 b9 sethi %hi(0x21dae400), %g1
2029498: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff <RAM_END+0x1f9ae4ff>
202949c: 80 a0 80 01 cmp %g2, %g1
20294a0: 38 80 00 06 bgu,a 20294b8 <clock_settime+0x44>
20294a4: 03 00 81 bc sethi %hi(0x206f000), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
20294a8: 40 00 61 fe call 2041ca0 <__errno>
20294ac: 01 00 00 00 nop
20294b0: 10 80 00 44 b 20295c0 <clock_settime+0x14c>
20294b4: 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++;
20294b8: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2
20294bc: 84 00 a0 01 inc %g2
20294c0: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ]
return _Thread_Dispatch_disable_level;
20294c4: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
20294c8: d6 06 40 00 ld [ %i1 ], %o3
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
20294cc: b0 10 20 00 clr %i0
20294d0: 95 3a e0 1f sra %o3, 0x1f, %o2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
20294d4: 83 2a a0 03 sll %o2, 3, %g1
20294d8: 89 32 e0 1d srl %o3, 0x1d, %g4
20294dc: 87 2a e0 03 sll %o3, 3, %g3
20294e0: 84 11 00 01 or %g4, %g1, %g2
20294e4: 83 30 e0 1b srl %g3, 0x1b, %g1
20294e8: 99 28 a0 05 sll %g2, 5, %o4
20294ec: 9b 28 e0 05 sll %g3, 5, %o5
20294f0: 98 10 40 0c or %g1, %o4, %o4
20294f4: 86 a3 40 03 subcc %o5, %g3, %g3
20294f8: 83 30 e0 1a srl %g3, 0x1a, %g1
20294fc: 84 63 00 02 subx %o4, %g2, %g2
2029500: 9b 28 e0 06 sll %g3, 6, %o5
2029504: 99 28 a0 06 sll %g2, 6, %o4
2029508: 9a a3 40 03 subcc %o5, %g3, %o5
202950c: 98 10 40 0c or %g1, %o4, %o4
2029510: 98 63 00 02 subx %o4, %g2, %o4
2029514: 96 83 40 0b addcc %o5, %o3, %o3
2029518: 83 32 e0 1e srl %o3, 0x1e, %g1
202951c: 94 43 00 0a addx %o4, %o2, %o2
2029520: bb 2a e0 02 sll %o3, 2, %i5
2029524: b9 2a a0 02 sll %o2, 2, %i4
2029528: 96 82 c0 1d addcc %o3, %i5, %o3
202952c: b8 10 40 1c or %g1, %i4, %i4
2029530: 93 2a e0 02 sll %o3, 2, %o1
2029534: 94 42 80 1c addx %o2, %i4, %o2
2029538: 83 32 e0 1e srl %o3, 0x1e, %g1
202953c: 91 2a a0 02 sll %o2, 2, %o0
2029540: 90 10 40 08 or %g1, %o0, %o0
2029544: 96 82 c0 09 addcc %o3, %o1, %o3
2029548: 94 42 80 08 addx %o2, %o0, %o2
202954c: 83 32 e0 1e srl %o3, 0x1e, %g1
2029550: 93 2a e0 02 sll %o3, 2, %o1
2029554: 91 2a a0 02 sll %o2, 2, %o0
2029558: 96 82 c0 09 addcc %o3, %o1, %o3
202955c: 90 10 40 08 or %g1, %o0, %o0
2029560: 87 32 e0 17 srl %o3, 0x17, %g3
2029564: 94 42 80 08 addx %o2, %o0, %o2
2029568: 85 2a a0 09 sll %o2, 9, %g2
202956c: 94 10 c0 02 or %g3, %g2, %o2
2029570: c6 06 60 04 ld [ %i1 + 4 ], %g3
2029574: 83 2a e0 09 sll %o3, 9, %g1
2029578: 85 38 e0 1f sra %g3, 0x1f, %g2
202957c: 96 80 40 03 addcc %g1, %g3, %o3
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
2029580: 90 07 bf f8 add %fp, -8, %o0
2029584: 94 42 80 02 addx %o2, %g2, %o2
2029588: 40 00 06 30 call 202ae48 <_TOD_Set_with_timestamp>
202958c: d4 3f bf f8 std %o2, [ %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();
2029590: 7f ff 9a 30 call 200fe50 <_Thread_Enable_dispatch>
2029594: 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;
2029598: 81 c7 e0 08 ret
202959c: 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 )
20295a0: 02 80 00 05 be 20295b4 <clock_settime+0x140>
20295a4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
20295a8: 80 a6 20 03 cmp %i0, 3
20295ac: 12 80 00 08 bne 20295cc <clock_settime+0x158>
20295b0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
20295b4: 40 00 61 bb call 2041ca0 <__errno>
20295b8: 01 00 00 00 nop
20295bc: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
20295c0: c2 22 00 00 st %g1, [ %o0 ]
20295c4: 81 c7 e0 08 ret
20295c8: 91 e8 3f ff restore %g0, -1, %o0
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
20295cc: 40 00 61 b5 call 2041ca0 <__errno>
20295d0: b0 10 3f ff mov -1, %i0
20295d4: 82 10 20 16 mov 0x16, %g1
20295d8: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
20295dc: 81 c7 e0 08 ret
20295e0: 81 e8 00 00 restore
02003750 <create_disk>:
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
2003750: 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) {
2003754: 03 00 80 84 sethi %hi(0x2021000), %g1
2003758: e2 00 63 a8 ld [ %g1 + 0x3a8 ], %l1 ! 20213a8 <disktab_size>
200375c: 80 a6 00 11 cmp %i0, %l1
2003760: 0a 80 00 18 bcs 20037c0 <create_disk+0x70>
2003764: ba 10 00 18 mov %i0, %i5
rtems_disk_device_table *table = disktab;
2003768: 03 00 80 84 sethi %hi(0x2021000), %g1
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
200376c: b9 2c 60 01 sll %l1, 1, %i4
if (major >= new_size) {
2003770: 80 a6 00 1c cmp %i0, %i4
2003774: 0a 80 00 03 bcs 2003780 <create_disk+0x30> <== NEVER TAKEN
2003778: d0 00 63 ac ld [ %g1 + 0x3ac ], %o0
new_size = major + 1;
200377c: b8 06 20 01 add %i0, 1, %i4
}
table = realloc(table, new_size * sizeof(*table));
2003780: 93 2f 20 03 sll %i4, 3, %o1
2003784: 40 00 08 d3 call 2005ad0 <realloc>
2003788: b0 10 20 1a mov 0x1a, %i0
if (table == NULL) {
200378c: 80 a2 20 00 cmp %o0, 0
2003790: 02 80 00 46 be 20038a8 <create_disk+0x158> <== ALWAYS TAKEN
2003794: a0 10 00 08 mov %o0, %l0
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2003798: 94 27 00 11 sub %i4, %l1, %o2 <== NOT EXECUTED
200379c: 91 2c 60 03 sll %l1, 3, %o0 <== NOT EXECUTED
20037a0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20037a4: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
20037a8: 40 00 41 f3 call 2013f74 <memset> <== NOT EXECUTED
20037ac: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
20037b0: 03 00 80 84 sethi %hi(0x2021000), %g1 <== NOT EXECUTED
20037b4: e0 20 63 ac st %l0, [ %g1 + 0x3ac ] ! 20213ac <disktab> <== NOT EXECUTED
disktab_size = new_size;
20037b8: 03 00 80 84 sethi %hi(0x2021000), %g1 <== NOT EXECUTED
20037bc: f8 20 63 a8 st %i4, [ %g1 + 0x3a8 ] ! 20213a8 <disktab_size><== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
20037c0: 03 00 80 84 sethi %hi(0x2021000), %g1
20037c4: e4 00 63 ac ld [ %g1 + 0x3ac ], %l2 ! 20213ac <disktab>
20037c8: a3 2f 60 03 sll %i5, 3, %l1
20037cc: d0 04 80 11 ld [ %l2 + %l1 ], %o0
20037d0: a6 04 80 11 add %l2, %l1, %l3
20037d4: 80 a2 20 00 cmp %o0, 0
20037d8: 02 80 00 05 be 20037ec <create_disk+0x9c>
20037dc: e8 04 e0 04 ld [ %l3 + 4 ], %l4
20037e0: 80 a6 40 14 cmp %i1, %l4
20037e4: 2a 80 00 18 bcs,a 2003844 <create_disk+0xf4>
20037e8: 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) {
20037ec: 80 a5 20 00 cmp %l4, 0
20037f0: 02 80 00 03 be 20037fc <create_disk+0xac>
20037f4: b8 10 20 08 mov 8, %i4
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
20037f8: b9 2d 20 01 sll %l4, 1, %i4
}
if (minor >= new_size) {
20037fc: 80 a6 40 1c cmp %i1, %i4
2003800: 3a 80 00 02 bcc,a 2003808 <create_disk+0xb8>
2003804: b8 06 60 01 add %i1, 1, %i4
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
2003808: 93 2f 20 02 sll %i4, 2, %o1
200380c: 40 00 08 b1 call 2005ad0 <realloc>
2003810: b0 10 20 1a mov 0x1a, %i0
if (table == NULL) {
2003814: 80 a2 20 00 cmp %o0, 0
2003818: 02 80 00 24 be 20038a8 <create_disk+0x158>
200381c: a0 10 00 08 mov %o0, %l0
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2003820: 94 27 00 14 sub %i4, %l4, %o2
2003824: 91 2d 20 02 sll %l4, 2, %o0
2003828: 92 10 20 00 clr %o1
200382c: 90 04 00 08 add %l0, %o0, %o0
2003830: 40 00 41 d1 call 2013f74 <memset>
2003834: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
2003838: e0 24 80 11 st %l0, [ %l2 + %l1 ]
disktab [major].size = new_size;
200383c: f8 24 e0 04 st %i4, [ %l3 + 4 ]
}
return disktab [major].minor + minor;
2003840: e2 04 80 11 ld [ %l2 + %l1 ], %l1
2003844: a1 2e 60 02 sll %i1, 2, %l0
2003848: 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) {
200384c: 80 a0 60 00 cmp %g1, 0
2003850: 02 80 00 16 be 20038a8 <create_disk+0x158> <== NEVER TAKEN
2003854: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
2003858: c2 04 40 10 ld [ %l1 + %l0 ], %g1
200385c: 80 a0 60 00 cmp %g1, 0
2003860: 12 80 00 12 bne 20038a8 <create_disk+0x158>
2003864: b0 10 20 0c mov 0xc, %i0
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
2003868: 90 10 20 38 mov 0x38, %o0
200386c: 40 00 05 d1 call 2004fb0 <malloc>
2003870: b0 10 20 1a mov 0x1a, %i0
if (dd == NULL) {
2003874: 80 a2 20 00 cmp %o0, 0
2003878: 02 80 00 0c be 20038a8 <create_disk+0x158> <== NEVER TAKEN
200387c: b8 10 00 08 mov %o0, %i4
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
2003880: 80 a6 a0 00 cmp %i2, 0
2003884: 02 80 00 12 be 20038cc <create_disk+0x17c>
2003888: a4 10 20 00 clr %l2
alloc_name = strdup(name);
200388c: 40 00 43 1a call 20144f4 <strdup>
2003890: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
2003894: a4 92 20 00 orcc %o0, 0, %l2
2003898: 12 80 00 17 bne 20038f4 <create_disk+0x1a4> <== ALWAYS TAKEN
200389c: b4 10 00 08 mov %o0, %i2
free(dd);
20038a0: 40 00 04 4c call 20049d0 <free> <== NOT EXECUTED
20038a4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
20038a8: 81 c7 e0 08 ret
20038ac: 81 e8 00 00 restore
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
20038b0: 40 00 04 48 call 20049d0 <free> <== NOT EXECUTED
20038b4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
20038b8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20038bc: 40 00 04 45 call 20049d0 <free> <== NOT EXECUTED
20038c0: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
20038c4: 81 c7 e0 08 ret <== NOT EXECUTED
20038c8: 81 e8 00 00 restore <== NOT EXECUTED
}
}
dd->dev = dev;
20038cc: fa 27 00 00 st %i5, [ %i4 ]
20038d0: f2 27 20 04 st %i1, [ %i4 + 4 ]
dd->name = alloc_name;
20038d4: e4 27 20 10 st %l2, [ %i4 + 0x10 ]
dd->uses = 0;
20038d8: c0 27 20 14 clr [ %i4 + 0x14 ]
dd->deleted = false;
20038dc: c0 2f 20 30 clrb [ %i4 + 0x30 ]
*dd_entry = dd;
20038e0: f8 24 40 10 st %i4, [ %l1 + %l0 ]
*dd_ptr = dd;
20038e4: f8 26 c0 00 st %i4, [ %i3 ]
return RTEMS_SUCCESSFUL;
20038e8: b0 10 20 00 clr %i0
}
20038ec: 81 c7 e0 08 ret
20038f0: 81 e8 00 00 restore
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
20038f4: 13 00 00 18 sethi %hi(0x6000), %o1
20038f8: 94 10 00 1d mov %i5, %o2
20038fc: 92 12 61 ff or %o1, 0x1ff, %o1
2003900: 40 00 06 1b call 200516c <mknod>
2003904: 96 10 00 19 mov %i1, %o3
2003908: 80 a2 20 00 cmp %o0, 0
200390c: 36 bf ff f1 bge,a 20038d0 <create_disk+0x180> <== ALWAYS TAKEN
2003910: fa 27 00 00 st %i5, [ %i4 ]
2003914: 30 bf ff e7 b,a 20038b0 <create_disk+0x160> <== NOT EXECUTED
02004a94 <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)
2004a94: 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)
2004a98: 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)
2004a9c: ba 10 00 18 mov %i0, %i5
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
2004aa0: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
2004aa4: 92 10 20 28 mov 0x28, %o1
2004aa8: 40 00 03 1e call 2005720 <calloc>
2004aac: b0 10 20 1a mov 0x1a, %i0
2004ab0: 80 a2 20 00 cmp %o0, 0
2004ab4: 02 80 00 2d be 2004b68 <data_to_part_desc.part.1+0xd4> <== NEVER TAKEN
2004ab8: b8 10 00 08 mov %o0, %i4
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
2004abc: c2 0f 40 00 ldub [ %i5 ], %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));
2004ac0: 92 07 60 08 add %i5, 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);
2004ac4: c2 2a 00 00 stb %g1, [ %o0 ]
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
2004ac8: f6 0f 60 04 ldub [ %i5 + 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));
2004acc: 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);
2004ad0: 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));
2004ad4: 40 00 42 37 call 20153b0 <memcpy>
2004ad8: 90 07 bf fc add %fp, -4, %o0
part_desc->start = LE_TO_CPU_U32(temp);
2004adc: 7f ff ff a2 call 2004964 <CPU_swap_u32>
2004ae0: d0 07 bf fc ld [ %fp + -4 ], %o0
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
2004ae4: 92 07 60 0c add %i5, 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);
2004ae8: d0 27 20 04 st %o0, [ %i4 + 4 ]
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
2004aec: 94 10 20 04 mov 4, %o2
2004af0: 40 00 42 30 call 20153b0 <memcpy>
2004af4: 90 07 bf fc add %fp, -4, %o0
part_desc->size = LE_TO_CPU_U32(temp);
2004af8: 7f ff ff 9b call 2004964 <CPU_swap_u32>
2004afc: d0 07 bf fc ld [ %fp + -4 ], %o0
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004b00: 82 1e e0 85 xor %i3, 0x85, %g1
2004b04: 80 a0 00 01 cmp %g0, %g1
/* 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);
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
part_desc->size = LE_TO_CPU_U32(temp);
2004b08: d0 27 20 08 st %o0, [ %i4 + 8 ]
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004b0c: 84 60 3f ff subx %g0, -1, %g2
2004b10: 82 1e e0 05 xor %i3, 5, %g1
2004b14: 80 a0 00 01 cmp %g0, %g1
/* 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);
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
part_desc->size = LE_TO_CPU_U32(temp);
2004b18: ba 10 00 08 mov %o0, %i5
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004b1c: 82 60 3f ff subx %g0, -1, %g1
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
2004b20: 80 90 80 01 orcc %g2, %g1, %g0
2004b24: 12 80 00 0b bne 2004b50 <data_to_part_desc.part.1+0xbc>
2004b28: 92 10 00 1b mov %i3, %o1
DOS_P32MB_PARTITION,
FAT32_PARTITION ,FAT32_LBA_PARTITION,
FAT16_LBA_PARTITION
};
return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
2004b2c: 11 00 80 90 sethi %hi(0x2024000), %o0
2004b30: 94 10 20 06 mov 6, %o2
2004b34: 40 00 41 ac call 20151e4 <memchr>
2004b38: 90 12 21 88 or %o0, 0x188, %o0
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
2004b3c: 80 a2 20 00 cmp %o0, 0
2004b40: 02 80 00 07 be 2004b5c <data_to_part_desc.part.1+0xc8>
2004b44: 80 a7 60 00 cmp %i5, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
2004b48: 02 80 00 06 be 2004b60 <data_to_part_desc.part.1+0xcc> <== NEVER TAKEN
2004b4c: 90 10 00 1c mov %i4, %o0
*new_part_desc = part_desc;
2004b50: f8 26 40 00 st %i4, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
}
return RTEMS_SUCCESSFUL;
2004b54: 81 c7 e0 08 ret
2004b58: 91 e8 20 00 restore %g0, 0, %o0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
*new_part_desc = part_desc;
}
else {
/* empty partition */
free(part_desc);
2004b5c: 90 10 00 1c mov %i4, %o0
2004b60: 40 00 03 c0 call 2005a60 <free>
2004b64: b0 10 20 00 clr %i0
}
return RTEMS_SUCCESSFUL;
}
2004b68: 81 c7 e0 08 ret
2004b6c: 81 e8 00 00 restore
02002b9c <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
2002b9c: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
2002ba0: 03 00 80 6a sethi %hi(0x201a800), %g1
2002ba4: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 201a8d0 <rtems_current_user_env>
if (rootloc->ops == &devFS_ops) {
2002ba8: 05 00 80 63 sethi %hi(0x2018c00), %g2
#include "devfs.h"
void devFS_Show(void)
{
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
2002bac: c2 00 60 04 ld [ %g1 + 4 ], %g1
if (rootloc->ops == &devFS_ops) {
2002bb0: 84 10 a0 e4 or %g2, 0xe4, %g2
2002bb4: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
2002bb8: 80 a0 c0 02 cmp %g3, %g2
2002bbc: 12 80 00 26 bne 2002c54 <devFS_Show+0xb8> <== NEVER TAKEN
2002bc0: 33 00 80 63 sethi %hi(0x2018c00), %i1
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return loc->mt_entry->immutable_fs_info;
2002bc4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
2002bc8: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002bcc: 35 00 80 63 sethi %hi(0x2018c00), %i2
}
printk(
2002bd0: 37 00 80 63 sethi %hi(0x2018c00), %i3
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
if (rootloc->ops == &devFS_ops) {
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
2002bd4: f0 00 60 04 ld [ %g1 + 4 ], %i0
2002bd8: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002bdc: b8 10 20 00 clr %i4
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
2002be0: b2 16 61 38 or %i1, 0x138, %i1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002be4: b4 16 a1 40 or %i2, 0x140, %i2
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) {
2002be8: 10 80 00 18 b 2002c48 <devFS_Show+0xac>
2002bec: b6 16 e1 48 or %i3, 0x148, %i3
devFS_node *current = nodes + i;
if (current->name != NULL) {
2002bf0: 80 a0 60 00 cmp %g1, 0
2002bf4: 22 80 00 14 be,a 2002c44 <devFS_Show+0xa8>
2002bf8: b8 07 20 01 inc %i4
size_t j = 0;
size_t m = current->namelen;
2002bfc: e2 07 60 04 ld [ %i5 + 4 ], %l1
printk("/");
2002c00: 90 10 00 19 mov %i1, %o0
2002c04: 40 00 04 d4 call 2003f54 <printk>
2002c08: a0 10 20 00 clr %l0
for (j = 0; j < m; ++j) {
2002c0c: 10 80 00 07 b 2002c28 <devFS_Show+0x8c>
2002c10: 80 a4 00 11 cmp %l0, %l1
printk("%c", current->name [j]);
2002c14: 90 10 00 1a mov %i2, %o0
2002c18: d2 48 40 10 ldsb [ %g1 + %l0 ], %o1
2002c1c: 40 00 04 ce call 2003f54 <printk>
2002c20: a0 04 20 01 inc %l0
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
2002c24: 80 a4 00 11 cmp %l0, %l1
2002c28: 32 bf ff fb bne,a 2002c14 <devFS_Show+0x78>
2002c2c: c2 07 40 00 ld [ %i5 ], %g1
printk("%c", current->name [j]);
}
printk(
2002c30: d2 07 60 08 ld [ %i5 + 8 ], %o1
2002c34: d4 07 60 0c ld [ %i5 + 0xc ], %o2
2002c38: 40 00 04 c7 call 2003f54 <printk>
2002c3c: 90 10 00 1b mov %i3, %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) {
2002c40: b8 07 20 01 inc %i4
2002c44: ba 07 60 14 add %i5, 0x14, %i5
2002c48: 80 a7 00 18 cmp %i4, %i0
2002c4c: 32 bf ff e9 bne,a 2002bf0 <devFS_Show+0x54>
2002c50: c2 07 40 00 ld [ %i5 ], %g1
2002c54: 81 c7 e0 08 ret
2002c58: 81 e8 00 00 restore
0200ba40 <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
200ba40: 9d e3 bf a0 save %sp, -96, %sp
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return loc->mt_entry->immutable_fs_info;
200ba44: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
static inline const char *rtems_filesystem_eval_path_get_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->path;
200ba48: f2 06 00 00 ld [ %i0 ], %i1
200ba4c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
static inline size_t rtems_filesystem_eval_path_get_pathlen(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->pathlen;
200ba50: 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;
200ba54: e2 00 60 04 ld [ %g1 + 4 ], %l1
200ba58: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
200ba5c: b8 10 20 00 clr %i4
devFS_node *free_node = NULL;
200ba60: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200ba64: 10 80 00 12 b 200baac <devFS_eval_path+0x6c>
200ba68: b4 10 20 00 clr %i2
devFS_node *current = nodes + i;
if (current->name != NULL) {
200ba6c: 80 a2 20 00 cmp %o0, 0
200ba70: 02 80 00 0c be 200baa0 <devFS_eval_path+0x60>
200ba74: a0 10 00 1d mov %i5, %l0
if (
200ba78: c4 07 60 04 ld [ %i5 + 4 ], %g2
200ba7c: 80 a0 80 1b cmp %g2, %i3
200ba80: 12 80 00 08 bne 200baa0 <devFS_eval_path+0x60>
200ba84: a0 10 00 01 mov %g1, %l0
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
200ba88: 92 10 00 19 mov %i1, %o1
200ba8c: 40 00 0e 37 call 200f368 <memcmp>
200ba90: 94 10 00 1b mov %i3, %o2
200ba94: 80 a2 20 00 cmp %o0, 0
200ba98: 22 80 00 02 be,a 200baa0 <devFS_eval_path+0x60>
200ba9c: 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) {
200baa0: b4 06 a0 01 inc %i2
200baa4: ba 07 60 14 add %i5, 0x14, %i5
200baa8: 82 10 00 10 mov %l0, %g1
200baac: 80 a7 20 00 cmp %i4, 0
200bab0: 02 80 00 05 be 200bac4 <devFS_eval_path+0x84>
200bab4: 80 a6 80 11 cmp %i2, %l1
200bab8: 80 a0 60 00 cmp %g1, 0
200babc: 12 80 00 04 bne 200bacc <devFS_eval_path+0x8c>
200bac0: 80 a6 80 11 cmp %i2, %l1
200bac4: 32 bf ff ea bne,a 200ba6c <devFS_eval_path+0x2c>
200bac8: 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) {
200bacc: 80 a7 20 00 cmp %i4, 0
200bad0: 02 80 00 07 be 200baec <devFS_eval_path+0xac>
200bad4: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
200bad8: 80 88 a0 40 btst 0x40, %g2
200badc: 32 80 00 13 bne,a 200bb28 <devFS_eval_path+0xe8>
200bae0: b2 10 20 11 mov 0x11, %i1
currentloc->node_access = node;
200bae4: 10 80 00 0b b 200bb10 <devFS_eval_path+0xd0>
200bae8: 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) {
200baec: 80 88 a0 20 btst 0x20, %g2
200baf0: 02 80 00 0d be 200bb24 <devFS_eval_path+0xe4> <== NEVER TAKEN
200baf4: 80 a0 60 00 cmp %g1, 0
if (free_node != NULL) {
200baf8: 02 80 00 09 be 200bb1c <devFS_eval_path+0xdc>
200bafc: 84 10 21 ff mov 0x1ff, %g2
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
200bb00: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
currentloc->node_access = free_node;
200bb04: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
200bb08: f2 26 20 08 st %i1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
200bb0c: 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;
200bb10: c0 26 20 04 clr [ %i0 + 4 ]
200bb14: 81 c7 e0 08 ret
200bb18: 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);
200bb1c: 10 80 00 03 b 200bb28 <devFS_eval_path+0xe8>
200bb20: b2 10 20 1c mov 0x1c, %i1
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200bb24: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
200bb28: 7f ff e4 a3 call 2004db4 <rtems_filesystem_eval_path_error>
200bb2c: 81 e8 00 00 restore
02003710 <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2003710: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
2003714: 80 a6 a0 03 cmp %i2, 3
2003718: 12 80 00 0e bne 2003750 <devFS_mknod+0x40>
200371c: 03 00 00 3c sethi %hi(0xf000), %g1
2003720: c2 4e 40 00 ldsb [ %i1 ], %g1
2003724: 80 a0 60 64 cmp %g1, 0x64
2003728: 12 80 00 0a bne 2003750 <devFS_mknod+0x40> <== NEVER TAKEN
200372c: 03 00 00 3c sethi %hi(0xf000), %g1
2003730: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
2003734: 80 a0 60 65 cmp %g1, 0x65
2003738: 12 80 00 06 bne 2003750 <devFS_mknod+0x40> <== NEVER TAKEN
200373c: 03 00 00 3c sethi %hi(0xf000), %g1
2003740: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
2003744: 80 a0 60 76 cmp %g1, 0x76
2003748: 02 80 00 24 be 20037d8 <devFS_mknod+0xc8> <== ALWAYS TAKEN
200374c: 03 00 00 3c sethi %hi(0xf000), %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
2003750: 05 00 00 08 sethi %hi(0x2000), %g2
2003754: 82 0e c0 01 and %i3, %g1, %g1
2003758: 80 a0 40 02 cmp %g1, %g2
200375c: 02 80 00 05 be 2003770 <devFS_mknod+0x60>
2003760: 05 00 00 18 sethi %hi(0x6000), %g2
2003764: 80 a0 40 02 cmp %g1, %g2
2003768: 12 80 00 16 bne 20037c0 <devFS_mknod+0xb0>
200376c: 01 00 00 00 nop
char *dupname = malloc(namelen);
2003770: 40 00 02 29 call 2004014 <malloc>
2003774: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
2003778: 84 92 20 00 orcc %o0, 0, %g2
200377c: 02 80 00 0d be 20037b0 <devFS_mknod+0xa0>
2003780: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
2003784: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
2003788: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
200378c: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
2003790: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
2003794: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
2003798: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
200379c: 94 10 00 1a mov %i2, %o2
20037a0: 40 00 2f 20 call 200f420 <memcpy>
20037a4: b0 10 20 00 clr %i0
20037a8: 81 c7 e0 08 ret
20037ac: 81 e8 00 00 restore
} else {
errno = ENOMEM;
20037b0: 40 00 2b 03 call 200e3bc <__errno>
20037b4: 01 00 00 00 nop
20037b8: 10 80 00 05 b 20037cc <devFS_mknod+0xbc>
20037bc: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
rv = -1;
}
} else {
errno = ENOTSUP;
20037c0: 40 00 2a ff call 200e3bc <__errno>
20037c4: 01 00 00 00 nop
20037c8: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
20037cc: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
20037d0: 81 c7 e0 08 ret
20037d4: 91 e8 3f ff restore %g0, -1, %o0
}
} else {
if (!S_ISDIR(mode)) {
20037d8: b6 0e c0 01 and %i3, %g1, %i3
20037dc: 03 00 00 10 sethi %hi(0x4000), %g1
20037e0: 80 a6 c0 01 cmp %i3, %g1
20037e4: 02 bf ff f1 be 20037a8 <devFS_mknod+0x98> <== ALWAYS TAKEN
20037e8: b0 10 20 00 clr %i0
errno = ENOTSUP;
20037ec: 40 00 2a f4 call 200e3bc <__errno> <== NOT EXECUTED
20037f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20037f4: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
20037f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
}
return rv;
}
20037fc: 81 c7 e0 08 ret <== NOT EXECUTED
2003800: 81 e8 00 00 restore <== NOT EXECUTED
020036e0 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
20036e0: 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);
20036e4: 03 00 80 84 sethi %hi(0x2021000), %g1
20036e8: d0 00 63 a4 ld [ %g1 + 0x3a4 ], %o0 ! 20213a4 <diskdevs_mutex>
20036ec: 92 10 20 00 clr %o1
20036f0: 94 10 20 00 clr %o2
20036f4: 40 00 15 98 call 2008d54 <rtems_semaphore_obtain>
20036f8: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
20036fc: 80 a2 20 00 cmp %o0, 0
2003700: 12 80 00 05 bne 2003714 <disk_lock+0x34> <== NEVER TAKEN
2003704: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
2003708: 03 00 80 84 sethi %hi(0x2021000), %g1
return RTEMS_SUCCESSFUL;
200370c: 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;
2003710: c4 28 63 a0 stb %g2, [ %g1 + 0x3a0 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
2003714: 81 c7 e0 08 ret
2003718: 81 e8 00 00 restore
0200371c <disk_unlock>:
static void
disk_unlock(void)
{
200371c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
2003720: 03 00 80 84 sethi %hi(0x2021000), %g1
2003724: c0 28 63 a0 clrb [ %g1 + 0x3a0 ] ! 20213a0 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
2003728: 03 00 80 84 sethi %hi(0x2021000), %g1
200372c: 40 00 15 d4 call 2008e7c <rtems_semaphore_release>
2003730: d0 00 63 a4 ld [ %g1 + 0x3a4 ], %o0 ! 20213a4 <diskdevs_mutex>
if (sc != RTEMS_SUCCESSFUL) {
2003734: 80 a2 20 00 cmp %o0, 0
2003738: 02 80 00 04 be 2003748 <disk_unlock+0x2c> <== ALWAYS TAKEN
200373c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
2003740: 40 00 17 31 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
2003744: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2003748: 81 c7 e0 08 ret
200374c: 81 e8 00 00 restore
020052f0 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
20052f0: 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);
20052f4: 7f ff f4 be call 20025ec <sparc_disable_interrupts>
20052f8: ba 10 00 18 mov %i0, %i5
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
20052fc: 10 80 00 0f b 2005338 <drainOutput.part.0+0x48>
2005300: b8 10 20 02 mov 2, %i4
rtems_interrupt_enable (level);
2005304: 7f ff f4 be call 20025fc <sparc_enable_interrupts> <== NOT EXECUTED
2005308: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
200530c: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
2005310: 92 10 20 00 clr %o1 <== NOT EXECUTED
2005314: 40 00 09 59 call 2007878 <rtems_semaphore_obtain> <== NOT EXECUTED
2005318: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200531c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2005320: 02 80 00 04 be 2005330 <drainOutput.part.0+0x40> <== NOT EXECUTED
2005324: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
2005328: 40 00 0b 18 call 2007f88 <rtems_fatal_error_occurred> <== NOT EXECUTED
200532c: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
2005330: 7f ff f4 af call 20025ec <sparc_disable_interrupts> <== NOT EXECUTED
2005334: 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) {
2005338: c4 07 60 84 ld [ %i5 + 0x84 ], %g2
200533c: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2005340: 80 a0 80 01 cmp %g2, %g1
2005344: 32 bf ff f0 bne,a 2005304 <drainOutput.part.0+0x14> <== NEVER TAKEN
2005348: f8 27 60 94 st %i4, [ %i5 + 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);
200534c: 7f ff f4 ac call 20025fc <sparc_enable_interrupts>
2005350: 91 e8 00 08 restore %g0, %o0, %o0
02003ba4 <dup2>:
int dup2(
int fildes,
int fildes2
)
{
2003ba4: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
2003ba8: 90 10 00 18 mov %i0, %o0
int dup2(
int fildes,
int fildes2
)
{
2003bac: ba 10 00 18 mov %i0, %i5
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
2003bb0: 92 07 bf b8 add %fp, -72, %o1
2003bb4: 40 00 01 dd call 2004328 <fstat>
2003bb8: b0 10 3f ff mov -1, %i0
if ( status == -1 )
2003bbc: 80 a2 3f ff cmp %o0, -1
2003bc0: 02 80 00 0b be 2003bec <dup2+0x48>
2003bc4: 90 10 00 19 mov %i1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
2003bc8: 40 00 01 d8 call 2004328 <fstat>
2003bcc: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
2003bd0: 80 a2 3f ff cmp %o0, -1
2003bd4: 02 80 00 06 be 2003bec <dup2+0x48> <== NEVER TAKEN
2003bd8: 90 10 00 1d mov %i5, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
2003bdc: 92 10 20 00 clr %o1
2003be0: 40 00 00 ab call 2003e8c <fcntl>
2003be4: 94 10 00 19 mov %i1, %o2
2003be8: b0 10 00 08 mov %o0, %i0
}
2003bec: 81 c7 e0 08 ret
2003bf0: 81 e8 00 00 restore
0200604c <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
200604c: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
2006050: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
2006054: 80 88 62 00 btst 0x200, %g1
2006058: 02 80 00 19 be 20060bc <echo+0x70> <== NEVER TAKEN
200605c: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
2006060: 03 00 80 74 sethi %hi(0x201d000), %g1
2006064: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 201d1c0 <__ctype_ptr__>
2006068: 82 00 40 18 add %g1, %i0, %g1
200606c: c2 08 60 01 ldub [ %g1 + 1 ], %g1
2006070: 80 88 60 20 btst 0x20, %g1
2006074: 02 80 00 12 be 20060bc <echo+0x70>
2006078: 80 a6 20 09 cmp %i0, 9
200607c: 02 80 00 10 be 20060bc <echo+0x70>
2006080: 80 a6 20 0a cmp %i0, 0xa
2006084: 02 80 00 0e be 20060bc <echo+0x70>
2006088: 82 10 20 5e mov 0x5e, %g1
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
200608c: 90 1e 20 40 xor %i0, 0x40, %o0
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
2006090: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
2006094: d0 2f bf f9 stb %o0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
2006098: 92 10 20 02 mov 2, %o1
200609c: 90 07 bf f8 add %fp, -8, %o0
20060a0: 7f ff ff 40 call 2005da0 <rtems_termios_puts>
20060a4: 94 10 00 19 mov %i1, %o2
tty->column += 2;
20060a8: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
20060ac: 82 00 60 02 add %g1, 2, %g1
20060b0: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
20060b4: 81 c7 e0 08 ret
20060b8: 81 e8 00 00 restore
} else {
oproc (c, tty);
20060bc: 7f ff ff 82 call 2005ec4 <oproc>
20060c0: 92 10 00 19 mov %i1, %o1
20060c4: 81 c7 e0 08 ret
20060c8: 81 e8 00 00 restore
0202840c <endgrent>:
void endgrent(void)
{
if (group_fp != NULL)
202840c: 03 00 81 bb sethi %hi(0x206ec00), %g1
2028410: d0 00 61 20 ld [ %g1 + 0x120 ], %o0 ! 206ed20 <group_fp>
2028414: 80 a2 20 00 cmp %o0, 0
2028418: 02 80 00 05 be 202842c <endgrent+0x20> <== NEVER TAKEN
202841c: 01 00 00 00 nop
fclose(group_fp);
2028420: 82 13 c0 00 mov %o7, %g1
2028424: 40 00 66 71 call 2041de8 <fclose>
2028428: 9e 10 40 00 mov %g1, %o7
202842c: 81 c3 e0 08 retl <== NOT EXECUTED
02028278 <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
2028278: 03 00 81 bb sethi %hi(0x206ec00), %g1
202827c: d0 00 60 40 ld [ %g1 + 0x40 ], %o0 ! 206ec40 <passwd_fp>
2028280: 80 a2 20 00 cmp %o0, 0
2028284: 02 80 00 05 be 2028298 <endpwent+0x20> <== NEVER TAKEN
2028288: 01 00 00 00 nop
fclose(passwd_fp);
202828c: 82 13 c0 00 mov %o7, %g1
2028290: 40 00 66 d6 call 2041de8 <fclose>
2028294: 9e 10 40 00 mov %g1, %o7
2028298: 81 c3 e0 08 retl <== NOT EXECUTED
020060cc <erase>:
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
20060cc: 9d e3 bf a0 save %sp, -96, %sp
if (tty->ccount == 0)
20060d0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
20060d4: 80 a0 60 00 cmp %g1, 0
20060d8: 02 80 00 0a be 2006100 <erase+0x34>
20060dc: ba 10 00 18 mov %i0, %i5
return;
if (lineFlag) {
20060e0: 80 a6 60 00 cmp %i1, 0
20060e4: 02 80 00 76 be 20062bc <erase+0x1f0>
20060e8: 35 00 80 6e sethi %hi(0x201b800), %i2
if (!(tty->termios.c_lflag & ECHO)) {
20060ec: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
20060f0: 80 88 60 08 btst 8, %g1
20060f4: 32 80 00 05 bne,a 2006108 <erase+0x3c> <== ALWAYS TAKEN
20060f8: 80 88 60 10 btst 0x10, %g1
tty->ccount = 0;
20060fc: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
return;
2006100: 81 c7 e0 08 ret
2006104: 81 e8 00 00 restore
}
if (!(tty->termios.c_lflag & ECHOE)) {
2006108: 12 80 00 6d bne 20062bc <erase+0x1f0> <== ALWAYS TAKEN
200610c: 35 00 80 6e sethi %hi(0x201b800), %i2
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
2006110: d0 0e 20 44 ldub [ %i0 + 0x44 ], %o0 <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
2006114: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
2006118: 7f ff ff cd call 200604c <echo> <== NOT EXECUTED
200611c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
2006120: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
2006124: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006128: 02 bf ff f6 be 2006100 <erase+0x34> <== NOT EXECUTED
200612c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
2006130: 30 80 00 0e b,a 2006168 <erase+0x9c> <== NOT EXECUTED
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
2006134: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
2006138: 86 00 ff ff add %g3, -1, %g3
200613c: c6 27 60 20 st %g3, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
2006140: 80 88 60 08 btst 8, %g1
2006144: 02 80 00 59 be 20062a8 <erase+0x1dc> <== NEVER TAKEN
2006148: f8 09 00 03 ldub [ %g4 + %g3 ], %i4
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
200614c: 80 a6 60 00 cmp %i1, 0
2006150: 32 80 00 08 bne,a 2006170 <erase+0xa4>
2006154: b8 0f 20 ff and %i4, 0xff, %i4
2006158: 80 88 60 10 btst 0x10, %g1
200615c: 32 80 00 05 bne,a 2006170 <erase+0xa4> <== ALWAYS TAKEN
2006160: b8 0f 20 ff and %i4, 0xff, %i4
echo (tty->termios.c_cc[VERASE], tty);
2006164: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
2006168: 7f ff ff b9 call 200604c <echo> <== NOT EXECUTED
200616c: 93 e8 00 1d restore %g0, %i5, %o1 <== NOT EXECUTED
} else if (c == '\t') {
2006170: 80 a7 20 09 cmp %i4, 9
2006174: 32 80 00 28 bne,a 2006214 <erase+0x148>
2006178: c4 06 e1 c0 ld [ %i3 + 0x1c0 ], %g2
int col = tty->read_start_column;
200617c: 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)) {
2006180: da 06 e1 c0 ld [ %i3 + 0x1c0 ], %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;
2006184: 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)
2006188: 10 80 00 12 b 20061d0 <erase+0x104>
200618c: 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') {
2006190: 80 a3 e0 09 cmp %o7, 9
2006194: 12 80 00 04 bne 20061a4 <erase+0xd8>
2006198: 84 00 a0 01 inc %g2
col = (col | 7) + 1;
200619c: 10 80 00 0c b 20061cc <erase+0x100>
20061a0: b8 17 20 07 or %i4, 7, %i4
} else if (iscntrl (c)) {
20061a4: 9e 03 40 0f add %o5, %o7, %o7
20061a8: de 0b e0 01 ldub [ %o7 + 1 ], %o7
20061ac: 80 8b e0 20 btst 0x20, %o7
20061b0: 22 80 00 08 be,a 20061d0 <erase+0x104> <== ALWAYS TAKEN
20061b4: b8 07 20 01 inc %i4
if (tty->termios.c_lflag & ECHOCTL)
20061b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20061bc: 32 80 00 05 bne,a 20061d0 <erase+0x104> <== NOT EXECUTED
20061c0: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
20061c4: 10 80 00 04 b 20061d4 <erase+0x108> <== NOT EXECUTED
20061c8: 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++;
20061cc: b8 07 20 01 inc %i4
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
20061d0: 80 a0 80 03 cmp %g2, %g3
20061d4: 32 bf ff ef bne,a 2006190 <erase+0xc4>
20061d8: de 09 00 02 ldub [ %g4 + %g2 ], %o7
}
/*
* Back up over the tab
*/
while (tty->column > col) {
20061dc: 10 80 00 09 b 2006200 <erase+0x134>
20061e0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_termios_puts ("\b", 1, tty);
20061e4: 92 10 20 01 mov 1, %o1
20061e8: 7f ff fe ee call 2005da0 <rtems_termios_puts>
20061ec: 94 10 00 1d mov %i5, %o2
tty->column--;
20061f0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
20061f4: 82 00 7f ff add %g1, -1, %g1
20061f8: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
/*
* Back up over the tab
*/
while (tty->column > col) {
20061fc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006200: 80 a0 40 1c cmp %g1, %i4
2006204: 14 bf ff f8 bg 20061e4 <erase+0x118>
2006208: 90 10 00 18 mov %i0, %o0
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
200620c: 10 80 00 28 b 20062ac <erase+0x1e0>
2006210: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
2006214: b8 07 20 01 inc %i4
2006218: c4 08 80 1c ldub [ %g2 + %i4 ], %g2
200621c: 80 88 a0 20 btst 0x20, %g2
2006220: 22 80 00 10 be,a 2006260 <erase+0x194> <== ALWAYS TAKEN
2006224: c2 06 e1 c0 ld [ %i3 + 0x1c0 ], %g1
2006228: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
200622c: 02 80 00 0d be 2006260 <erase+0x194> <== NOT EXECUTED
2006230: c2 06 e1 c0 ld [ %i3 + 0x1c0 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
2006234: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2006238: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
200623c: 7f ff fe d9 call 2005da0 <rtems_termios_puts> <== NOT EXECUTED
2006240: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
2006244: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
2006248: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200624c: 22 80 00 05 be,a 2006260 <erase+0x194> <== NOT EXECUTED
2006250: c2 06 e1 c0 ld [ %i3 + 0x1c0 ], %g1 <== NOT EXECUTED
tty->column--;
2006254: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2006258: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
200625c: c2 06 e1 c0 ld [ %i3 + 0x1c0 ], %g1 <== NOT EXECUTED
2006260: c2 08 40 1c ldub [ %g1 + %i4 ], %g1
2006264: 80 88 60 20 btst 0x20, %g1
2006268: 02 80 00 07 be 2006284 <erase+0x1b8> <== ALWAYS TAKEN
200626c: 90 10 00 1a mov %i2, %o0
2006270: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
2006274: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
2006278: 02 80 00 0d be 20062ac <erase+0x1e0> <== NOT EXECUTED
200627c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
2006280: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2006284: 92 10 20 03 mov 3, %o1
2006288: 7f ff fe c6 call 2005da0 <rtems_termios_puts>
200628c: 94 10 00 1d mov %i5, %o2
if (tty->column)
2006290: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006294: 80 a0 60 00 cmp %g1, 0
2006298: 02 80 00 05 be 20062ac <erase+0x1e0> <== NEVER TAKEN
200629c: 80 a6 60 00 cmp %i1, 0
tty->column--;
20062a0: 82 00 7f ff add %g1, -1, %g1
20062a4: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
20062a8: 80 a6 60 00 cmp %i1, 0
20062ac: 32 80 00 09 bne,a 20062d0 <erase+0x204>
20062b0: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
20062b4: 81 c7 e0 08 ret
20062b8: 81 e8 00 00 restore
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
20062bc: 31 00 80 6e sethi %hi(0x201b800), %i0
20062c0: 37 00 80 74 sethi %hi(0x201d000), %i3
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);
20062c4: b4 16 a0 c0 or %i2, 0xc0, %i2
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
20062c8: b0 16 20 b8 or %i0, 0xb8, %i0
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
20062cc: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
20062d0: 80 a0 e0 00 cmp %g3, 0
20062d4: 32 bf ff 98 bne,a 2006134 <erase+0x68>
20062d8: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
20062dc: 81 c7 e0 08 ret
20062e0: 81 e8 00 00 restore
02025acc <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)
{
2025acc: 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)
2025ad0: c2 0e 20 7d ldub [ %i0 + 0x7d ], %g1
2025ad4: 80 a0 60 00 cmp %g1, 0
2025ad8: 32 80 00 15 bne,a 2025b2c <fat_buf_access+0x60>
2025adc: 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);
2025ae0: 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)
2025ae4: 80 a6 a0 01 cmp %i2, 1
2025ae8: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
2025aec: 12 80 00 06 bne 2025b04 <fat_buf_access+0x38>
2025af0: 94 06 20 80 add %i0, 0x80, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2025af4: 7f ff 81 de call 200626c <rtems_bdbuf_read>
2025af8: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
2025afc: 10 80 00 05 b 2025b10 <fat_buf_access+0x44>
2025b00: 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);
2025b04: 7f ff 81 b1 call 20061c8 <rtems_bdbuf_get>
2025b08: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
2025b0c: 80 a2 20 00 cmp %o0, 0
2025b10: 12 80 00 61 bne 2025c94 <fat_buf_access+0x1c8> <== NEVER TAKEN
2025b14: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
2025b18: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
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);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
2025b1c: f2 26 20 78 st %i1, [ %i0 + 0x78 ]
fs_info->c.modified = 0;
2025b20: c0 2e 20 7c clrb [ %i0 + 0x7c ]
fs_info->c.state = FAT_CACHE_ACTUAL;
2025b24: c2 2e 20 7d stb %g1, [ %i0 + 0x7d ]
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
2025b28: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2025b2c: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
2025b30: 80 a0 40 02 cmp %g1, %g2
2025b34: 0a 80 00 05 bcs 2025b48 <fat_buf_access+0x7c> <== NEVER TAKEN
2025b38: ba 10 20 00 clr %i5
2025b3c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
2025b40: 80 a0 40 02 cmp %g1, %g2
2025b44: 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)
2025b48: 80 a0 40 19 cmp %g1, %i1
2025b4c: 22 80 00 5b be,a 2025cb8 <fat_buf_access+0x1ec>
2025b50: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
{
if (fs_info->c.modified)
2025b54: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2025b58: 80 a0 60 00 cmp %g1, 0
2025b5c: 02 80 00 3b be 2025c48 <fat_buf_access+0x17c>
2025b60: 80 8f 60 ff btst 0xff, %i5
{
if (sec_of_fat && !fs_info->vol.mirror)
2025b64: 02 80 00 0b be 2025b90 <fat_buf_access+0xc4> <== ALWAYS TAKEN
2025b68: 01 00 00 00 nop
2025b6c: c2 0e 20 48 ldub [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
2025b70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2025b74: 12 80 00 07 bne 2025b90 <fat_buf_access+0xc4> <== NOT EXECUTED
2025b78: 01 00 00 00 nop <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
2025b7c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2025b80: d0 06 20 84 ld [ %i0 + 0x84 ], %o0 <== NOT EXECUTED
2025b84: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
2025b88: 40 00 7d 87 call 20451a4 <memcpy> <== NOT EXECUTED
2025b8c: d4 16 00 00 lduh [ %i0 ], %o2 <== NOT EXECUTED
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
2025b90: 7f ff 82 7a call 2006578 <rtems_bdbuf_release_modified>
2025b94: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
fs_info->c.state = FAT_CACHE_EMPTY;
2025b98: c0 2e 20 7d clrb [ %i0 + 0x7d ]
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
2025b9c: 80 a2 20 00 cmp %o0, 0
2025ba0: 12 80 00 3d bne 2025c94 <fat_buf_access+0x1c8> <== NEVER TAKEN
2025ba4: c0 2e 20 7c clrb [ %i0 + 0x7c ]
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
2025ba8: 80 8f 60 ff btst 0xff, %i5
2025bac: 02 80 00 2d be 2025c60 <fat_buf_access+0x194> <== ALWAYS TAKEN
2025bb0: 92 10 00 19 mov %i1, %o1
2025bb4: c2 0e 20 48 ldub [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
2025bb8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2025bbc: 02 80 00 1c be 2025c2c <fat_buf_access+0x160> <== NOT EXECUTED
2025bc0: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
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)
2025bc4: 10 80 00 28 b 2025c64 <fat_buf_access+0x198> <== NOT EXECUTED
2025bc8: 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,
2025bcc: 7f ff 74 7c call 2002dbc <.umul> <== NOT EXECUTED
2025bd0: f8 06 20 58 ld [ %i0 + 0x58 ], %i4 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dd,
2025bd4: d2 06 20 78 ld [ %i0 + 0x78 ], %o1 <== NOT EXECUTED
2025bd8: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
2025bdc: 92 02 00 09 add %o0, %o1, %o1 <== NOT EXECUTED
2025be0: 7f ff 81 7a call 20061c8 <rtems_bdbuf_get> <== NOT EXECUTED
2025be4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
2025be8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025bec: 12 80 00 0c bne 2025c1c <fat_buf_access+0x150> <== NOT EXECUTED
2025bf0: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
2025bf4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
2025bf8: d2 06 20 84 ld [ %i0 + 0x84 ], %o1 <== NOT EXECUTED
2025bfc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 <== NOT EXECUTED
2025c00: 40 00 7d 69 call 20451a4 <memcpy> <== NOT EXECUTED
2025c04: d4 16 00 00 lduh [ %i0 ], %o2 <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
2025c08: 7f ff 82 5c call 2006578 <rtems_bdbuf_release_modified> <== NOT EXECUTED
2025c0c: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
2025c10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025c14: 22 80 00 06 be,a 2025c2c <fat_buf_access+0x160> <== NOT EXECUTED
2025c18: ba 07 60 01 inc %i5 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
2025c1c: 40 00 70 21 call 2041ca0 <__errno> <== NOT EXECUTED
2025c20: 01 00 00 00 nop <== NOT EXECUTED
2025c24: 10 80 00 1f b 2025ca0 <fat_buf_access+0x1d4> <== NOT EXECUTED
2025c28: 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++)
2025c2c: c2 0e 20 09 ldub [ %i0 + 9 ], %g1 <== NOT EXECUTED
2025c30: 90 0f 60 ff and %i5, 0xff, %o0 <== NOT EXECUTED
2025c34: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED
2025c38: 2a bf ff e5 bcs,a 2025bcc <fat_buf_access+0x100> <== NOT EXECUTED
2025c3c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2025c40: 10 80 00 08 b 2025c60 <fat_buf_access+0x194> <== NOT EXECUTED
2025c44: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2025c48: 7f ff 82 13 call 2006494 <rtems_bdbuf_release>
2025c4c: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
2025c50: 80 a2 20 00 cmp %o0, 0
2025c54: 12 80 00 10 bne 2025c94 <fat_buf_access+0x1c8> <== NEVER TAKEN
2025c58: 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);
2025c5c: 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)
2025c60: 80 a6 a0 01 cmp %i2, 1
2025c64: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
2025c68: 12 80 00 06 bne 2025c80 <fat_buf_access+0x1b4>
2025c6c: 94 06 20 80 add %i0, 0x80, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2025c70: 7f ff 81 7f call 200626c <rtems_bdbuf_read>
2025c74: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
2025c78: 10 80 00 05 b 2025c8c <fat_buf_access+0x1c0>
2025c7c: 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);
2025c80: 7f ff 81 52 call 20061c8 <rtems_bdbuf_get>
2025c84: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
2025c88: 80 a2 20 00 cmp %o0, 0
2025c8c: 02 80 00 08 be 2025cac <fat_buf_access+0x1e0> <== ALWAYS TAKEN
2025c90: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
2025c94: 40 00 70 03 call 2041ca0 <__errno> <== NOT EXECUTED
2025c98: 01 00 00 00 nop <== NOT EXECUTED
2025c9c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2025ca0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2025ca4: 81 c7 e0 08 ret <== NOT EXECUTED
2025ca8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
fs_info->c.blk_num = blk;
2025cac: f2 26 20 78 st %i1, [ %i0 + 0x78 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
2025cb0: c2 2e 20 7d stb %g1, [ %i0 + 0x7d ]
}
*buf = fs_info->c.buf;
2025cb4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
2025cb8: c2 26 c0 00 st %g1, [ %i3 ]
return RC_OK;
}
2025cbc: 81 c7 e0 08 ret
2025cc0: 91 e8 20 00 restore %g0, 0, %o0
02025cc4 <fat_buf_release>:
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2025cc4: 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)
2025cc8: c2 0e 20 7d ldub [ %i0 + 0x7d ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2025ccc: 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)
2025cd0: 80 a0 60 00 cmp %g1, 0
2025cd4: 02 80 00 53 be 2025e20 <fat_buf_release+0x15c>
2025cd8: b0 10 20 00 clr %i0
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
2025cdc: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
2025ce0: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
2025ce4: 80 a0 40 02 cmp %g1, %g2
2025ce8: 0a 80 00 05 bcs 2025cfc <fat_buf_release+0x38> <== NEVER TAKEN
2025cec: b8 10 20 00 clr %i4
*buf = fs_info->c.buf;
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
2025cf0: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
2025cf4: 80 a0 40 02 cmp %g1, %g2
2025cf8: b8 40 20 00 addx %g0, 0, %i4
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
2025cfc: c2 0f 60 7c ldub [ %i5 + 0x7c ], %g1
2025d00: 80 a0 60 00 cmp %g1, 0
2025d04: 02 80 00 3a be 2025dec <fat_buf_release+0x128>
2025d08: 80 8f 20 ff btst 0xff, %i4
{
if (sec_of_fat && !fs_info->vol.mirror)
2025d0c: 02 80 00 0b be 2025d38 <fat_buf_release+0x74>
2025d10: 01 00 00 00 nop
2025d14: c2 0f 60 48 ldub [ %i5 + 0x48 ], %g1
2025d18: 80 a0 60 00 cmp %g1, 0
2025d1c: 12 80 00 07 bne 2025d38 <fat_buf_release+0x74> <== NEVER TAKEN
2025d20: 01 00 00 00 nop
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
2025d24: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2025d28: d0 07 60 84 ld [ %i5 + 0x84 ], %o0
2025d2c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2025d30: 40 00 7d 1d call 20451a4 <memcpy>
2025d34: d4 17 40 00 lduh [ %i5 ], %o2
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
2025d38: 7f ff 82 10 call 2006578 <rtems_bdbuf_release_modified>
2025d3c: d0 07 60 80 ld [ %i5 + 0x80 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2025d40: 80 a2 20 00 cmp %o0, 0
2025d44: 12 80 00 2f bne 2025e00 <fat_buf_release+0x13c> <== NEVER TAKEN
2025d48: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
2025d4c: 80 8f 20 ff btst 0xff, %i4
2025d50: 02 80 00 32 be 2025e18 <fat_buf_release+0x154>
2025d54: c0 2f 60 7c clrb [ %i5 + 0x7c ]
2025d58: c2 0f 60 48 ldub [ %i5 + 0x48 ], %g1
2025d5c: 80 a0 60 00 cmp %g1, 0
2025d60: 02 80 00 1c be 2025dd0 <fat_buf_release+0x10c> <== ALWAYS TAKEN
2025d64: 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;
2025d68: 10 80 00 2d b 2025e1c <fat_buf_release+0x158> <== NOT EXECUTED
2025d6c: 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,
2025d70: 7f ff 74 13 call 2002dbc <.umul>
2025d74: 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,
2025d78: d2 07 60 78 ld [ %i5 + 0x78 ], %o1
2025d7c: 94 07 bf fc add %fp, -4, %o2
2025d80: 92 02 00 09 add %o0, %o1, %o1
2025d84: 7f ff 81 11 call 20061c8 <rtems_bdbuf_get>
2025d88: 90 10 00 1b mov %i3, %o0
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
2025d8c: 80 a2 20 00 cmp %o0, 0
2025d90: 12 80 00 0c bne 2025dc0 <fat_buf_release+0xfc> <== NEVER TAKEN
2025d94: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
2025d98: c2 07 bf fc ld [ %fp + -4 ], %g1
2025d9c: d2 07 60 84 ld [ %i5 + 0x84 ], %o1
2025da0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2025da4: 40 00 7d 00 call 20451a4 <memcpy>
2025da8: d4 17 40 00 lduh [ %i5 ], %o2
sc = rtems_bdbuf_release_modified(b);
2025dac: 7f ff 81 f3 call 2006578 <rtems_bdbuf_release_modified>
2025db0: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
2025db4: 80 a2 20 00 cmp %o0, 0
2025db8: 22 80 00 06 be,a 2025dd0 <fat_buf_release+0x10c> <== ALWAYS TAKEN
2025dbc: b8 07 20 01 inc %i4
rtems_set_errno_and_return_minus_one(ENOMEM);
2025dc0: 40 00 6f b8 call 2041ca0 <__errno> <== NOT EXECUTED
2025dc4: 01 00 00 00 nop <== NOT EXECUTED
2025dc8: 10 80 00 11 b 2025e0c <fat_buf_release+0x148> <== NOT EXECUTED
2025dcc: 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++)
2025dd0: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
2025dd4: 90 0f 20 ff and %i4, 0xff, %o0
2025dd8: 80 a2 00 01 cmp %o0, %g1
2025ddc: 2a bf ff e5 bcs,a 2025d70 <fat_buf_release+0xac>
2025de0: 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;
2025de4: 10 80 00 0e b 2025e1c <fat_buf_release+0x158>
2025de8: c0 2f 60 7d clrb [ %i5 + 0x7d ]
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2025dec: 7f ff 81 aa call 2006494 <rtems_bdbuf_release>
2025df0: d0 07 60 80 ld [ %i5 + 0x80 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2025df4: 80 a2 20 00 cmp %o0, 0
2025df8: 22 80 00 09 be,a 2025e1c <fat_buf_release+0x158> <== ALWAYS TAKEN
2025dfc: c0 2f 60 7d clrb [ %i5 + 0x7d ]
rtems_set_errno_and_return_minus_one(EIO);
2025e00: 40 00 6f a8 call 2041ca0 <__errno> <== NOT EXECUTED
2025e04: 01 00 00 00 nop <== NOT EXECUTED
2025e08: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2025e0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2025e10: 81 c7 e0 08 ret <== NOT EXECUTED
2025e14: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
2025e18: c0 2f 60 7d clrb [ %i5 + 0x7d ]
return RC_OK;
2025e1c: b0 10 20 00 clr %i0
}
2025e20: 81 c7 e0 08 ret
2025e24: 81 e8 00 00 restore
02024d6c <fat_cluster_num_to_sector_num>:
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2024d6c: 80 a2 60 00 cmp %o1, 0
2024d70: 12 80 00 08 bne 2024d90 <fat_cluster_num_to_sector_num+0x24>
2024d74: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
2024d78: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
2024d7c: 80 88 a0 03 btst 3, %g2
2024d80: 22 80 00 05 be,a 2024d94 <fat_cluster_num_to_sector_num+0x28><== NEVER TAKEN
2024d84: c4 08 60 05 ldub [ %g1 + 5 ], %g2 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2024d88: 81 c3 e0 08 retl
2024d8c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2024d90: c4 08 60 05 ldub [ %g1 + 5 ], %g2
2024d94: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
2024d98: 90 02 7f fe add %o1, -2, %o0
2024d9c: 91 2a 00 02 sll %o0, %g2, %o0
fs_info->vol.data_fsec);
}
2024da0: 81 c3 e0 08 retl
2024da4: 90 02 00 01 add %o0, %g1, %o0
02025f58 <fat_cluster_read>:
fat_cluster_read(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
2025f58: 98 10 00 0a mov %o2, %o4 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2025f5c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2025f60: 12 80 00 08 bne 2025f80 <fat_cluster_read+0x28> <== NOT EXECUTED
2025f64: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
2025f68: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 <== NOT EXECUTED
2025f6c: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
2025f70: 22 80 00 05 be,a 2025f84 <fat_cluster_read+0x2c> <== NOT EXECUTED
2025f74: c4 08 60 05 ldub [ %g1 + 5 ], %g2 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2025f78: 10 80 00 07 b 2025f94 <fat_cluster_read+0x3c> <== NOT EXECUTED
2025f7c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2025f80: c4 08 60 05 ldub [ %g1 + 5 ], %g2 <== NOT EXECUTED
2025f84: 92 02 7f fe add %o1, -2, %o1 <== NOT EXECUTED
2025f88: 93 2a 40 02 sll %o1, %g2, %o1 <== NOT EXECUTED
2025f8c: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 <== NOT EXECUTED
2025f90: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
2025f94: d6 08 60 04 ldub [ %g1 + 4 ], %o3 <== NOT EXECUTED
2025f98: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
2025f9c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2025fa0: 97 2a c0 01 sll %o3, %g1, %o3 <== NOT EXECUTED
2025fa4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2025fa8: 7f ff ff a0 call 2025e28 <_fat_block_read> <== NOT EXECUTED
2025fac: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02025fb0 <fat_cluster_write>:
fat_cluster_write(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
const void *buff
)
{
2025fb0: 98 10 00 0a mov %o2, %o4
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2025fb4: 80 a2 60 00 cmp %o1, 0
2025fb8: 12 80 00 08 bne 2025fd8 <fat_cluster_write+0x28> <== ALWAYS TAKEN
2025fbc: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
2025fc0: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 <== NOT EXECUTED
2025fc4: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
2025fc8: 22 80 00 05 be,a 2025fdc <fat_cluster_write+0x2c> <== NOT EXECUTED
2025fcc: c4 08 60 05 ldub [ %g1 + 5 ], %g2 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2025fd0: 10 80 00 07 b 2025fec <fat_cluster_write+0x3c> <== NOT EXECUTED
2025fd4: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2025fd8: c4 08 60 05 ldub [ %g1 + 5 ], %g2
2025fdc: 92 02 7f fe add %o1, -2, %o1
2025fe0: 93 2a 40 02 sll %o1, %g2, %o1
2025fe4: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
2025fe8: 92 02 40 02 add %o1, %g2, %o1
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_write(mt_entry, fsec, 0,
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
2025fec: d6 08 60 04 ldub [ %g1 + 4 ], %o3
2025ff0: c2 08 60 02 ldub [ %g1 + 2 ], %g1
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_write(mt_entry, fsec, 0,
2025ff4: 94 10 20 00 clr %o2
2025ff8: 97 2a c0 01 sll %o3, %g1, %o3
2025ffc: 82 13 c0 00 mov %o7, %g1
2026000: 7f ff ff ac call 2025eb0 <_fat_block_write>
2026004: 9e 10 40 00 mov %g1, %o7
020261d4 <fat_fat32_update_fsinfo_sector>:
fat_fat32_update_fsinfo_sector(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t free_count,
uint32_t next_free
)
{
20261d4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
20261d8: fa 06 20 20 ld [ %i0 + 0x20 ], %i5 <== NOT EXECUTED
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
20261dc: 7f ff fe 30 call 2025a9c <CPU_swap_u32> <== NOT EXECUTED
20261e0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20261e4: d0 27 bf f8 st %o0, [ %fp + -8 ] <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
20261e8: 7f ff fe 2d call 2025a9c <CPU_swap_u32> <== NOT EXECUTED
20261ec: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
20261f0: d2 17 60 3c lduh [ %i5 + 0x3c ], %o1 <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
20261f4: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
20261f8: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
20261fc: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2026200: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED
2026204: 7f ff ff 2b call 2025eb0 <_fat_block_write> <== NOT EXECUTED
2026208: 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(mt_entry,
202620c: d2 17 60 3c lduh [ %i5 + 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(mt_entry,
2026210: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
2026214: 94 10 21 ec mov 0x1ec, %o2 <== NOT EXECUTED
2026218: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
202621c: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2026220: 7f ff ff 24 call 2025eb0 <_fat_block_write> <== NOT EXECUTED
2026224: 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) )
2026228: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202622c: 06 80 00 04 bl 202623c <fat_fat32_update_fsinfo_sector+0x68><== NOT EXECUTED
2026230: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2026234: 16 80 00 03 bge 2026240 <fat_fat32_update_fsinfo_sector+0x6c><== NOT EXECUTED
2026238: b0 10 20 00 clr %i0 <== NOT EXECUTED
return -1;
202623c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
2026240: 81 c7 e0 08 ret <== NOT EXECUTED
2026244: 81 e8 00 00 restore <== NOT EXECUTED
02025328 <fat_file_close>:
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
2025328: 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)
202532c: c2 06 60 08 ld [ %i1 + 8 ], %g1
2025330: 80 a0 60 01 cmp %g1, 1
2025334: 08 80 00 06 bleu 202534c <fat_file_close+0x24>
2025338: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
{
fat_fd->links_num--;
202533c: 82 00 7f ff add %g1, -1, %g1
return rc;
2025340: 90 10 20 00 clr %o0
2025344: 10 80 00 25 b 20253d8 <fat_file_close+0xb0>
2025348: c2 26 60 08 st %g1, [ %i1 + 8 ]
}
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
202534c: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
2025350: 80 88 60 01 btst 1, %g1
2025354: 02 80 00 14 be 20253a4 <fat_file_close+0x7c>
2025358: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_truncate(mt_entry, fat_fd, 0);
202535c: 92 10 00 19 mov %i1, %o1
2025360: 7f ff ff ae call 2025218 <fat_file_truncate>
2025364: 94 10 20 00 clr %o2
if ( rc != RC_OK )
2025368: 80 a2 20 00 cmp %o0, 0
202536c: 12 80 00 1b bne 20253d8 <fat_file_close+0xb0> <== NEVER TAKEN
2025370: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2025374: 7f ff a2 c3 call 200de80 <_Chain_Extract>
2025378: 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(mt_entry, fat_fd->ino) )
202537c: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2025380: 40 00 03 90 call 20261c0 <fat_ino_is_unique>
2025384: 90 10 00 18 mov %i0, %o0
2025388: 80 8a 20 ff btst 0xff, %o0
202538c: 02 80 00 0f be 20253c8 <fat_file_close+0xa0> <== ALWAYS TAKEN
2025390: 01 00 00 00 nop
fat_free_unique_ino(mt_entry, fat_fd->ino);
2025394: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
2025398: 40 00 03 7e call 2026190 <fat_free_unique_ino> <== NOT EXECUTED
202539c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20253a0: 30 80 00 0a b,a 20253c8 <fat_file_close+0xa0> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
20253a4: 40 00 03 87 call 20261c0 <fat_ino_is_unique>
20253a8: d2 06 60 0c ld [ %i1 + 0xc ], %o1
20253ac: 80 8a 20 ff btst 0xff, %o0
20253b0: 02 80 00 04 be 20253c0 <fat_file_close+0x98> <== ALWAYS TAKEN
20253b4: 01 00 00 00 nop
{
fat_fd->links_num = 0;
20253b8: 10 80 00 06 b 20253d0 <fat_file_close+0xa8> <== NOT EXECUTED
20253bc: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
20253c0: 7f ff a2 b0 call 200de80 <_Chain_Extract>
20253c4: 90 10 00 19 mov %i1, %o0
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
20253c8: 7f ff 8c ec call 2008778 <free>
20253cc: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
20253d0: 40 00 02 3d call 2025cc4 <fat_buf_release>
20253d4: 91 e8 00 1c restore %g0, %i4, %o0
return rc;
}
20253d8: 81 c7 e0 08 ret
20253dc: 91 e8 00 08 restore %g0, %o0, %o0
020258fc <fat_file_datasync>:
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
20258fc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
2025900: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
2025904: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
2025908: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
202590c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
2025910: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
2025914: f8 06 20 20 ld [ %i0 + 0x20 ], %i4 <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
2025918: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
202591c: 02 80 00 07 be 2025938 <fat_file_datasync+0x3c> <== NOT EXECUTED
2025920: b0 10 20 00 clr %i0 <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
2025924: 40 00 00 e8 call 2025cc4 <fat_buf_release> <== NOT EXECUTED
2025928: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (rc != RC_OK)
202592c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2025930: 02 80 00 24 be 20259c0 <fat_file_datasync+0xc4> <== NOT EXECUTED
2025934: d2 07 bf f8 ld [ %fp + -8 ], %o1 <== NOT EXECUTED
2025938: 81 c7 e0 08 ret <== NOT EXECUTED
202593c: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
2025940: 7f ff fd 0b call 2024d6c <fat_cluster_num_to_sector_num> <== NOT EXECUTED
2025944: b6 10 20 00 clr %i3 <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
2025948: 10 80 00 13 b 2025994 <fat_file_datasync+0x98> <== NOT EXECUTED
202594c: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dd, (sec + i), &block);
2025950: 92 06 c0 1a add %i3, %i2, %o1 <== NOT EXECUTED
2025954: 7f ff 82 46 call 200626c <rtems_bdbuf_read> <== NOT EXECUTED
2025958: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
202595c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025960: 12 80 00 07 bne 202597c <fat_file_datasync+0x80> <== NOT EXECUTED
2025964: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
2025968: 7f ff 83 28 call 2006608 <rtems_bdbuf_sync> <== NOT EXECUTED
202596c: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
2025970: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025974: 22 80 00 08 be,a 2025994 <fat_file_datasync+0x98> <== NOT EXECUTED
2025978: b6 06 e0 01 inc %i3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
202597c: 40 00 70 c9 call 2041ca0 <__errno> <== NOT EXECUTED
2025980: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2025984: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2025988: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
202598c: 81 c7 e0 08 ret <== NOT EXECUTED
2025990: 81 e8 00 00 restore <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
2025994: c2 0f 20 04 ldub [ %i4 + 4 ], %g1 <== NOT EXECUTED
2025998: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
202599c: 2a bf ff ed bcs,a 2025950 <fat_file_datasync+0x54> <== NOT EXECUTED
20259a0: d0 07 20 58 ld [ %i4 + 0x58 ], %o0 <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
20259a4: d2 07 bf f8 ld [ %fp + -8 ], %o1 <== NOT EXECUTED
20259a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20259ac: 40 00 5e b7 call 203d488 <fat_get_fat_cluster> <== NOT EXECUTED
20259b0: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
20259b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20259b8: 12 80 00 0a bne 20259e0 <fat_file_datasync+0xe4> <== NOT EXECUTED
20259bc: d2 07 bf f8 ld [ %fp + -8 ], %o1 <== NOT EXECUTED
rc = fat_buf_release(fs_info);
if (rc != RC_OK)
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
20259c0: c4 07 20 0c ld [ %i4 + 0xc ], %g2 <== NOT EXECUTED
20259c4: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 <== NOT EXECUTED
20259c8: 84 0a 40 02 and %o1, %g2, %g2 <== NOT EXECUTED
20259cc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20259d0: 0a bf ff dc bcs 2025940 <fat_file_datasync+0x44> <== NOT EXECUTED
20259d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20259d8: 81 c7 e0 08 ret <== NOT EXECUTED
20259dc: 81 e8 00 00 restore <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
20259e0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
return rc;
}
20259e4: 81 c7 e0 08 ret <== NOT EXECUTED
20259e8: 81 e8 00 00 restore <== NOT EXECUTED
020254b4 <fat_file_extend>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
20254b4: 9d e3 bf 90 save %sp, -112, %sp
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
20254b8: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
uint32_t old_last_cl;
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
20254bc: f4 26 c0 00 st %i2, [ %i3 ]
if (new_length <= fat_fd->fat_file_size)
20254c0: e4 06 60 18 ld [ %i1 + 0x18 ], %l2
uint32_t *a_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
20254c4: 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;
20254c8: c0 27 bf f8 clr [ %fp + -8 ]
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
20254cc: ba 10 00 18 mov %i0, %i5
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
20254d0: 80 a6 80 12 cmp %i2, %l2
20254d4: 08 80 00 2d bleu 2025588 <fat_file_extend+0xd4>
20254d8: b0 10 20 00 clr %i0
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
20254dc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20254e0: 80 a0 60 01 cmp %g1, 1
20254e4: 32 80 00 0b bne,a 2025510 <fat_file_extend+0x5c> <== ALWAYS TAKEN
20254e8: c4 17 20 06 lduh [ %i4 + 6 ], %g2
20254ec: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
20254f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20254f4: 32 80 00 07 bne,a 2025510 <fat_file_extend+0x5c> <== NOT EXECUTED
20254f8: c4 17 20 06 lduh [ %i4 + 6 ], %g2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
20254fc: c2 0f 20 0a ldub [ %i4 + 0xa ], %g1 <== 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)) &&
2025500: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2025504: 12 80 00 1d bne 2025578 <fat_file_extend+0xc4> <== NOT EXECUTED
2025508: 01 00 00 00 nop <== 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))) &
202550c: c4 17 20 06 lduh [ %i4 + 6 ], %g2 <== NOT EXECUTED
2025510: 82 00 bf ff add %g2, -1, %g1
2025514: a0 08 40 12 and %g1, %l2, %l0
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
2025518: a4 26 80 12 sub %i2, %l2, %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 -
202551c: a0 20 80 10 sub %g2, %l0, %l0
2025520: a0 0c 00 01 and %l0, %g1, %l0
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
if (bytes2add > bytes_remain)
2025524: 80 a4 80 10 cmp %l2, %l0
2025528: 08 80 00 18 bleu 2025588 <fat_file_extend+0xd4>
202552c: b0 10 20 00 clr %i0
/*
* 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)
2025530: a4 a4 80 10 subcc %l2, %l0, %l2
2025534: 02 80 00 15 be 2025588 <fat_file_extend+0xd4> <== NEVER TAKEN
2025538: a2 04 bf ff add %l2, -1, %l1
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
202553c: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
2025540: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2025544: a3 34 40 01 srl %l1, %g1, %l1
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
2025548: 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;
202554c: a2 04 60 01 inc %l1
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
2025550: 96 07 bf fc add %fp, -4, %o3
2025554: 94 10 00 11 mov %l1, %o2
2025558: 40 00 61 1b call 203d9c4 <fat_scan_fat_for_free_clusters>
202555c: 98 07 bf f8 add %fp, -8, %o4
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
2025560: b0 92 20 00 orcc %o0, 0, %i0
2025564: 12 80 00 09 bne 2025588 <fat_file_extend+0xd4> <== NEVER TAKEN
2025568: 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))
202556c: 80 94 00 01 orcc %l0, %g1, %g0
2025570: 12 80 00 08 bne 2025590 <fat_file_extend+0xdc> <== ALWAYS TAKEN
2025574: 80 a4 40 01 cmp %l1, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
2025578: 40 00 71 ca call 2041ca0 <__errno> <== NOT EXECUTED
202557c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2025580: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
2025584: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2025588: 81 c7 e0 08 ret
202558c: 81 e8 00 00 restore
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
2025590: 02 80 00 0b be 20255bc <fat_file_extend+0x108> <== ALWAYS TAKEN
2025594: 82 38 00 01 xnor %g0, %g1, %g1
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
2025598: c4 0f 20 08 ldub [ %i4 + 8 ], %g2 <== NOT EXECUTED
202559c: a2 00 40 11 add %g1, %l1, %l1 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
20255a0: c2 17 20 06 lduh [ %i4 + 6 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
20255a4: a3 2c 40 02 sll %l1, %g2, %l1 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
20255a8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
20255ac: a2 26 80 11 sub %i2, %l1, %l1 <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
20255b0: a4 0c 80 01 and %l2, %g1, %l2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
20255b4: a4 24 40 12 sub %l1, %l2, %l2 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
20255b8: e4 26 c0 00 st %l2, [ %i3 ] <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
20255bc: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
20255c0: 80 a2 e0 00 cmp %o3, 0
20255c4: 32 80 00 07 bne,a 20255e0 <fat_file_extend+0x12c>
20255c8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
20255cc: c2 07 bf f0 ld [ %fp + -16 ], %g1
fat_fd->map.file_cln = 0;
20255d0: c0 26 60 34 clr [ %i1 + 0x34 ]
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
20255d4: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
20255d8: 10 80 00 1d b 202564c <fat_file_extend+0x198>
20255dc: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
20255e0: 80 a0 7f ff cmp %g1, -1
20255e4: 02 80 00 04 be 20255f4 <fat_file_extend+0x140> <== NEVER TAKEN
20255e8: 90 10 00 1d mov %i5, %o0
{
old_last_cl = fat_fd->map.last_cln;
20255ec: 10 80 00 0a b 2025614 <fat_file_extend+0x160>
20255f0: c2 27 bf f4 st %g1, [ %fp + -12 ]
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
20255f4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20255f8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
20255fc: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
2025600: 7f ff ff 78 call 20253e0 <fat_file_ioctl> <== NOT EXECUTED
2025604: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
2025608: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
202560c: 12 80 00 09 bne 2025630 <fat_file_extend+0x17c> <== NOT EXECUTED
2025610: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
2025614: d2 07 bf f4 ld [ %fp + -12 ], %o1
2025618: d4 07 bf f0 ld [ %fp + -16 ], %o2
202561c: 40 00 60 0b call 203d648 <fat_set_fat_cluster>
2025620: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
2025624: b6 92 20 00 orcc %o0, 0, %i3
2025628: 02 80 00 07 be 2025644 <fat_file_extend+0x190> <== ALWAYS TAKEN
202562c: d2 07 bf f0 ld [ %fp + -16 ], %o1
{
fat_free_fat_clusters_chain(mt_entry, chain);
2025630: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2025634: 40 00 60 b4 call 203d904 <fat_free_fat_clusters_chain> <== NOT EXECUTED
2025638: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED
return rc;
202563c: 81 c7 e0 08 ret <== NOT EXECUTED
2025640: 81 e8 00 00 restore <== NOT EXECUTED
}
fat_buf_release(fs_info);
2025644: 40 00 01 a0 call 2025cc4 <fat_buf_release>
2025648: 90 10 00 1c mov %i4, %o0
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
202564c: c2 07 bf fc ld [ %fp + -4 ], %g1
2025650: 80 a0 60 00 cmp %g1, 0
2025654: 22 bf ff cd be,a 2025588 <fat_file_extend+0xd4> <== NEVER TAKEN
2025658: f4 26 60 18 st %i2, [ %i1 + 0x18 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
202565c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2025660: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
2025664: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2025668: 80 a0 60 00 cmp %g1, 0
202566c: 32 bf ff c7 bne,a 2025588 <fat_file_extend+0xd4>
2025670: f4 26 60 18 st %i2, [ %i1 + 0x18 ]
{
rc = fat_init_clusters_chain(mt_entry, chain);
2025674: d2 07 bf f0 ld [ %fp + -16 ], %o1
2025678: 40 00 02 64 call 2026008 <fat_init_clusters_chain>
202567c: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
2025680: b8 92 20 00 orcc %o0, 0, %i4
2025684: 22 bf ff c1 be,a 2025588 <fat_file_extend+0xd4> <== ALWAYS TAKEN
2025688: f4 26 60 18 st %i2, [ %i1 + 0x18 ]
{
fat_free_fat_clusters_chain(mt_entry, chain);
202568c: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
2025690: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2025694: 40 00 60 9c call 203d904 <fat_free_fat_clusters_chain> <== NOT EXECUTED
2025698: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
return rc;
202569c: 81 c7 e0 08 ret <== NOT EXECUTED
20256a0: 81 e8 00 00 restore <== NOT EXECUTED
020253e0 <fat_file_ioctl>:
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
20253e0: 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);
20253e4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
20253e8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
20253ec: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
20253f0: 84 07 a0 50 add %fp, 0x50, %g2
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
20253f4: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
20253f8: c4 27 bf fc st %g2, [ %fp + -4 ]
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
20253fc: 90 10 00 18 mov %i0, %o0
2025400: 92 10 00 19 mov %i1, %o1
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
2025404: 80 a6 a0 01 cmp %i2, 1
2025408: 12 80 00 24 bne 2025498 <fat_file_ioctl+0xb8> <== NEVER TAKEN
202540c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
2025410: 84 07 a0 58 add %fp, 0x58, %g2
2025414: c4 27 bf fc st %g2, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
2025418: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
va_start(ap, cmd);
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
202541c: 82 10 00 1b mov %i3, %g1
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
2025420: 80 a6 c0 02 cmp %i3, %g2
2025424: 0a 80 00 06 bcs 202543c <fat_file_ioctl+0x5c> <== ALWAYS TAKEN
2025428: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
202542c: 40 00 72 1d call 2041ca0 <__errno> <== NOT EXECUTED
2025430: 01 00 00 00 nop <== NOT EXECUTED
2025434: 10 80 00 1c b 20254a4 <fat_file_ioctl+0xc4> <== NOT EXECUTED
2025438: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
202543c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2025440: 80 a0 a0 01 cmp %g2, 1
2025444: 32 80 00 0d bne,a 2025478 <fat_file_ioctl+0x98>
2025448: d4 08 e0 08 ldub [ %g3 + 8 ], %o2
202544c: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
2025450: 80 a0 a0 00 cmp %g2, 0
2025454: 32 80 00 09 bne,a 2025478 <fat_file_ioctl+0x98> <== NEVER TAKEN
2025458: d4 08 e0 08 ldub [ %g3 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
202545c: c4 08 e0 0a ldub [ %g3 + 0xa ], %g2
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)) &&
2025460: 80 88 a0 03 btst 3, %g2
2025464: 22 80 00 05 be,a 2025478 <fat_file_ioctl+0x98> <== NEVER TAKEN
2025468: d4 08 e0 08 ldub [ %g3 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
202546c: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
2025470: 10 80 00 0f b 20254ac <fat_file_ioctl+0xcc>
2025474: 92 10 20 00 clr %o1
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
2025478: 96 07 bf f8 add %fp, -8, %o3
202547c: 7f ff fe 7a call 2024e64 <fat_file_lseek>
2025480: 95 30 40 0a srl %g1, %o2, %o2
if ( rc != RC_OK )
2025484: 80 a2 60 00 cmp %o1, 0
2025488: 12 80 00 09 bne 20254ac <fat_file_ioctl+0xcc> <== NEVER TAKEN
202548c: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
break;
2025490: 10 80 00 07 b 20254ac <fat_file_ioctl+0xcc>
2025494: c2 27 40 00 st %g1, [ %i5 ]
default:
errno = EINVAL;
2025498: 40 00 72 02 call 2041ca0 <__errno> <== NOT EXECUTED
202549c: 01 00 00 00 nop <== NOT EXECUTED
20254a0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
20254a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
20254a8: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
20254ac: 81 c7 e0 08 ret
20254b0: 91 e8 00 09 restore %g0, %o1, %o0
02024e64 <fat_file_lseek>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
2024e64: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
2024e68: f8 06 60 34 ld [ %i1 + 0x34 ], %i4
2024e6c: 80 a6 80 1c cmp %i2, %i4
2024e70: 12 80 00 07 bne 2024e8c <fat_file_lseek+0x28> <== NEVER TAKEN
2024e74: 01 00 00 00 nop
*disk_cln = fat_fd->map.disk_cln;
2024e78: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
2024e7c: b0 10 20 00 clr %i0
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
2024e80: c2 26 c0 00 st %g1, [ %i3 ]
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
2024e84: 81 c7 e0 08 ret
2024e88: 93 e8 20 00 restore %g0, 0, %o1
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
2024e8c: 28 80 00 06 bleu,a 2024ea4 <fat_file_lseek+0x40> <== NOT EXECUTED
2024e90: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
{
cur_cln = fat_fd->map.disk_cln;
2024e94: c2 06 60 38 ld [ %i1 + 0x38 ], %g1 <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
2024e98: b8 26 80 1c sub %i2, %i4, %i4 <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
2024e9c: 10 80 00 04 b 2024eac <fat_file_lseek+0x48> <== NOT EXECUTED
2024ea0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
2024ea4: b8 10 00 1a mov %i2, %i4 <== NOT EXECUTED
2024ea8: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
2024eac: 10 80 00 0b b 2024ed8 <fat_file_lseek+0x74> <== NOT EXECUTED
2024eb0: ba 10 20 00 clr %i5 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
2024eb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024eb8: 40 00 61 74 call 203d488 <fat_get_fat_cluster> <== NOT EXECUTED
2024ebc: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
2024ec0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024ec4: 22 80 00 05 be,a 2024ed8 <fat_file_lseek+0x74> <== NOT EXECUTED
2024ec8: ba 07 60 01 inc %i5 <== NOT EXECUTED
return rc;
2024ecc: b1 3a 20 1f sra %o0, 0x1f, %i0 <== NOT EXECUTED
2024ed0: 81 c7 e0 08 ret <== NOT EXECUTED
2024ed4: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
2024ed8: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
2024edc: 12 bf ff f6 bne 2024eb4 <fat_file_lseek+0x50> <== NOT EXECUTED
2024ee0: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
2024ee4: f4 26 60 34 st %i2, [ %i1 + 0x34 ] <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
2024ee8: d2 26 60 38 st %o1, [ %i1 + 0x38 ] <== NOT EXECUTED
*disk_cln = cur_cln;
2024eec: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
}
return RC_OK;
2024ef0: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
2024ef4: 81 c7 e0 08 ret <== NOT EXECUTED
2024ef8: 93 e8 20 00 restore %g0, 0, %o1 <== NOT EXECUTED
02024efc <fat_file_open>:
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
2024efc: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
2024f00: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
2024f04: 90 10 00 18 mov %i0, %o0
2024f08: 92 10 00 19 mov %i1, %o1
2024f0c: 7f ff ff a7 call 2024da8 <fat_construct_key>
2024f10: c0 27 bf fc clr [ %fp + -4 ]
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
2024f14: d2 06 e0 60 ld [ %i3 + 0x60 ], %o1
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
2024f18: b8 10 00 08 mov %o0, %i4
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
2024f1c: ba 10 00 18 mov %i0, %i5
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
2024f20: 90 10 00 18 mov %i0, %o0
2024f24: 94 10 00 1c mov %i4, %o2
2024f28: 96 10 20 00 clr %o3
2024f2c: 7f ff ff b1 call 2024df0 <_hash_search>
2024f30: 98 07 bf fc add %fp, -4, %o4
if ( rc == RC_OK )
2024f34: b0 92 20 00 orcc %o0, 0, %i0
2024f38: 12 80 00 08 bne 2024f58 <fat_file_open+0x5c>
2024f3c: c2 07 bf fc ld [ %fp + -4 ], %g1
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
lfat_fd->links_num++;
2024f40: c4 00 60 08 ld [ %g1 + 8 ], %g2
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
2024f44: c2 26 80 00 st %g1, [ %i2 ]
lfat_fd->links_num++;
2024f48: 84 00 a0 01 inc %g2
2024f4c: c4 20 60 08 st %g2, [ %g1 + 8 ]
return rc;
2024f50: 81 c7 e0 08 ret
2024f54: 81 e8 00 00 restore
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
2024f58: d2 06 e0 64 ld [ %i3 + 0x64 ], %o1
2024f5c: 94 10 00 1c mov %i4, %o2
2024f60: 96 10 00 1c mov %i4, %o3
2024f64: 98 07 bf fc add %fp, -4, %o4
2024f68: 7f ff ff a2 call 2024df0 <_hash_search>
2024f6c: 90 10 00 1d mov %i5, %o0
2024f70: a0 10 00 08 mov %o0, %l0
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
2024f74: 7f ff 8f 81 call 2008d78 <malloc>
2024f78: 90 10 20 44 mov 0x44, %o0
2024f7c: d0 26 80 00 st %o0, [ %i2 ]
2024f80: d0 27 bf fc st %o0, [ %fp + -4 ]
if ( lfat_fd == NULL )
2024f84: 80 a2 20 00 cmp %o0, 0
2024f88: 02 80 00 1f be 2025004 <fat_file_open+0x108> <== NEVER TAKEN
2024f8c: b0 10 00 08 mov %o0, %i0
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
2024f90: 92 10 20 00 clr %o1
2024f94: 40 00 81 10 call 20453d4 <memset>
2024f98: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
2024f9c: 82 10 20 01 mov 1, %g1
2024fa0: c2 26 20 08 st %g1, [ %i0 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
2024fa4: c2 0e 20 30 ldub [ %i0 + 0x30 ], %g1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
2024fa8: 90 06 20 20 add %i0, 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;
2024fac: 82 08 7f fe and %g1, -2, %g1
2024fb0: c2 2e 20 30 stb %g1, [ %i0 + 0x30 ]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2024fb4: 82 10 3f ff mov -1, %g1
lfat_fd->dir_pos = *dir_pos;
2024fb8: 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;
2024fbc: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
2024fc0: 40 00 80 79 call 20451a4 <memcpy>
2024fc4: 94 10 20 10 mov 0x10, %o2
if ( rc != RC_OK )
2024fc8: 80 a4 20 00 cmp %l0, 0
2024fcc: 02 80 00 04 be 2024fdc <fat_file_open+0xe0> <== NEVER TAKEN
2024fd0: 01 00 00 00 nop
lfat_fd->ino = key;
2024fd4: 10 80 00 12 b 202501c <fat_file_open+0x120>
2024fd8: f8 26 20 0c st %i4, [ %i0 + 0xc ]
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
2024fdc: 40 00 04 39 call 20260c0 <fat_get_unique_ino> <== NOT EXECUTED
2024fe0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
2024fe4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
2024fe8: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
2024fec: c2 00 60 0c ld [ %g1 + 0xc ], %g1 <== NOT EXECUTED
2024ff0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2024ff4: 32 80 00 0b bne,a 2025020 <fat_file_open+0x124> <== NOT EXECUTED
2024ff8: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
{
free((*fat_fd));
2024ffc: 7f ff 8d df call 2008778 <free> <== NOT EXECUTED
2025000: 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 );
2025004: 40 00 73 27 call 2041ca0 <__errno> <== NOT EXECUTED
2025008: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202500c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
2025010: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2025014: 81 c7 e0 08 ret <== NOT EXECUTED
2025018: 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);
202501c: d0 06 e0 60 ld [ %i3 + 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 );
2025020: d2 07 bf fc ld [ %fp + -4 ], %o1
2025024: b8 0f 20 01 and %i4, 1, %i4
2025028: 83 2f 20 02 sll %i4, 2, %g1
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
202502c: b0 10 20 00 clr %i0
*/
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);
2025030: b9 2f 20 04 sll %i4, 4, %i4
2025034: b8 27 00 01 sub %i4, %g1, %i4
2025038: 7f ff a3 87 call 200de54 <_Chain_Append>
202503c: 90 02 00 1c add %o0, %i4, %o0
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
}
2025040: 81 c7 e0 08 ret
2025044: 81 e8 00 00 restore
0202505c <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
202505c: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
2025060: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2025064: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
2025068: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
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)
202506c: 80 a6 e0 00 cmp %i3, 0
2025070: 02 80 00 63 be 20251fc <fat_file_read+0x1a0> <== NEVER TAKEN
2025074: b0 10 20 00 clr %i0
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
2025078: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
202507c: 80 a6 80 01 cmp %i2, %g1
2025080: 1a 80 00 5f bcc 20251fc <fat_file_read+0x1a0> <== NEVER TAKEN
2025084: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
2025088: 38 80 00 07 bgu,a 20250a4 <fat_file_read+0x48> <== NEVER TAKEN
202508c: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
2025090: 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) ||
2025094: 80 a6 80 02 cmp %i2, %g2
2025098: 28 80 00 04 bleu,a 20250a8 <fat_file_read+0x4c> <== ALWAYS TAKEN
202509c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
20250a0: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
20250a4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
20250a8: 80 a0 60 01 cmp %g1, 1
20250ac: 32 80 00 1c bne,a 202511c <fat_file_read+0xc0>
20250b0: e4 0c 20 08 ldub [ %l0 + 8 ], %l2
20250b4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
20250b8: 80 a0 60 00 cmp %g1, 0
20250bc: 32 80 00 18 bne,a 202511c <fat_file_read+0xc0> <== NEVER TAKEN
20250c0: e4 0c 20 08 ldub [ %l0 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
20250c4: c2 0c 20 0a ldub [ %l0 + 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)) &&
20250c8: 80 88 60 03 btst 3, %g1
20250cc: 22 80 00 14 be,a 202511c <fat_file_read+0xc0> <== NEVER TAKEN
20250d0: e4 0c 20 08 ldub [ %l0 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
20250d4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
20250d8: 7f ff ff 25 call 2024d6c <fat_cluster_num_to_sector_num>
20250dc: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
20250e0: d2 0c 20 02 ldub [ %l0 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
20250e4: d4 14 00 00 lduh [ %l0 ], %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
20250e8: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
20250ec: 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(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
20250f0: 92 02 00 09 add %o0, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
20250f4: 94 0e 80 0a and %i2, %o2, %o2
20250f8: 90 10 00 1d mov %i5, %o0
20250fc: 96 10 00 1b mov %i3, %o3
2025100: 40 00 03 4a call 2025e28 <_fat_block_read>
2025104: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
2025108: b0 92 20 00 orcc %o0, 0, %i0
202510c: 16 80 00 41 bge 2025210 <fat_file_read+0x1b4> <== ALWAYS TAKEN
2025110: 01 00 00 00 nop
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
2025114: 81 c7 e0 08 ret <== NOT EXECUTED
2025118: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
202511c: e2 14 20 06 lduh [ %l0 + 6 ], %l1
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
2025120: a5 36 80 12 srl %i2, %l2, %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
2025124: a6 07 bf fc add %fp, -4, %l3
2025128: 90 10 00 1d mov %i5, %o0
202512c: 92 10 00 19 mov %i1, %o1
2025130: 94 10 00 12 mov %l2, %o2
2025134: 7f ff ff 4c call 2024e64 <fat_file_lseek>
2025138: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
202513c: b0 92 60 00 orcc %o1, 0, %i0
2025140: 12 80 00 2f bne 20251fc <fat_file_read+0x1a0> <== NEVER TAKEN
2025144: a3 2c 60 10 sll %l1, 0x10, %l1
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
2025148: a3 34 60 10 srl %l1, 0x10, %l1
202514c: a2 04 7f ff add %l1, -1, %l1
2025150: b4 0e 80 11 and %i2, %l1, %i2
2025154: a2 10 20 00 clr %l1
2025158: 10 80 00 1f b 20251d4 <fat_file_read+0x178>
202515c: a8 10 00 1a mov %i2, %l4
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2025160: a2 24 40 14 sub %l1, %l4, %l1
2025164: 80 a4 40 1b cmp %l1, %i3
2025168: 38 80 00 02 bgu,a 2025170 <fat_file_read+0x114>
202516c: a2 10 00 1b mov %i3, %l1
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
2025170: d2 07 bf fc ld [ %fp + -4 ], %o1
2025174: 7f ff fe fe call 2024d6c <fat_cluster_num_to_sector_num>
2025178: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
202517c: d2 0c 20 02 ldub [ %l0 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
2025180: d4 14 00 00 lduh [ %l0 ], %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2025184: 93 35 00 09 srl %l4, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
2025188: 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(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
202518c: 92 02 00 09 add %o0, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
2025190: 94 0d 00 0a and %l4, %o2, %o2
2025194: 90 10 00 1d mov %i5, %o0
2025198: 96 10 00 11 mov %l1, %o3
202519c: 40 00 03 23 call 2025e28 <_fat_block_read>
20251a0: 98 07 00 18 add %i4, %i0, %o4
if ( ret < 0 )
20251a4: 80 a2 20 00 cmp %o0, 0
20251a8: 06 80 00 17 bl 2025204 <fat_file_read+0x1a8> <== NEVER TAKEN
20251ac: b6 26 c0 11 sub %i3, %l1, %i3
return -1;
count -= c;
cmpltd += c;
20251b0: b0 06 00 11 add %i0, %l1, %i0
save_cln = cur_cln;
20251b4: e2 07 bf fc ld [ %fp + -4 ], %l1
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
20251b8: 90 10 00 1d mov %i5, %o0
20251bc: 92 10 00 11 mov %l1, %o1
20251c0: 40 00 60 b2 call 203d488 <fat_get_fat_cluster>
20251c4: 94 10 00 13 mov %l3, %o2
if ( rc != RC_OK )
20251c8: 80 a2 20 00 cmp %o0, 0
20251cc: 12 80 00 10 bne 202520c <fat_file_read+0x1b0> <== NEVER TAKEN
20251d0: a8 10 20 00 clr %l4
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
20251d4: 80 a6 e0 00 cmp %i3, 0
20251d8: 32 bf ff e2 bne,a 2025160 <fat_file_read+0x104>
20251dc: e2 14 20 06 lduh [ %l0 + 6 ], %l1
}
/* 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);
20251e0: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
20251e4: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
20251e8: e2 26 60 38 st %l1, [ %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);
20251ec: b4 06 80 18 add %i2, %i0, %i2
20251f0: 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 +
20251f4: a4 06 80 12 add %i2, %l2, %l2
20251f8: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
20251fc: 81 c7 e0 08 ret
2025200: 81 e8 00 00 restore
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
2025204: 81 c7 e0 08 ret <== NOT EXECUTED
2025208: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
202520c: b0 10 00 08 mov %o0, %i0 <== 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;
}
2025210: 81 c7 e0 08 ret
2025214: 81 e8 00 00 restore
020259ec <fat_file_size>:
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
20259ec: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
20259f0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
20259f4: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
20259f8: 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)) &&
20259fc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2025a00: 80 a0 60 01 cmp %g1, 1
2025a04: 12 80 00 0d bne 2025a38 <fat_file_size+0x4c> <== ALWAYS TAKEN
2025a08: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
2025a0c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
2025a10: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2025a14: 32 80 00 0a bne,a 2025a3c <fat_file_size+0x50> <== NOT EXECUTED
2025a18: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2025a1c: c2 0f 20 0a ldub [ %i4 + 0xa ], %g1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025a20: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2025a24: 22 80 00 06 be,a 2025a3c <fat_file_size+0x50> <== NOT EXECUTED
2025a28: 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;
2025a2c: c2 07 20 28 ld [ %i4 + 0x28 ], %g1 <== NOT EXECUTED
2025a30: 10 80 00 18 b 2025a90 <fat_file_size+0xa4> <== NOT EXECUTED
2025a34: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
2025a38: c0 26 60 18 clr [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2025a3c: 10 80 00 0d b 2025a70 <fat_file_size+0x84>
2025a40: 82 10 20 00 clr %g1
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
2025a44: 92 10 00 1b mov %i3, %o1
2025a48: 40 00 5e 90 call 203d488 <fat_get_fat_cluster>
2025a4c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2025a50: 80 a2 20 00 cmp %o0, 0
2025a54: 12 80 00 10 bne 2025a94 <fat_file_size+0xa8> <== NEVER TAKEN
2025a58: 01 00 00 00 nop
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
2025a5c: c2 17 20 06 lduh [ %i4 + 6 ], %g1
2025a60: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
2025a64: 82 00 80 01 add %g2, %g1, %g1
2025a68: 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;
2025a6c: 82 10 00 1b mov %i3, %g1
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2025a70: f6 07 bf fc ld [ %fp + -4 ], %i3
2025a74: c6 07 20 0c ld [ %i4 + 0xc ], %g3
2025a78: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
2025a7c: 86 0e c0 03 and %i3, %g3, %g3
2025a80: 80 a0 c0 02 cmp %g3, %g2
2025a84: 0a bf ff f0 bcs 2025a44 <fat_file_size+0x58>
2025a88: 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;
2025a8c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
return rc;
2025a90: 90 10 20 00 clr %o0
}
2025a94: 81 c7 e0 08 ret
2025a98: 91 e8 00 08 restore %g0, %o0, %o0
02025218 <fat_file_truncate>:
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
2025218: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
202521c: 82 10 3f ff mov -1, %g1
2025220: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( new_length >= fat_fd->fat_file_size )
2025224: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
2025228: c0 27 bf f8 clr [ %fp + -8 ]
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
202522c: ba 10 00 18 mov %i0, %i5
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
2025230: 80 a6 80 01 cmp %i2, %g1
2025234: 1a 80 00 3a bcc 202531c <fat_file_truncate+0x104>
2025238: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
return rc;
assert(fat_fd->fat_file_size);
202523c: 80 a0 60 00 cmp %g1, 0
2025240: 32 80 00 0a bne,a 2025268 <fat_file_truncate+0x50> <== ALWAYS TAKEN
2025244: c4 08 e0 08 ldub [ %g3 + 8 ], %g2
2025248: 11 00 81 8f sethi %hi(0x2063c00), %o0 <== NOT EXECUTED
202524c: 15 00 81 8f sethi %hi(0x2063c00), %o2 <== NOT EXECUTED
2025250: 17 00 81 8f sethi %hi(0x2063c00), %o3 <== NOT EXECUTED
2025254: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
2025258: 92 10 22 6d mov 0x26d, %o1 <== NOT EXECUTED
202525c: 94 12 a0 78 or %o2, 0x78, %o2 <== NOT EXECUTED
2025260: 40 00 08 0d call 2027294 <__assert_func> <== NOT EXECUTED
2025264: 96 12 e0 60 or %o3, 0x60, %o3 <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
2025268: c6 10 e0 06 lduh [ %g3 + 6 ], %g3
202526c: 86 00 ff ff add %g3, -1, %g3
2025270: b4 00 c0 1a add %g3, %i2, %i2
2025274: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
2025278: 85 2e 80 02 sll %i2, %g2, %g2
202527c: 80 a0 80 01 cmp %g2, %g1
2025280: 1a 80 00 28 bcc 2025320 <fat_file_truncate+0x108> <== NEVER TAKEN
2025284: 92 10 20 00 clr %o1
return RC_OK;
if (cl_start != 0)
2025288: 80 a6 a0 00 cmp %i2, 0
202528c: 02 80 00 0a be 20252b4 <fat_file_truncate+0x9c> <== ALWAYS TAKEN
2025290: 90 10 00 1d mov %i5, %o0
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
2025294: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2025298: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
202529c: 94 06 bf ff add %i2, -1, %o2 <== NOT EXECUTED
20252a0: 7f ff fe f1 call 2024e64 <fat_file_lseek> <== NOT EXECUTED
20252a4: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
if (rc != RC_OK)
20252a8: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
20252ac: 12 80 00 1d bne 2025320 <fat_file_truncate+0x108> <== NOT EXECUTED
20252b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
20252b4: 92 10 00 19 mov %i1, %o1
20252b8: 94 10 00 1a mov %i2, %o2
20252bc: 7f ff fe ea call 2024e64 <fat_file_lseek>
20252c0: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
20252c4: 80 a2 60 00 cmp %o1, 0
20252c8: 12 80 00 16 bne 2025320 <fat_file_truncate+0x108> <== NEVER TAKEN
20252cc: 01 00 00 00 nop
return rc;
rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
20252d0: d2 07 bf f8 ld [ %fp + -8 ], %o1
20252d4: 40 00 61 8c call 203d904 <fat_free_fat_clusters_chain>
20252d8: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
20252dc: 92 92 20 00 orcc %o0, 0, %o1
20252e0: 12 80 00 10 bne 2025320 <fat_file_truncate+0x108> <== NEVER TAKEN
20252e4: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
20252e8: 02 80 00 0e be 2025320 <fat_file_truncate+0x108> <== ALWAYS TAKEN
20252ec: 90 10 00 1d mov %i5, %o0
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
20252f0: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
20252f4: 40 00 60 d5 call 203d648 <fat_set_fat_cluster> <== NOT EXECUTED
20252f8: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
20252fc: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
2025300: 12 80 00 08 bne 2025320 <fat_file_truncate+0x108> <== NOT EXECUTED
2025304: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
fat_fd->map.file_cln = cl_start - 1;
2025308: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
202530c: c2 26 60 38 st %g1, [ %i1 + 0x38 ] <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
2025310: f4 26 60 34 st %i2, [ %i1 + 0x34 ] <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
2025314: 10 80 00 03 b 2025320 <fat_file_truncate+0x108> <== NOT EXECUTED
2025318: c2 26 60 3c st %g1, [ %i1 + 0x3c ] <== NOT EXECUTED
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
return rc;
202531c: 92 10 20 00 clr %o1
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;
}
2025320: 81 c7 e0 08 ret
2025324: 91 e8 00 09 restore %g0, %o1, %o0
020256a4 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20256a4: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
20256a8: 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;
20256ac: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20256b0: ba 10 00 18 mov %i0, %i5
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
20256b4: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
20256b8: 80 a6 e0 00 cmp %i3, 0
20256bc: 02 80 00 79 be 20258a0 <fat_file_write+0x1fc> <== NEVER TAKEN
20256c0: 90 10 20 00 clr %o0
return cmpltd;
if ( start > fat_fd->fat_file_size )
20256c4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
20256c8: 80 a6 80 01 cmp %i2, %g1
20256cc: 18 80 00 09 bgu 20256f0 <fat_file_write+0x4c> <== NEVER TAKEN
20256d0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
20256d4: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
20256d8: 80 a6 c0 01 cmp %i3, %g1
20256dc: 18 80 00 05 bgu 20256f0 <fat_file_write+0x4c> <== NEVER TAKEN
20256e0: 82 20 40 1b sub %g1, %i3, %g1
20256e4: 80 a6 80 01 cmp %i2, %g1
20256e8: 08 80 00 07 bleu 2025704 <fat_file_write+0x60> <== ALWAYS TAKEN
20256ec: a2 06 c0 1a add %i3, %i2, %l1
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
20256f0: 40 00 71 6c call 2041ca0 <__errno> <== NOT EXECUTED
20256f4: 01 00 00 00 nop <== NOT EXECUTED
20256f8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
20256fc: 10 80 00 68 b 202589c <fat_file_write+0x1f8> <== NOT EXECUTED
2025700: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
2025704: 90 10 00 18 mov %i0, %o0
2025708: 92 10 00 19 mov %i1, %o1
202570c: 94 10 00 11 mov %l1, %o2
2025710: 7f ff ff 69 call 20254b4 <fat_file_extend>
2025714: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2025718: 80 a2 20 00 cmp %o0, 0
202571c: 12 80 00 61 bne 20258a0 <fat_file_write+0x1fc> <== NEVER TAKEN
2025720: 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))
2025724: 80 a0 40 11 cmp %g1, %l1
2025728: 32 80 00 02 bne,a 2025730 <fat_file_write+0x8c> <== NEVER TAKEN
202572c: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025730: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2025734: 80 a0 60 01 cmp %g1, 1
2025738: 32 80 00 1c bne,a 20257a8 <fat_file_write+0x104>
202573c: e4 0c 20 08 ldub [ %l0 + 8 ], %l2
2025740: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2025744: 80 a0 60 00 cmp %g1, 0
2025748: 32 80 00 18 bne,a 20257a8 <fat_file_write+0x104> <== NEVER TAKEN
202574c: e4 0c 20 08 ldub [ %l0 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2025750: c2 0c 20 0a ldub [ %l0 + 0xa ], %g1
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025754: 80 88 60 03 btst 3, %g1
2025758: 22 80 00 14 be,a 20257a8 <fat_file_write+0x104> <== NEVER TAKEN
202575c: e4 0c 20 08 ldub [ %l0 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
2025760: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
2025764: 7f ff fd 82 call 2024d6c <fat_cluster_num_to_sector_num>
2025768: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
202576c: d2 0c 20 02 ldub [ %l0 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
2025770: d4 14 00 00 lduh [ %l0 ], %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
2025774: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
2025778: 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(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
202577c: 92 02 00 09 add %o0, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
2025780: 94 0e 80 0a and %i2, %o2, %o2
2025784: 90 10 00 1d mov %i5, %o0
2025788: 96 10 00 1b mov %i3, %o3
202578c: 40 00 01 c9 call 2025eb0 <_fat_block_write>
2025790: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
2025794: 80 a2 20 00 cmp %o0, 0
2025798: 16 80 00 42 bge 20258a0 <fat_file_write+0x1fc> <== ALWAYS TAKEN
202579c: 01 00 00 00 nop
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
20257a0: 10 80 00 40 b 20258a0 <fat_file_write+0x1fc> <== NOT EXECUTED
20257a4: 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);
20257a8: e2 14 20 06 lduh [ %l0 + 6 ], %l1
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
20257ac: a5 36 80 12 srl %i2, %l2, %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
20257b0: a6 07 bf f8 add %fp, -8, %l3
20257b4: 90 10 00 1d mov %i5, %o0
20257b8: 92 10 00 19 mov %i1, %o1
20257bc: 94 10 00 12 mov %l2, %o2
20257c0: 7f ff fd a9 call 2024e64 <fat_file_lseek>
20257c4: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
20257c8: 90 92 60 00 orcc %o1, 0, %o0
20257cc: 12 80 00 35 bne 20258a0 <fat_file_write+0x1fc> <== NEVER TAKEN
20257d0: a3 2c 60 10 sll %l1, 0x10, %l1
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
20257d4: a3 34 60 10 srl %l1, 0x10, %l1
20257d8: a2 04 7f ff add %l1, -1, %l1
20257dc: a8 10 20 00 clr %l4
20257e0: b4 0e 80 11 and %i2, %l1, %i2
20257e4: a2 10 20 00 clr %l1
20257e8: 10 80 00 21 b 202586c <fat_file_write+0x1c8>
20257ec: aa 10 00 1a mov %i2, %l5
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
20257f0: b0 26 00 15 sub %i0, %l5, %i0
20257f4: 80 a6 00 1b cmp %i0, %i3
20257f8: 38 80 00 02 bgu,a 2025800 <fat_file_write+0x15c>
20257fc: b0 10 00 1b mov %i3, %i0
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
2025800: 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));
2025804: f0 27 bf fc st %i0, [ %fp + -4 ]
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
2025808: 7f ff fd 59 call 2024d6c <fat_cluster_num_to_sector_num>
202580c: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
2025810: d2 0c 20 02 ldub [ %l0 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
2025814: d4 14 00 00 lduh [ %l0 ], %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2025818: 93 35 40 09 srl %l5, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
202581c: 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(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2025820: 92 02 00 09 add %o0, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
2025824: 94 0d 40 0a and %l5, %o2, %o2
2025828: 90 10 00 1d mov %i5, %o0
202582c: 96 10 00 18 mov %i0, %o3
2025830: 40 00 01 a0 call 2025eb0 <_fat_block_write>
2025834: 98 07 00 11 add %i4, %l1, %o4
if ( ret < 0 )
2025838: 80 a2 20 00 cmp %o0, 0
202583c: 06 80 00 18 bl 202589c <fat_file_write+0x1f8> <== NEVER TAKEN
2025840: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
2025844: e8 07 bf f8 ld [ %fp + -8 ], %l4
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
2025848: b6 26 c0 01 sub %i3, %g1, %i3
cmpltd += c;
202584c: a2 04 40 01 add %l1, %g1, %l1
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
2025850: 90 10 00 1d mov %i5, %o0
2025854: 92 10 00 14 mov %l4, %o1
2025858: 40 00 5f 0c call 203d488 <fat_get_fat_cluster>
202585c: 94 10 00 13 mov %l3, %o2
if ( rc != RC_OK )
2025860: 80 a2 20 00 cmp %o0, 0
2025864: 12 80 00 0f bne 20258a0 <fat_file_write+0x1fc> <== NEVER TAKEN
2025868: aa 10 20 00 clr %l5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
202586c: 80 a6 e0 00 cmp %i3, 0
2025870: 32 bf ff e0 bne,a 20257f0 <fat_file_write+0x14c>
2025874: f0 14 20 06 lduh [ %l0 + 6 ], %i0
}
/* 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);
2025878: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
202587c: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
2025880: e8 26 60 38 st %l4, [ %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);
2025884: b4 06 80 11 add %i2, %l1, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
2025888: 90 10 00 11 mov %l1, %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);
202588c: 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 +
2025890: a4 06 80 12 add %i2, %l2, %l2
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
2025894: 10 80 00 03 b 20258a0 <fat_file_write+0x1fc>
2025898: 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(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
202589c: 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;
}
20258a0: 81 c7 e0 08 ret
20258a4: 91 e8 00 08 restore %g0, %o0, %o0
0203d904 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
203d904: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
203d908: b6 10 20 00 clr %i3
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
203d90c: ba 10 00 18 mov %i0, %i5
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
203d910: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
203d914: c0 27 bf fc clr [ %fp + -4 ]
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
203d918: b4 10 00 19 mov %i1, %i2
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
203d91c: 10 80 00 19 b 203d980 <fat_free_fat_clusters_chain+0x7c>
203d920: a0 10 20 00 clr %l0
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
203d924: 92 10 00 1a mov %i2, %o1
203d928: 7f ff fe d8 call 203d488 <fat_get_fat_cluster>
203d92c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
203d930: b0 92 20 00 orcc %o0, 0, %i0
203d934: 02 80 00 0b be 203d960 <fat_free_fat_clusters_chain+0x5c> <== ALWAYS TAKEN
203d938: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
203d93c: c2 07 20 40 ld [ %i4 + 0x40 ], %g1 <== NOT EXECUTED
203d940: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
203d944: 02 80 00 03 be 203d950 <fat_free_fat_clusters_chain+0x4c> <== NOT EXECUTED
203d948: b6 06 c0 01 add %i3, %g1, %i3 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
203d94c: f6 27 20 40 st %i3, [ %i4 + 0x40 ] <== NOT EXECUTED
fat_buf_release(fs_info);
203d950: 7f ff a0 dd call 2025cc4 <fat_buf_release> <== NOT EXECUTED
203d954: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rc;
203d958: 81 c7 e0 08 ret <== NOT EXECUTED
203d95c: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
203d960: 92 10 00 1a mov %i2, %o1
203d964: 7f ff ff 39 call 203d648 <fat_set_fat_cluster>
203d968: 94 10 20 00 clr %o2
if ( rc != RC_OK )
203d96c: 80 a2 20 00 cmp %o0, 0
203d970: 32 80 00 02 bne,a 203d978 <fat_free_fat_clusters_chain+0x74><== NEVER TAKEN
203d974: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
203d978: f4 07 bf fc ld [ %fp + -4 ], %i2
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
203d97c: b6 06 e0 01 inc %i3
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
203d980: c4 07 20 0c ld [ %i4 + 0xc ], %g2
203d984: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
203d988: 84 0e 80 02 and %i2, %g2, %g2
203d98c: 80 a0 80 01 cmp %g2, %g1
203d990: 0a bf ff e5 bcs 203d924 <fat_free_fat_clusters_chain+0x20>
203d994: 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)
203d998: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
203d99c: 80 a0 7f ff cmp %g1, -1
203d9a0: 02 80 00 04 be 203d9b0 <fat_free_fat_clusters_chain+0xac> <== ALWAYS TAKEN
203d9a4: f2 27 20 44 st %i1, [ %i4 + 0x44 ]
fs_info->vol.free_cls += freed_cls_cnt;
203d9a8: b6 06 c0 01 add %i3, %g1, %i3 <== NOT EXECUTED
203d9ac: f6 27 20 40 st %i3, [ %i4 + 0x40 ] <== NOT EXECUTED
fat_buf_release(fs_info);
203d9b0: 90 10 00 1c mov %i4, %o0
203d9b4: 7f ff a0 c4 call 2025cc4 <fat_buf_release>
203d9b8: b0 10 00 10 mov %l0, %i0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
203d9bc: 81 c7 e0 08 ret
203d9c0: 81 e8 00 00 restore
02026190 <fat_free_unique_ino>:
fat_free_unique_ino(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
2026190: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
2026194: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
2026198: c4 00 60 74 ld [ %g1 + 0x74 ], %g2 <== NOT EXECUTED
202619c: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 <== NOT EXECUTED
20261a0: 84 22 40 02 sub %o1, %g2, %g2 <== NOT EXECUTED
20261a4: 87 30 a0 03 srl %g2, 3, %g3 <== NOT EXECUTED
20261a8: 84 08 a0 07 and %g2, 7, %g2 <== NOT EXECUTED
20261ac: 85 29 00 02 sll %g4, %g2, %g2 <== NOT EXECUTED
20261b0: c8 08 40 03 ldub [ %g1 + %g3 ], %g4 <== NOT EXECUTED
20261b4: 84 29 00 02 andn %g4, %g2, %g2 <== NOT EXECUTED
}
20261b8: 81 c3 e0 08 retl <== NOT EXECUTED
20261bc: c4 28 40 03 stb %g2, [ %g1 + %g3 ] <== NOT EXECUTED
0203d488 <fat_get_fat_cluster>:
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
203d488: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
rtems_bdbuf_buffer *block0 = NULL;
203d48c: 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)) )
203d490: 80 a6 60 01 cmp %i1, 1
203d494: 08 80 00 64 bleu 203d624 <fat_get_fat_cluster+0x19c> <== NEVER TAKEN
203d498: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
203d49c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
203d4a0: 82 00 60 01 inc %g1
203d4a4: 80 a6 40 01 cmp %i1, %g1
203d4a8: 18 80 00 5f bgu 203d624 <fat_get_fat_cluster+0x19c> <== NEVER TAKEN
203d4ac: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
203d4b0: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
203d4b4: b7 36 60 01 srl %i1, 1, %i3
203d4b8: 84 88 60 01 andcc %g1, 1, %g2
203d4bc: 12 80 00 06 bne 203d4d4 <fat_get_fat_cluster+0x4c> <== ALWAYS TAKEN
203d4c0: b6 06 c0 19 add %i3, %i1, %i3
203d4c4: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
203d4c8: 02 80 00 03 be 203d4d4 <fat_get_fat_cluster+0x4c> <== NOT EXECUTED
203d4cc: b7 2e 60 02 sll %i1, 2, %i3 <== NOT EXECUTED
203d4d0: b7 2e 60 01 sll %i1, 1, %i3 <== NOT EXECUTED
203d4d4: 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);
203d4d8: b9 36 60 01 srl %i1, 1, %i4
/* 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) +
203d4dc: b7 36 c0 03 srl %i3, %g3, %i3
203d4e0: 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);
203d4e4: b8 07 00 19 add %i4, %i1, %i4
203d4e8: 80 a0 a0 00 cmp %g2, 0
203d4ec: 12 80 00 06 bne 203d504 <fat_get_fat_cluster+0x7c> <== ALWAYS TAKEN
203d4f0: b6 06 c0 03 add %i3, %g3, %i3
203d4f4: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
203d4f8: 02 80 00 03 be 203d504 <fat_get_fat_cluster+0x7c> <== NOT EXECUTED
203d4fc: b9 2e 60 02 sll %i1, 2, %i4 <== NOT EXECUTED
203d500: b9 2e 60 01 sll %i1, 1, %i4 <== NOT EXECUTED
203d504: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
203d508: 90 10 00 1d mov %i5, %o0
203d50c: 92 10 00 1b mov %i3, %o1
203d510: 94 10 20 01 mov 1, %o2
203d514: 7f ff a1 6e call 2025acc <fat_buf_access>
203d518: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
203d51c: b0 92 20 00 orcc %o0, 0, %i0
203d520: 12 80 00 38 bne 203d600 <fat_get_fat_cluster+0x178> <== NEVER TAKEN
203d524: a1 2c 20 10 sll %l0, 0x10, %l0
return rc;
switch ( fs_info->vol.type )
203d528: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
203d52c: 80 a0 60 02 cmp %g1, 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);
203d530: a1 34 20 10 srl %l0, 0x10, %l0
203d534: a0 04 3f ff add %l0, -1, %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
203d538: 02 80 00 27 be 203d5d4 <fat_get_fat_cluster+0x14c> <== NEVER TAKEN
203d53c: b8 0f 00 10 and %i4, %l0, %i4
203d540: 80 a0 60 04 cmp %g1, 4
203d544: 02 80 00 31 be 203d608 <fat_get_fat_cluster+0x180> <== NEVER TAKEN
203d548: 80 a0 60 01 cmp %g1, 1
203d54c: 12 80 00 36 bne 203d624 <fat_get_fat_cluster+0x19c> <== NEVER TAKEN
203d550: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* 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) )
203d554: c6 17 40 00 lduh [ %i5 ], %g3
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)));
203d558: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
if ( ofs == (fs_info->vol.bps - 1) )
203d55c: 86 00 ff ff add %g3, -1, %g3
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)));
203d560: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
if ( ofs == (fs_info->vol.bps - 1) )
203d564: 80 a7 00 03 cmp %i4, %g3
203d568: 12 80 00 0f bne 203d5a4 <fat_get_fat_cluster+0x11c> <== ALWAYS TAKEN
203d56c: c2 26 80 00 st %g1, [ %i2 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
203d570: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203d574: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
203d578: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203d57c: 7f ff a1 54 call 2025acc <fat_buf_access> <== NOT EXECUTED
203d580: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
203d584: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
203d588: 12 80 00 2d bne 203d63c <fat_get_fat_cluster+0x1b4> <== NOT EXECUTED
203d58c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
203d590: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
203d594: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
203d598: c2 08 40 00 ldub [ %g1 ], %g1 <== NOT EXECUTED
203d59c: 10 80 00 05 b 203d5b0 <fat_get_fat_cluster+0x128> <== NOT EXECUTED
203d5a0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
203d5a4: b8 00 80 1c add %g2, %i4, %i4
203d5a8: c4 0f 20 01 ldub [ %i4 + 1 ], %g2
203d5ac: 85 28 a0 08 sll %g2, 8, %g2
203d5b0: 82 10 80 01 or %g2, %g1, %g1
203d5b4: c2 26 80 00 st %g1, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
203d5b8: 80 8e 60 01 btst 1, %i1
203d5bc: 02 80 00 04 be 203d5cc <fat_get_fat_cluster+0x144>
203d5c0: c2 06 80 00 ld [ %i2 ], %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
203d5c4: 10 80 00 0e b 203d5fc <fat_get_fat_cluster+0x174>
203d5c8: 83 30 60 04 srl %g1, 4, %g1
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
203d5cc: 10 80 00 0c b 203d5fc <fat_get_fat_cluster+0x174>
203d5d0: 82 08 6f ff and %g1, 0xfff, %g1
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
203d5d4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
203d5d8: 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));
203d5dc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
203d5e0: 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));
203d5e4: c2 10 40 1c lduh [ %g1 + %i4 ], %g1 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
203d5e8: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
203d5ec: 85 30 60 18 srl %g1, 0x18, %g2 <== NOT EXECUTED
203d5f0: 83 30 60 08 srl %g1, 8, %g1 <== NOT EXECUTED
203d5f4: 82 08 40 03 and %g1, %g3, %g1 <== NOT EXECUTED
203d5f8: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
203d5fc: c2 26 80 00 st %g1, [ %i2 ]
break;
203d600: 81 c7 e0 08 ret
203d604: 81 e8 00 00 restore
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
203d608: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
203d60c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
*ret_val = CF_LE_L(*ret_val);
203d610: 7f ff ff 92 call 203d458 <CPU_swap_u32> <== NOT EXECUTED
203d614: d0 00 40 1c ld [ %g1 + %i4 ], %o0 <== NOT EXECUTED
203d618: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
break;
203d61c: 81 c7 e0 08 ret <== NOT EXECUTED
203d620: 81 e8 00 00 restore <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one(EIO);
203d624: 40 00 11 9f call 2041ca0 <__errno> <== NOT EXECUTED
203d628: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d62c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
203d630: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203d634: 81 c7 e0 08 ret <== NOT EXECUTED
203d638: 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)
203d63c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
203d640: 81 c7 e0 08 ret <== NOT EXECUTED
203d644: 81 e8 00 00 restore <== NOT EXECUTED
020260c0 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
20260c0: 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))
20260c4: 39 03 ff ff sethi %hi(0xffffc00), %i4 <== NOT EXECUTED
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
20260c8: fa 06 20 20 ld [ %i0 + 0x20 ], %i5 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
20260cc: 10 80 00 2a b 2026174 <fat_get_unique_ino+0xb4> <== NOT EXECUTED
20260d0: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
20260d4: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
20260d8: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
20260dc: 9e 00 c0 02 add %g3, %g2, %o7 <== NOT EXECUTED
20260e0: da 08 c0 02 ldub [ %g3 + %g2 ], %o5 <== NOT EXECUTED
20260e4: c4 48 c0 02 ldsb [ %g3 + %g2 ], %g2 <== NOT EXECUTED
20260e8: 88 08 60 07 and %g1, 7, %g4 <== NOT EXECUTED
20260ec: 85 38 80 04 sra %g2, %g4, %g2 <== NOT EXECUTED
20260f0: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
20260f4: 12 80 00 0a bne 202611c <fat_get_unique_ino+0x5c> <== NOT EXECUTED
20260f8: 82 00 60 01 inc %g1 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
20260fc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2026100: 89 28 40 04 sll %g1, %g4, %g4 <== NOT EXECUTED
2026104: 88 11 00 0d or %g4, %o5, %g4 <== NOT EXECUTED
2026108: c8 2b c0 00 stb %g4, [ %o7 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
202610c: f0 07 60 6c ld [ %i5 + 0x6c ], %i0 <== NOT EXECUTED
2026110: c2 07 60 74 ld [ %i5 + 0x74 ], %g1 <== NOT EXECUTED
2026114: 81 c7 e0 08 ret <== NOT EXECUTED
2026118: 91 ee 00 01 restore %i0, %g1, %o0 <== NOT EXECUTED
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
202611c: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
2026120: 0a 80 00 03 bcs 202612c <fat_get_unique_ino+0x6c> <== NOT EXECUTED
2026124: c2 27 60 6c st %g1, [ %i5 + 0x6c ] <== NOT EXECUTED
fs_info->index = 0;
2026128: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
202612c: 92 02 60 01 inc %o1 <== NOT EXECUTED
2026130: 80 a2 40 18 cmp %o1, %i0 <== NOT EXECUTED
2026134: 32 bf ff e8 bne,a 20260d4 <fat_get_unique_ino+0x14> <== NOT EXECUTED
2026138: c6 07 60 68 ld [ %i5 + 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))
202613c: c2 07 60 74 ld [ %i5 + 0x74 ], %g1 <== NOT EXECUTED
2026140: 93 2a 60 01 sll %o1, 1, %o1 <== NOT EXECUTED
2026144: 82 27 00 01 sub %i4, %g1, %g1 <== NOT EXECUTED
2026148: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
202614c: 1a 80 00 0d bcc 2026180 <fat_get_unique_ino+0xc0> <== NOT EXECUTED
2026150: 01 00 00 00 nop <== NOT EXECUTED
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
2026154: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
2026158: 7f ff 8e 41 call 2009a5c <realloc> <== NOT EXECUTED
202615c: d2 27 60 70 st %o1, [ %i5 + 0x70 ] <== NOT EXECUTED
if (fs_info->uino != NULL)
2026160: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2026164: 02 80 00 09 be 2026188 <fat_get_unique_ino+0xc8> <== NOT EXECUTED
2026168: d0 27 60 68 st %o0, [ %i5 + 0x68 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
202616c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 <== NOT EXECUTED
2026170: c2 27 60 6c st %g1, [ %i5 + 0x6c ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
2026174: f0 07 60 70 ld [ %i5 + 0x70 ], %i0 <== NOT EXECUTED
2026178: 10 bf ff ee b 2026130 <fat_get_unique_ino+0x70> <== NOT EXECUTED
202617c: 92 10 20 00 clr %o1 <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
2026180: 81 c7 e0 08 ret <== NOT EXECUTED
2026184: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
2026188: 81 c7 e0 08 ret <== NOT EXECUTED
202618c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02026008 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
2026008: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
202600c: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
uint32_t cur_cln = start_cln;
2026010: f2 27 bf fc st %i1, [ %fp + -4 ]
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
2026014: d0 17 60 06 lduh [ %i5 + 6 ], %o0
2026018: 92 10 20 01 mov 1, %o1
202601c: 7f ff 88 f9 call 2008400 <calloc>
2026020: b8 10 00 18 mov %i0, %i4
if ( buf == NULL )
2026024: b6 92 20 00 orcc %o0, 0, %i3
2026028: 12 80 00 1b bne 2026094 <fat_init_clusters_chain+0x8c> <== ALWAYS TAKEN
202602c: d2 07 bf fc ld [ %fp + -4 ], %o1
rtems_set_errno_and_return_minus_one( EIO );
2026030: 40 00 6f 1c call 2041ca0 <__errno> <== NOT EXECUTED
2026034: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2026038: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
202603c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2026040: 81 c7 e0 08 ret <== NOT EXECUTED
2026044: 81 e8 00 00 restore <== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
2026048: 7f ff ff da call 2025fb0 <fat_cluster_write>
202604c: 94 10 00 1b mov %i3, %o2
if ( ret == -1 )
2026050: 80 a2 3f ff cmp %o0, -1
2026054: 12 80 00 06 bne 202606c <fat_init_clusters_chain+0x64> <== ALWAYS TAKEN
2026058: d2 07 bf fc ld [ %fp + -4 ], %o1
{
free(buf);
202605c: 7f ff 89 c7 call 2008778 <free> <== NOT EXECUTED
2026060: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
return -1;
2026064: 81 c7 e0 08 ret <== NOT EXECUTED
2026068: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
202606c: 90 10 00 1c mov %i4, %o0
2026070: 40 00 5d 06 call 203d488 <fat_get_fat_cluster>
2026074: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2026078: b0 92 20 00 orcc %o0, 0, %i0
202607c: 02 80 00 06 be 2026094 <fat_init_clusters_chain+0x8c> <== ALWAYS TAKEN
2026080: d2 07 bf fc ld [ %fp + -4 ], %o1
{
free(buf);
2026084: 7f ff 89 bd call 2008778 <free> <== NOT EXECUTED
2026088: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
return rc;
202608c: 81 c7 e0 08 ret <== NOT EXECUTED
2026090: 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)
2026094: c4 07 60 0c ld [ %i5 + 0xc ], %g2
2026098: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
202609c: 84 0a 40 02 and %o1, %g2, %g2
20260a0: 80 a0 80 01 cmp %g2, %g1
20260a4: 0a bf ff e9 bcs 2026048 <fat_init_clusters_chain+0x40>
20260a8: 90 10 00 1c mov %i4, %o0
free(buf);
return rc;
}
}
free(buf);
20260ac: 90 10 00 1b mov %i3, %o0
20260b0: 7f ff 89 b2 call 2008778 <free>
20260b4: b0 10 20 00 clr %i0
return rc;
}
20260b8: 81 c7 e0 08 ret
20260bc: 81 e8 00 00 restore
0202635c <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
202635c: 9d e3 bf 10 save %sp, -240, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
2026360: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(mt_entry->dev, O_RDWR);
2026364: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
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;
2026368: c0 27 bf fc clr [ %fp + -4 ]
vol->fd = open(mt_entry->dev, O_RDWR);
202636c: 7f ff 8c e2 call 20096f4 <open>
2026370: 92 10 20 02 mov 2, %o1
if (vol->fd < 0)
2026374: 80 a2 20 00 cmp %o0, 0
2026378: 06 80 00 09 bl 202639c <fat_init_volume_info+0x40> <== NEVER TAKEN
202637c: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
2026380: 40 00 05 34 call 2027850 <fstat>
2026384: 92 07 bf a8 add %fp, -88, %o1
if (rc != 0)
2026388: 80 a2 20 00 cmp %o0, 0
202638c: 02 80 00 08 be 20263ac <fat_init_volume_info+0x50> <== ALWAYS TAKEN
2026390: d0 07 60 54 ld [ %i5 + 0x54 ], %o0
{
close(vol->fd);
2026394: 7f ff 88 40 call 2008494 <close> <== NOT EXECUTED
2026398: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
202639c: 40 00 6e 41 call 2041ca0 <__errno> <== NOT EXECUTED
20263a0: 01 00 00 00 nop <== NOT EXECUTED
20263a4: 10 80 01 c4 b 2026ab4 <fat_init_volume_info+0x758> <== NOT EXECUTED
20263a8: 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))
20263ac: c4 07 bf b4 ld [ %fp + -76 ], %g2
20263b0: 03 00 00 3c sethi %hi(0xf000), %g1
20263b4: 84 08 80 01 and %g2, %g1, %g2
20263b8: 03 00 00 18 sethi %hi(0x6000), %g1
20263bc: 80 a0 80 01 cmp %g2, %g1
20263c0: 12 bf ff f5 bne 2026394 <fat_init_volume_info+0x38> <== NEVER TAKEN
20263c4: 01 00 00 00 nop
static inline int rtems_disk_fd_get_disk_device(
int fd,
const rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
20263c8: 13 10 01 10 sethi %hi(0x40044000), %o1
20263cc: 94 07 60 58 add %i5, 0x58, %o2
20263d0: 7f ff 89 41 call 20088d4 <ioctl>
20263d4: 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) {
20263d8: b8 92 20 00 orcc %o0, 0, %i4
20263dc: 22 80 00 04 be,a 20263ec <fat_init_volume_info+0x90> <== ALWAYS TAKEN
20263e0: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
close(vol->fd);
20263e4: 10 bf ff ec b 2026394 <fat_init_volume_info+0x38> <== NOT EXECUTED
20263e8: d0 07 60 54 ld [ %i5 + 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);
20263ec: 92 10 20 00 clr %o1
20263f0: 7f ff 7f 9f call 200626c <rtems_bdbuf_read>
20263f4: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
20263f8: 80 a2 20 00 cmp %o0, 0
20263fc: 12 80 00 35 bne 20264d0 <fat_init_volume_info+0x174> <== NEVER TAKEN
2026400: 01 00 00 00 nop
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
2026404: d0 07 bf fc ld [ %fp + -4 ], %o0
2026408: de 02 20 1c ld [ %o0 + 0x1c ], %o7
202640c: d6 0b e0 17 ldub [ %o7 + 0x17 ], %o3
2026410: f4 0b e0 20 ldub [ %o7 + 0x20 ], %i2
2026414: d6 2f bf 98 stb %o3, [ %fp + -104 ]
2026418: d6 0b e0 22 ldub [ %o7 + 0x22 ], %o3
202641c: f4 2f bf 9a stb %i2, [ %fp + -102 ]
2026420: d6 2f bf 99 stb %o3, [ %fp + -103 ]
2026424: d6 0b e0 2c ldub [ %o7 + 0x2c ], %o3
2026428: f4 0b e0 23 ldub [ %o7 + 0x23 ], %i2
202642c: d6 2f bf 9d stb %o3, [ %fp + -99 ]
2026430: d6 0b e0 2d ldub [ %o7 + 0x2d ], %o3
2026434: f4 2f bf 97 stb %i2, [ %fp + -105 ]
2026438: d6 2f bf 9c stb %o3, [ %fp + -100 ]
202643c: d6 0b e0 2e ldub [ %o7 + 0x2e ], %o3
2026440: da 0b e0 0b ldub [ %o7 + 0xb ], %o5
2026444: d6 2f bf 9b stb %o3, [ %fp + -101 ]
2026448: d6 0b e0 2f ldub [ %o7 + 0x2f ], %o3
202644c: d8 0b e0 0c ldub [ %o7 + 0xc ], %o4
2026450: c6 0b e0 0e ldub [ %o7 + 0xe ], %g3
2026454: c8 0b e0 0f ldub [ %o7 + 0xf ], %g4
2026458: c2 0b e0 11 ldub [ %o7 + 0x11 ], %g1
202645c: c4 0b e0 12 ldub [ %o7 + 0x12 ], %g2
2026460: f6 0b e0 0d ldub [ %o7 + 0xd ], %i3
2026464: f2 0b e0 10 ldub [ %o7 + 0x10 ], %i1
2026468: e2 0b e0 13 ldub [ %o7 + 0x13 ], %l1
202646c: e4 0b e0 14 ldub [ %o7 + 0x14 ], %l2
2026470: ee 0b e0 16 ldub [ %o7 + 0x16 ], %l7
2026474: e0 0b e0 21 ldub [ %o7 + 0x21 ], %l0
2026478: e8 0b e0 24 ldub [ %o7 + 0x24 ], %l4
202647c: ec 0b e0 25 ldub [ %o7 + 0x25 ], %l6
2026480: ea 0b e0 26 ldub [ %o7 + 0x26 ], %l5
2026484: e6 0b e0 27 ldub [ %o7 + 0x27 ], %l3
2026488: f4 0b e0 28 ldub [ %o7 + 0x28 ], %i2
202648c: d6 2f bf a7 stb %o3, [ %fp + -89 ]
2026490: d6 0b e0 30 ldub [ %o7 + 0x30 ], %o3
2026494: de 0b e0 31 ldub [ %o7 + 0x31 ], %o7
2026498: d6 2f bf 9f stb %o3, [ %fp + -97 ]
sc = rtems_bdbuf_release( block);
202649c: c2 27 bf 8c st %g1, [ %fp + -116 ]
20264a0: c4 3f bf 80 std %g2, [ %fp + -128 ]
20264a4: c8 27 bf 7c st %g4, [ %fp + -132 ]
20264a8: 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);
20264ac: de 2f bf 9e stb %o7, [ %fp + -98 ]
sc = rtems_bdbuf_release( block);
20264b0: 7f ff 7f f9 call 2006494 <rtems_bdbuf_release>
20264b4: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
20264b8: c2 07 bf 8c ld [ %fp + -116 ], %g1
20264bc: 80 a2 20 00 cmp %o0, 0
20264c0: c4 1f bf 80 ldd [ %fp + -128 ], %g2
20264c4: c8 07 bf 7c ld [ %fp + -132 ], %g4
20264c8: 02 80 00 08 be 20264e8 <fat_init_volume_info+0x18c> <== ALWAYS TAKEN
20264cc: d8 1f bf 70 ldd [ %fp + -144 ], %o4
{
close(vol->fd);
20264d0: 7f ff 87 f1 call 2008494 <close> <== NOT EXECUTED
20264d4: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
20264d8: 40 00 6d f2 call 2041ca0 <__errno> <== NOT EXECUTED
20264dc: 01 00 00 00 nop <== NOT EXECUTED
20264e0: 10 80 01 75 b 2026ab4 <fat_init_volume_info+0x758> <== NOT EXECUTED
20264e4: 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);
20264e8: 98 0b 20 ff and %o4, 0xff, %o4
20264ec: 9a 0b 60 ff and %o5, 0xff, %o5
20264f0: 99 2b 20 08 sll %o4, 8, %o4
20264f4: 9a 13 00 0d or %o4, %o5, %o5
if ( (vol->bps != 512) &&
20264f8: 9f 2b 60 10 sll %o5, 0x10, %o7
20264fc: 9f 33 e0 10 srl %o7, 0x10, %o7
2026500: 80 a3 e4 00 cmp %o7, 0x400
2026504: 02 80 00 0b be 2026530 <fat_init_volume_info+0x1d4> <== NEVER TAKEN
2026508: da 37 40 00 sth %o5, [ %i5 ]
202650c: 80 a3 e2 00 cmp %o7, 0x200
2026510: 22 80 00 09 be,a 2026534 <fat_init_volume_info+0x1d8> <== ALWAYS TAKEN
2026514: 9f 2b 60 10 sll %o5, 0x10, %o7
(vol->bps != 1024) &&
2026518: 80 a3 e8 00 cmp %o7, 0x800 <== NOT EXECUTED
202651c: 02 80 00 05 be 2026530 <fat_init_volume_info+0x1d4> <== NOT EXECUTED
2026520: 19 00 00 04 sethi %hi(0x1000), %o4 <== NOT EXECUTED
(vol->bps != 2048) &&
2026524: 80 a3 c0 0c cmp %o7, %o4 <== NOT EXECUTED
2026528: 12 80 00 d2 bne 2026870 <fat_init_volume_info+0x514> <== NOT EXECUTED
202652c: 01 00 00 00 nop <== 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;
2026530: 9f 2b 60 10 sll %o5, 0x10, %o7 <== NOT EXECUTED
2026534: c0 2f 60 03 clrb [ %i5 + 3 ]
2026538: 10 80 00 05 b 202654c <fat_init_volume_info+0x1f0>
202653c: 9f 33 e0 19 srl %o7, 0x19, %o7
i >>= 1, vol->sec_mul++);
2026540: 9f 3b e0 01 sra %o7, 1, %o7 <== NOT EXECUTED
2026544: 98 03 20 01 inc %o4 <== NOT EXECUTED
2026548: d8 2f 60 03 stb %o4, [ %i5 + 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;
202654c: 80 8b e0 01 btst 1, %o7
2026550: 22 bf ff fc be,a 2026540 <fat_init_volume_info+0x1e4> <== NEVER TAKEN
2026554: d8 0f 60 03 ldub [ %i5 + 3 ], %o4 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
2026558: 9b 2b 60 10 sll %o5, 0x10, %o5
202655c: c0 2f 60 02 clrb [ %i5 + 2 ]
2026560: 93 33 60 10 srl %o5, 0x10, %o1
2026564: 10 80 00 05 b 2026578 <fat_init_volume_info+0x21c>
2026568: 9e 10 00 09 mov %o1, %o7
i >>= 1, vol->sec_log2++);
202656c: 9f 3b e0 01 sra %o7, 1, %o7
2026570: 9a 03 60 01 inc %o5
2026574: da 2f 60 02 stb %o5, [ %i5 + 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;
2026578: 80 8b e0 01 btst 1, %o7
202657c: 22 bf ff fc be,a 202656c <fat_init_volume_info+0x210>
2026580: da 0f 60 02 ldub [ %i5 + 2 ], %o5
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)
2026584: 9a 8e e0 ff andcc %i3, 0xff, %o5
2026588: 02 80 00 ba be 2026870 <fat_init_volume_info+0x514> <== NEVER TAKEN
202658c: f6 2f 60 04 stb %i3, [ %i5 + 4 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
2026590: 10 80 00 05 b 20265a4 <fat_init_volume_info+0x248>
2026594: c0 2f 60 05 clrb [ %i5 + 5 ]
i >>= 1, vol->spc_log2++);
2026598: 9e 03 e0 01 inc %o7
202659c: 9b 3b 60 01 sra %o5, 1, %o5
20265a0: de 2f 60 05 stb %o7, [ %i5 + 5 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
20265a4: 80 8b 60 01 btst 1, %o5
20265a8: 02 bf ff fc be 2026598 <fat_init_volume_info+0x23c>
20265ac: de 0f 60 05 ldub [ %i5 + 5 ], %o7
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)
20265b0: 9f 2a 40 0f sll %o1, %o7, %o7
20265b4: de 37 60 06 sth %o7, [ %i5 + 6 ]
20265b8: 1b 00 00 20 sethi %hi(0x8000), %o5
20265bc: 9f 2b e0 10 sll %o7, 0x10, %o7
20265c0: 9f 33 e0 10 srl %o7, 0x10, %o7
20265c4: 80 a3 c0 0d cmp %o7, %o5
20265c8: 18 80 00 aa bgu 2026870 <fat_init_volume_info+0x514> <== NEVER TAKEN
20265cc: 01 00 00 00 nop
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
20265d0: 10 80 00 05 b 20265e4 <fat_init_volume_info+0x288>
20265d4: c0 2f 60 08 clrb [ %i5 + 8 ]
i >>= 1, vol->bpc_log2++);
20265d8: 9f 3b e0 01 sra %o7, 1, %o7
20265dc: 9a 03 60 01 inc %o5
20265e0: da 2f 60 08 stb %o5, [ %i5 + 8 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
20265e4: 80 8b e0 01 btst 1, %o7
20265e8: 22 bf ff fc be,a 20265d8 <fat_init_volume_info+0x27c>
20265ec: da 0f 60 08 ldub [ %i5 + 8 ], %o5
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
20265f0: 84 08 a0 ff and %g2, 0xff, %g2
20265f4: 85 28 a0 08 sll %g2, 8, %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);
20265f8: f2 2f 60 09 stb %i1, [ %i5 + 9 ]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
20265fc: 88 09 20 ff and %g4, 0xff, %g4
2026600: 86 08 e0 ff and %g3, 0xff, %g3
2026604: 89 29 20 08 sll %g4, 8, %g4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
2026608: 82 08 60 ff and %g1, 0xff, %g1
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);
202660c: 86 11 00 03 or %g4, %g3, %g3
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
2026610: 82 10 80 01 or %g2, %g1, %g1
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);
2026614: c6 37 60 14 sth %g3, [ %i5 + 0x14 ]
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
2026618: c2 37 60 20 sth %g1, [ %i5 + 0x20 ]
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
202661c: 84 02 7f ff add %o1, -1, %g2
2026620: 83 28 60 10 sll %g1, 0x10, %g1
2026624: c6 27 bf 84 st %g3, [ %fp + -124 ]
2026628: 91 30 60 0b srl %g1, 0xb, %o0
202662c: 40 00 d3 8b call 205b458 <.div>
2026630: 90 02 00 02 add %o0, %g2, %o0
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
2026634: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
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)) /
2026638: d0 27 60 24 st %o0, [ %i5 + 0x24 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
202663c: 85 2a 00 02 sll %o0, %g2, %g2
2026640: c4 27 60 28 st %g2, [ %i5 + 0x28 ]
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
2026644: c4 0f bf 98 ldub [ %fp + -104 ], %g2
2026648: ae 0d e0 ff and %l7, 0xff, %l7
202664c: 85 28 a0 08 sll %g2, 8, %g2
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)) /
2026650: 82 10 00 08 mov %o0, %g1
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
2026654: ae 10 80 17 or %g2, %l7, %l7
2026658: af 2d e0 10 sll %l7, 0x10, %l7
202665c: 80 a5 e0 00 cmp %l7, 0
2026660: 02 80 00 05 be 2026674 <fat_init_volume_info+0x318> <== NEVER TAKEN
2026664: c6 07 bf 84 ld [ %fp + -124 ], %g3
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
2026668: af 35 e0 10 srl %l7, 0x10, %l7
202666c: 10 80 00 0c b 202669c <fat_init_volume_info+0x340>
2026670: ee 27 60 18 st %l7, [ %i5 + 0x18 ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
2026674: ac 0d a0 ff and %l6, 0xff, %l6 <== NOT EXECUTED
2026678: aa 0d 60 ff and %l5, 0xff, %l5 <== NOT EXECUTED
202667c: ad 2d a0 08 sll %l6, 8, %l6 <== NOT EXECUTED
2026680: ab 2d 60 10 sll %l5, 0x10, %l5 <== NOT EXECUTED
2026684: a8 0d 20 ff and %l4, 0xff, %l4 <== NOT EXECUTED
2026688: aa 15 80 15 or %l6, %l5, %l5 <== NOT EXECUTED
202668c: a7 2c e0 18 sll %l3, 0x18, %l3 <== NOT EXECUTED
2026690: a8 15 40 14 or %l5, %l4, %l4 <== NOT EXECUTED
2026694: a6 15 00 13 or %l4, %l3, %l3 <== NOT EXECUTED
2026698: e6 27 60 18 st %l3, [ %i5 + 0x18 ] <== NOT EXECUTED
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
202669c: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
20266a0: 87 28 e0 10 sll %g3, 0x10, %g3
20266a4: c2 27 bf 8c st %g1, [ %fp + -116 ]
20266a8: a7 30 e0 10 srl %g3, 0x10, %l3
20266ac: 7f ff 71 c4 call 2002dbc <.umul>
20266b0: 90 0e 60 ff and %i1, 0xff, %o0
20266b4: c2 07 bf 8c ld [ %fp + -116 ], %g1
20266b8: 90 04 c0 08 add %l3, %o0, %o0
20266bc: 82 00 40 08 add %g1, %o0, %g1
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
20266c0: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
20266c4: a4 0c a0 ff and %l2, 0xff, %l2
20266c8: a2 0c 60 ff and %l1, 0xff, %l1
20266cc: a5 2c a0 08 sll %l2, 8, %l2
20266d0: a2 14 80 11 or %l2, %l1, %l1
20266d4: a3 2c 60 10 sll %l1, 0x10, %l1
20266d8: 80 a4 60 00 cmp %l1, 0
20266dc: 02 80 00 05 be 20266f0 <fat_init_volume_info+0x394> <== NEVER TAKEN
20266e0: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
20266e4: a3 34 60 10 srl %l1, 0x10, %l1
20266e8: 10 80 00 0d b 202671c <fat_init_volume_info+0x3c0>
20266ec: e2 27 60 2c st %l1, [ %i5 + 0x2c ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
20266f0: c6 0f bf 9a ldub [ %fp + -102 ], %g3 <== NOT EXECUTED
20266f4: c4 0f bf 99 ldub [ %fp + -103 ], %g2 <== NOT EXECUTED
20266f8: c8 0f bf 97 ldub [ %fp + -105 ], %g4 <== NOT EXECUTED
20266fc: a0 0c 20 ff and %l0, 0xff, %l0 <== NOT EXECUTED
2026700: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2026704: a1 2c 20 08 sll %l0, 8, %l0 <== NOT EXECUTED
2026708: 84 14 00 02 or %l0, %g2, %g2 <== NOT EXECUTED
202670c: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2026710: 87 29 20 18 sll %g4, 0x18, %g3 <== NOT EXECUTED
2026714: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2026718: c4 27 60 2c st %g2, [ %i5 + 0x2c ] <== NOT EXECUTED
data_secs = vol->tot_secs - vol->data_fsec;
202671c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
vol->data_cls = data_secs / vol->spc;
2026720: 92 0e e0 ff and %i3, 0xff, %o1
2026724: 40 00 d3 4b call 205b450 <.udiv>
2026728: 90 22 00 01 sub %o0, %g1, %o0
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
202672c: 80 a2 2f f4 cmp %o0, 0xff4
2026730: 18 80 00 08 bgu 2026750 <fat_init_volume_info+0x3f4> <== NEVER TAKEN
2026734: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
{
vol->type = FAT_FAT12;
2026738: 82 10 20 01 mov 1, %g1
202673c: c2 2f 60 0a stb %g1, [ %i5 + 0xa ]
vol->mask = FAT_FAT12_MASK;
2026740: 82 10 2f ff mov 0xfff, %g1
2026744: c2 27 60 0c st %g1, [ %i5 + 0xc ]
vol->eoc_val = FAT_FAT12_EOC;
2026748: 10 80 00 0f b 2026784 <fat_init_volume_info+0x428>
202674c: 82 10 2f f8 mov 0xff8, %g1
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
2026750: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED
2026754: 84 10 63 f4 or %g1, 0x3f4, %g2 ! fff4 <PROM_START+0xfff4> <== NOT EXECUTED
2026758: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED
202675c: 38 80 00 05 bgu,a 2026770 <fat_init_volume_info+0x414> <== NOT EXECUTED
2026760: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
{
vol->type = FAT_FAT16;
2026764: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED
2026768: 10 80 00 04 b 2026778 <fat_init_volume_info+0x41c> <== NOT EXECUTED
202676c: c4 2f 60 0a stb %g2, [ %i5 + 0xa ] <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
2026770: c2 2f 60 0a stb %g1, [ %i5 + 0xa ] <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
2026774: 03 03 ff ff sethi %hi(0xffffc00), %g1 <== NOT EXECUTED
2026778: 84 10 63 ff or %g1, 0x3ff, %g2 ! fffffff <RAM_END+0xdbfffff><== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
202677c: 82 10 63 f8 or %g1, 0x3f8, %g1 <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
2026780: c4 27 60 0c st %g2, [ %i5 + 0xc ] <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
2026784: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
}
}
if (vol->type == FAT_FAT32)
2026788: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
202678c: 80 a0 60 04 cmp %g1, 4
2026790: 12 80 00 6f bne 202694c <fat_init_volume_info+0x5f0> <== ALWAYS TAKEN
2026794: 82 10 3f ff mov -1, %g1
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
2026798: c4 0f bf 9c ldub [ %fp + -100 ], %g2 <== NOT EXECUTED
202679c: c2 0f bf 9b ldub [ %fp + -101 ], %g1 <== NOT EXECUTED
20267a0: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
20267a4: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
20267a8: d6 0f bf a7 ldub [ %fp + -89 ], %o3 <== NOT EXECUTED
20267ac: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
20267b0: c4 0f bf 9d ldub [ %fp + -99 ], %g2 <== NOT EXECUTED
20267b4: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
20267b8: 85 2a e0 18 sll %o3, 0x18, %g2 <== NOT EXECUTED
20267bc: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
20267c0: c2 27 60 38 st %g1, [ %i5 + 0x38 ] <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
20267c4: 82 0e bf 80 and %i2, -128, %g1 <== NOT EXECUTED
if (vol->mirror)
20267c8: 80 88 60 80 btst 0x80, %g1 <== NOT EXECUTED
20267cc: 02 80 00 05 be 20267e0 <fat_init_volume_info+0x484> <== NOT EXECUTED
20267d0: c2 2f 60 48 stb %g1, [ %i5 + 0x48 ] <== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
20267d4: b4 0e a0 0f and %i2, 0xf, %i2 <== NOT EXECUTED
20267d8: 10 80 00 03 b 20267e4 <fat_init_volume_info+0x488> <== NOT EXECUTED
20267dc: f4 2f 60 50 stb %i2, [ %i5 + 0x50 ] <== NOT EXECUTED
else
vol->afat = 0;
20267e0: c0 2f 60 50 clrb [ %i5 + 0x50 ] <== NOT EXECUTED
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
20267e4: d2 0f bf 9e ldub [ %fp + -98 ], %o1 <== NOT EXECUTED
20267e8: c2 0f bf 9f ldub [ %fp + -97 ], %g1 <== NOT EXECUTED
20267ec: 93 2a 60 08 sll %o1, 8, %o1 <== NOT EXECUTED
20267f0: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
20267f4: d2 37 60 3c sth %o1, [ %i5 + 0x3c ] <== NOT EXECUTED
if( vol->info_sec == 0 )
20267f8: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
20267fc: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
2026800: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2026804: 02 80 00 1b be 2026870 <fat_init_volume_info+0x514> <== NOT EXECUTED
2026808: 01 00 00 00 nop <== NOT EXECUTED
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
202680c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2026810: 94 10 20 00 clr %o2 <== NOT EXECUTED
2026814: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2026818: 7f ff fd 84 call 2025e28 <_fat_block_read> <== NOT EXECUTED
202681c: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
2026820: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2026824: 06 80 00 23 bl 20268b0 <fat_init_volume_info+0x554> <== NOT EXECUTED
2026828: 01 00 00 00 nop <== NOT EXECUTED
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
202682c: c2 0f bf f2 ldub [ %fp + -14 ], %g1 <== NOT EXECUTED
2026830: c4 0f bf f1 ldub [ %fp + -15 ], %g2 <== NOT EXECUTED
2026834: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
2026838: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
202683c: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
2026840: c2 0f bf f0 ldub [ %fp + -16 ], %g1 <== NOT EXECUTED
2026844: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
2026848: c2 0f bf f3 ldub [ %fp + -13 ], %g1 <== NOT EXECUTED
202684c: 83 28 60 18 sll %g1, 0x18, %g1 <== NOT EXECUTED
2026850: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
2026854: 03 10 58 54 sethi %hi(0x41615000), %g1 <== NOT EXECUTED
2026858: 82 10 62 52 or %g1, 0x252, %g1 ! 41615252 <RAM_END+0x3f215252><== NOT EXECUTED
202685c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2026860: 22 80 00 0a be,a 2026888 <fat_init_volume_info+0x52c> <== NOT EXECUTED
2026864: d2 17 60 3c lduh [ %i5 + 0x3c ], %o1 <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
2026868: 7f ff fd 17 call 2025cc4 <fat_buf_release> <== NOT EXECUTED
202686c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
close(vol->fd);
2026870: 7f ff 87 09 call 2008494 <close> <== NOT EXECUTED
2026874: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
2026878: 40 00 6d 0a call 2041ca0 <__errno> <== NOT EXECUTED
202687c: 01 00 00 00 nop <== NOT EXECUTED
2026880: 10 80 00 8d b 2026ab4 <fat_init_volume_info+0x758> <== NOT EXECUTED
2026884: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
2026888: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
202688c: 94 10 21 e4 mov 0x1e4, %o2 <== NOT EXECUTED
2026890: 96 10 20 0c mov 0xc, %o3 <== NOT EXECUTED
2026894: 7f ff fd 65 call 2025e28 <_fat_block_read> <== NOT EXECUTED
2026898: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
202689c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20268a0: 16 80 00 08 bge 20268c0 <fat_init_volume_info+0x564> <== NOT EXECUTED
20268a4: c4 0f bf f5 ldub [ %fp + -11 ], %g2 <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
20268a8: 7f ff fd 07 call 2025cc4 <fat_buf_release> <== NOT EXECUTED
20268ac: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(mt_entry);
close(vol->fd);
20268b0: 7f ff 86 f9 call 2008494 <close> <== NOT EXECUTED
20268b4: d0 07 60 54 ld [ %i5 + 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 );
20268b8: 10 80 00 81 b 2026abc <fat_init_volume_info+0x760> <== NOT EXECUTED
20268bc: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
_fat_block_release(mt_entry);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
20268c0: c2 0f bf f6 ldub [ %fp + -10 ], %g1 <== NOT EXECUTED
20268c4: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
20268c8: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
20268cc: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
20268d0: c4 0f bf f4 ldub [ %fp + -12 ], %g2 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
20268d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
_fat_block_release(mt_entry);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
20268d8: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
20268dc: c4 0f bf f7 ldub [ %fp + -9 ], %g2 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
20268e0: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
_fat_block_release(mt_entry);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
20268e4: 85 28 a0 18 sll %g2, 0x18, %g2 <== NOT EXECUTED
20268e8: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
20268ec: c4 0f bf f9 ldub [ %fp + -7 ], %g2 <== NOT EXECUTED
_fat_block_release(mt_entry);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
20268f0: c2 27 60 40 st %g1, [ %i5 + 0x40 ] <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
20268f4: c2 0f bf fa ldub [ %fp + -6 ], %g1 <== NOT EXECUTED
20268f8: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
20268fc: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
2026900: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
2026904: c4 0f bf f8 ldub [ %fp + -8 ], %g2 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
2026908: 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);
202690c: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
2026910: c4 0f bf fb ldub [ %fp + -5 ], %g2 <== NOT EXECUTED
2026914: 85 28 a0 18 sll %g2, 0x18, %g2 <== NOT EXECUTED
2026918: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
202691c: 7f ff fe 2e call 20261d4 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
2026920: c2 27 60 44 st %g1, [ %i5 + 0x44 ] <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
2026924: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
2026928: 02 80 00 0e be 2026960 <fat_init_volume_info+0x604> <== NOT EXECUTED
202692c: 01 00 00 00 nop <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
2026930: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
2026934: 7f ff fc e4 call 2025cc4 <fat_buf_release> <== NOT EXECUTED
2026938: b8 10 00 1b mov %i3, %i4 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
0xFFFFFFFF);
if ( rc != RC_OK )
{
_fat_block_release(mt_entry);
close(vol->fd);
202693c: 7f ff 86 d6 call 2008494 <close> <== NOT EXECUTED
2026940: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED
return rc;
2026944: 81 c7 e0 08 ret <== NOT EXECUTED
2026948: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
202694c: c0 27 60 38 clr [ %i5 + 0x38 ]
vol->mirror = 0;
2026950: c0 2f 60 48 clrb [ %i5 + 0x48 ]
vol->afat = 0;
2026954: c0 2f 60 50 clrb [ %i5 + 0x50 ]
vol->free_cls = 0xFFFFFFFF;
2026958: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
vol->next_cl = 0xFFFFFFFF;
202695c: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
2026960: 7f ff fc d9 call 2025cc4 <fat_buf_release>
2026964: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
2026968: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
202696c: 7f ff 71 14 call 2002dbc <.umul>
2026970: d0 0f 60 50 ldub [ %i5 + 0x50 ], %o0
2026974: c2 17 60 14 lduh [ %i5 + 0x14 ], %g1
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
2026978: 92 10 20 0c mov 0xc, %o1
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
202697c: 82 02 00 01 add %o0, %g1, %g1
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
2026980: 90 10 20 02 mov 2, %o0
2026984: 7f ff 86 9f call 2008400 <calloc>
2026988: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
if ( fs_info->vhash == NULL )
202698c: 80 a2 20 00 cmp %o0, 0
2026990: 02 80 00 12 be 20269d8 <fat_init_volume_info+0x67c> <== NEVER TAKEN
2026994: d0 27 60 60 st %o0, [ %i5 + 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 );
2026998: 82 02 20 04 add %o0, 4, %g1
202699c: 84 02 20 10 add %o0, 0x10, %g2
head->next = tail;
20269a0: c2 22 00 00 st %g1, [ %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 );
20269a4: 82 02 20 0c add %o0, 0xc, %g1
head->next = tail;
head->previous = NULL;
20269a8: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
20269ac: 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;
20269b0: c4 22 20 0c st %g2, [ %o0 + 0xc ]
head->previous = NULL;
20269b4: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
20269b8: c2 22 20 14 st %g1, [ %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));
20269bc: 92 10 20 0c mov 0xc, %o1
20269c0: 7f ff 86 90 call 2008400 <calloc>
20269c4: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
20269c8: 80 a2 20 00 cmp %o0, 0
20269cc: 12 80 00 06 bne 20269e4 <fat_init_volume_info+0x688> <== ALWAYS TAKEN
20269d0: d0 27 60 64 st %o0, [ %i5 + 0x64 ]
20269d4: 30 80 00 1c b,a 2026a44 <fat_init_volume_info+0x6e8> <== 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);
20269d8: 7f ff 86 af call 2008494 <close> <== NOT EXECUTED
20269dc: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED
20269e0: 30 80 00 32 b,a 2026aa8 <fat_init_volume_info+0x74c> <== 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 );
20269e4: 82 02 20 04 add %o0, 4, %g1
head->next = tail;
20269e8: c2 22 00 00 st %g1, [ %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 );
20269ec: 82 02 20 0c add %o0, 0xc, %g1
head->next = tail;
head->previous = NULL;
20269f0: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
20269f4: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
20269f8: 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;
20269fc: 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 );
2026a00: 84 02 20 10 add %o0, 0x10, %g2
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;
2026a04: 82 10 21 00 mov 0x100, %g1
head->next = tail;
2026a08: c4 22 20 0c st %g2, [ %o0 + 0xc ]
2026a0c: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
2026a10: c4 07 60 2c ld [ %i5 + 0x2c ], %g2
2026a14: c2 0f 60 03 ldub [ %i5 + 3 ], %g1
fs_info->index = 0;
2026a18: c0 27 60 6c clr [ %i5 + 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;
2026a1c: 83 28 80 01 sll %g2, %g1, %g1
2026a20: 83 28 60 04 sll %g1, 4, %g1
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
2026a24: 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;
2026a28: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
2026a2c: 7f ff 86 75 call 2008400 <calloc>
2026a30: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
2026a34: 80 a2 20 00 cmp %o0, 0
2026a38: 12 80 00 0d bne 2026a6c <fat_init_volume_info+0x710> <== ALWAYS TAKEN
2026a3c: d0 27 60 68 st %o0, [ %i5 + 0x68 ]
2026a40: 30 80 00 05 b,a 2026a54 <fat_init_volume_info+0x6f8> <== 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);
2026a44: 7f ff 86 94 call 2008494 <close> <== NOT EXECUTED
2026a48: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2026a4c: 10 80 00 15 b 2026aa0 <fat_init_volume_info+0x744> <== NOT EXECUTED
2026a50: d0 07 60 60 ld [ %i5 + 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);
2026a54: 7f ff 86 90 call 2008494 <close> <== NOT EXECUTED
2026a58: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2026a5c: 7f ff 87 47 call 2008778 <free> <== NOT EXECUTED
2026a60: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2026a64: 10 80 00 0f b 2026aa0 <fat_init_volume_info+0x744> <== NOT EXECUTED
2026a68: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
2026a6c: d0 17 40 00 lduh [ %i5 ], %o0
2026a70: 7f ff 86 64 call 2008400 <calloc>
2026a74: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
2026a78: 80 a2 20 00 cmp %o0, 0
2026a7c: 12 80 00 10 bne 2026abc <fat_init_volume_info+0x760> <== ALWAYS TAKEN
2026a80: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
{
close(vol->fd);
2026a84: 7f ff 86 84 call 2008494 <close> <== NOT EXECUTED
2026a88: d0 07 60 54 ld [ %i5 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2026a8c: 7f ff 87 3b call 2008778 <free> <== NOT EXECUTED
2026a90: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2026a94: 7f ff 87 39 call 2008778 <free> <== NOT EXECUTED
2026a98: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
2026a9c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
2026aa0: 7f ff 87 36 call 2008778 <free> <== NOT EXECUTED
2026aa4: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
2026aa8: 40 00 6c 7e call 2041ca0 <__errno> <== NOT EXECUTED
2026aac: 01 00 00 00 nop <== NOT EXECUTED
2026ab0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2026ab4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2026ab8: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
}
return RC_OK;
}
2026abc: b0 10 00 1c mov %i4, %i0
2026ac0: 81 c7 e0 08 ret
2026ac4: 81 e8 00 00 restore
0203d9c4 <fat_scan_fat_for_free_clusters>:
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
203d9c4: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
203d9c8: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
uint32_t cl4find = 2;
uint32_t next_cln = 0;
203d9cc: c0 27 bf fc clr [ %fp + -4 ]
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
203d9d0: e8 04 60 34 ld [ %l1 + 0x34 ], %l4
uint32_t i = 2;
*cls_added = 0;
203d9d4: c0 26 c0 00 clr [ %i3 ]
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
203d9d8: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
203d9dc: a8 05 20 02 add %l4, 2, %l4
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
203d9e0: 80 a6 a0 00 cmp %i2, 0
203d9e4: 02 80 00 16 be 203da3c <fat_scan_fat_for_free_clusters+0x78><== NEVER TAKEN
203d9e8: b0 10 20 00 clr %i0
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
203d9ec: e0 04 60 44 ld [ %l1 + 0x44 ], %l0
203d9f0: 80 a4 3f ff cmp %l0, -1
203d9f4: 22 80 00 02 be,a 203d9fc <fat_scan_fat_for_free_clusters+0x38>
203d9f8: a0 10 20 02 mov 2, %l0
}
}
i++;
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
203d9fc: a6 10 20 02 mov 2, %l3
203da00: 10 80 00 55 b 203db54 <fat_scan_fat_for_free_clusters+0x190>
203da04: 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(mt_entry, cl4find, &next_cln);
203da08: 92 10 00 10 mov %l0, %o1
203da0c: 7f ff fe 9f call 203d488 <fat_get_fat_cluster>
203da10: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
203da14: b0 92 20 00 orcc %o0, 0, %i0
203da18: 02 80 00 0b be 203da44 <fat_scan_fat_for_free_clusters+0x80><== ALWAYS TAKEN
203da1c: c2 07 bf fc ld [ %fp + -4 ], %g1
{
if (*cls_added != 0)
203da20: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
203da24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203da28: 02 80 00 5b be 203db94 <fat_scan_fat_for_free_clusters+0x1d0><== NOT EXECUTED
203da2c: 01 00 00 00 nop <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
203da30: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
203da34: 7f ff ff b4 call 203d904 <fat_free_fat_clusters_chain> <== NOT EXECUTED
203da38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203da3c: 81 c7 e0 08 ret <== NOT EXECUTED
203da40: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
203da44: 80 a0 60 00 cmp %g1, 0
203da48: 32 80 00 3f bne,a 203db44 <fat_scan_fat_for_free_clusters+0x180>
203da4c: 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)
203da50: c2 06 c0 00 ld [ %i3 ], %g1
203da54: 80 a0 60 00 cmp %g1, 0
203da58: 12 80 00 0b bne 203da84 <fat_scan_fat_for_free_clusters+0xc0><== NEVER TAKEN
203da5c: 90 10 00 1d mov %i5, %o0
{
*chain = cl4find;
203da60: e0 26 40 00 st %l0, [ %i1 ]
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
203da64: 92 10 00 10 mov %l0, %o1
203da68: 7f ff fe f8 call 203d648 <fat_set_fat_cluster>
203da6c: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
203da70: 80 a2 20 00 cmp %o0, 0
203da74: 22 80 00 22 be,a 203dafc <fat_scan_fat_for_free_clusters+0x138><== ALWAYS TAKEN
203da78: c2 06 c0 00 ld [ %i3 ], %g1
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
203da7c: 81 c7 e0 08 ret <== NOT EXECUTED
203da80: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
203da84: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203da88: 7f ff fe f0 call 203d648 <fat_set_fat_cluster> <== NOT EXECUTED
203da8c: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
203da90: aa 10 00 08 mov %o0, %l5 <== NOT EXECUTED
if ( rc != RC_OK )
203da94: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
203da98: 02 80 00 07 be 203dab4 <fat_scan_fat_for_free_clusters+0xf0><== NOT EXECUTED
203da9c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
203daa0: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
203daa4: 7f ff ff 98 call 203d904 <fat_free_fat_clusters_chain> <== NOT EXECUTED
203daa8: b0 10 00 15 mov %l5, %i0 <== NOT EXECUTED
return rc;
203daac: 81 c7 e0 08 ret <== NOT EXECUTED
203dab0: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
203dab4: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
203dab8: 7f ff fe e4 call 203d648 <fat_set_fat_cluster> <== NOT EXECUTED
203dabc: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
203dac0: a4 92 20 00 orcc %o0, 0, %l2 <== NOT EXECUTED
203dac4: 22 80 00 0e be,a 203dafc <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
203dac8: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
203dacc: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
203dad0: 7f ff ff 8d call 203d904 <fat_free_fat_clusters_chain> <== NOT EXECUTED
203dad4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
203dad8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203dadc: 94 10 20 00 clr %o2 <== NOT EXECUTED
203dae0: 7f ff fe da call 203d648 <fat_set_fat_cluster> <== NOT EXECUTED
203dae4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_buf_release(fs_info);
203dae8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
203daec: 7f ff a0 76 call 2025cc4 <fat_buf_release> <== NOT EXECUTED
203daf0: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
return rc;
203daf4: 81 c7 e0 08 ret <== NOT EXECUTED
203daf8: 81 e8 00 00 restore <== NOT EXECUTED
}
}
save_cln = cl4find;
(*cls_added)++;
203dafc: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
203db00: 80 a0 40 1a cmp %g1, %i2
203db04: 12 80 00 0e bne 203db3c <fat_scan_fat_for_free_clusters+0x178><== NEVER TAKEN
203db08: c2 26 c0 00 st %g1, [ %i3 ]
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
203db0c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1
203db10: 80 a0 7f ff cmp %g1, -1
203db14: 02 80 00 05 be 203db28 <fat_scan_fat_for_free_clusters+0x164><== ALWAYS TAKEN
203db18: e0 24 60 44 st %l0, [ %l1 + 0x44 ]
fs_info->vol.free_cls -= (*cls_added);
203db1c: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
203db20: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
203db24: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED
*last_cl = save_cln;
203db28: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
203db2c: 7f ff a0 66 call 2025cc4 <fat_buf_release>
203db30: 90 10 00 11 mov %l1, %o0
return rc;
203db34: 81 c7 e0 08 ret
203db38: 81 e8 00 00 restore
save_cln = cl4find;
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
203db3c: a4 10 00 10 mov %l0, %l2 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
203db40: a0 04 20 01 inc %l0 <== NOT EXECUTED
if (cl4find >= data_cls_val)
203db44: 80 a4 00 14 cmp %l0, %l4
203db48: 0a 80 00 03 bcs 203db54 <fat_scan_fat_for_free_clusters+0x190><== ALWAYS TAKEN
203db4c: a6 04 e0 01 inc %l3
cl4find = 2;
203db50: 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)
203db54: 80 a4 c0 14 cmp %l3, %l4
203db58: 0a bf ff ac bcs 203da08 <fat_scan_fat_for_free_clusters+0x44><== ALWAYS TAKEN
203db5c: 90 10 00 1d mov %i5, %o0
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
203db60: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED
203db64: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
203db68: 02 80 00 05 be 203db7c <fat_scan_fat_for_free_clusters+0x1b8><== NOT EXECUTED
203db6c: e4 24 60 44 st %l2, [ %l1 + 0x44 ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
203db70: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
203db74: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
203db78: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED
*last_cl = save_cln;
203db7c: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
203db80: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
203db84: 7f ff a0 50 call 2025cc4 <fat_buf_release> <== NOT EXECUTED
203db88: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
203db8c: 81 c7 e0 08 ret <== NOT EXECUTED
203db90: 81 e8 00 00 restore <== NOT EXECUTED
}
203db94: 81 c7 e0 08 ret <== NOT EXECUTED
203db98: 81 e8 00 00 restore <== NOT EXECUTED
0203d648 <fat_set_fat_cluster>:
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
203d648: 9d e3 bf 98 save %sp, -104, %sp
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
203d64c: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
203d650: 80 a6 60 01 cmp %i1, 1
203d654: 08 80 00 07 bleu 203d670 <fat_set_fat_cluster+0x28> <== NEVER TAKEN
203d658: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
203d65c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
203d660: 82 00 60 01 inc %g1
203d664: 80 a6 40 01 cmp %i1, %g1
203d668: 28 80 00 08 bleu,a 203d688 <fat_set_fat_cluster+0x40> <== ALWAYS TAKEN
203d66c: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
rtems_set_errno_and_return_minus_one(EIO);
203d670: 40 00 11 8c call 2041ca0 <__errno> <== NOT EXECUTED
203d674: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d678: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
203d67c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203d680: 81 c7 e0 08 ret <== NOT EXECUTED
203d684: 81 e8 00 00 restore <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
203d688: b7 36 60 01 srl %i1, 1, %i3
203d68c: 84 88 60 01 andcc %g1, 1, %g2
203d690: 12 80 00 06 bne 203d6a8 <fat_set_fat_cluster+0x60> <== ALWAYS TAKEN
203d694: b6 06 c0 19 add %i3, %i1, %i3
203d698: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
203d69c: 02 80 00 03 be 203d6a8 <fat_set_fat_cluster+0x60> <== NOT EXECUTED
203d6a0: b7 2e 60 02 sll %i1, 2, %i3 <== NOT EXECUTED
203d6a4: b7 2e 60 01 sll %i1, 1, %i3 <== NOT EXECUTED
203d6a8: 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);
203d6ac: b9 36 60 01 srl %i1, 1, %i4
/* 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) +
203d6b0: b7 36 c0 03 srl %i3, %g3, %i3
203d6b4: 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);
203d6b8: b8 07 00 19 add %i4, %i1, %i4
203d6bc: 80 a0 a0 00 cmp %g2, 0
203d6c0: 12 80 00 06 bne 203d6d8 <fat_set_fat_cluster+0x90> <== ALWAYS TAKEN
203d6c4: b6 06 c0 03 add %i3, %g3, %i3
203d6c8: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
203d6cc: 02 80 00 03 be 203d6d8 <fat_set_fat_cluster+0x90> <== NOT EXECUTED
203d6d0: b9 2e 60 02 sll %i1, 2, %i4 <== NOT EXECUTED
203d6d4: b9 2e 60 01 sll %i1, 1, %i4 <== NOT EXECUTED
203d6d8: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
203d6dc: 90 10 00 1d mov %i5, %o0
203d6e0: 92 10 00 1b mov %i3, %o1
203d6e4: 94 10 20 01 mov 1, %o2
203d6e8: 7f ff a0 f9 call 2025acc <fat_buf_access>
203d6ec: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
203d6f0: b0 92 20 00 orcc %o0, 0, %i0
203d6f4: 12 bf ff e3 bne 203d680 <fat_set_fat_cluster+0x38> <== NEVER TAKEN
203d6f8: a1 2c 20 10 sll %l0, 0x10, %l0
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);
203d6fc: a1 34 20 10 srl %l0, 0x10, %l0
203d700: a0 04 3f ff add %l0, -1, %l0
203d704: a0 0f 00 10 and %i4, %l0, %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
203d708: f8 0f 60 0a ldub [ %i5 + 0xa ], %i4
203d70c: 80 a7 20 02 cmp %i4, 2
203d710: 02 80 00 5f be 203d88c <fat_set_fat_cluster+0x244> <== NEVER TAKEN
203d714: 80 a7 20 04 cmp %i4, 4
203d718: 02 80 00 65 be 203d8ac <fat_set_fat_cluster+0x264> <== NEVER TAKEN
203d71c: 80 a7 20 01 cmp %i4, 1
203d720: 12 80 00 73 bne 203d8ec <fat_set_fat_cluster+0x2a4> <== NEVER TAKEN
203d724: 80 8e 60 01 btst 1, %i1
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
203d728: 02 80 00 29 be 203d7cc <fat_set_fat_cluster+0x184>
203d72c: 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;
203d730: 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)) =
203d734: c4 08 40 10 ldub [ %g1 + %l0 ], %g2
203d738: 84 08 a0 0f and %g2, 0xf, %g2
203d73c: c4 28 40 10 stb %g2, [ %g1 + %l0 ]
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
203d740: 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)) =
203d744: 85 2e a0 04 sll %i2, 4, %g2
(*((uint8_t *)(block0->buffer + ofs))) |
203d748: 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)) =
203d74c: c6 08 40 10 ldub [ %g1 + %l0 ], %g3
203d750: 84 10 c0 02 or %g3, %g2, %g2
203d754: c4 28 40 10 stb %g2, [ %g1 + %l0 ]
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
203d758: c2 17 40 00 lduh [ %i5 ], %g1
203d75c: 82 00 7f ff add %g1, -1, %g1
203d760: 80 a4 00 01 cmp %l0, %g1
203d764: 12 80 00 11 bne 203d7a8 <fat_set_fat_cluster+0x160> <== ALWAYS TAKEN
203d768: f8 2f 60 7c stb %i4, [ %i5 + 0x7c ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
203d76c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203d770: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
203d774: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203d778: 7f ff a0 d5 call 2025acc <fat_buf_access> <== NOT EXECUTED
203d77c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
203d780: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203d784: 12 bf ff bf bne 203d680 <fat_set_fat_cluster+0x38> <== NOT EXECUTED
203d788: 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);
203d78c: 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;
203d790: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
203d794: 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;
203d798: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
203d79c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
203d7a0: 10 80 00 27 b 203d83c <fat_set_fat_cluster+0x1f4> <== NOT EXECUTED
203d7a4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
203d7a8: c2 07 bf fc ld [ %fp + -4 ], %g1
203d7ac: a0 04 20 01 inc %l0
203d7b0: 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);
203d7b4: b5 2e a0 14 sll %i2, 0x14, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
203d7b8: c0 28 40 10 clrb [ %g1 + %l0 ]
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
203d7bc: c2 07 bf fc ld [ %fp + -4 ], %g1
(uint8_t )((fat16_clv & 0xFF00)>>8);
203d7c0: 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))) |
203d7c4: 10 80 00 2d b 203d878 <fat_set_fat_cluster+0x230>
203d7c8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
203d7cc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
203d7d0: b4 0e af ff and %i2, 0xfff, %i2
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
203d7d4: c0 28 40 10 clrb [ %g1 + %l0 ]
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
203d7d8: c2 07 bf fc ld [ %fp + -4 ], %g1
203d7dc: 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)) =
203d7e0: c4 08 40 10 ldub [ %g1 + %l0 ], %g2
203d7e4: 84 16 80 02 or %i2, %g2, %g2
203d7e8: c4 28 40 10 stb %g2, [ %g1 + %l0 ]
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
203d7ec: c2 17 40 00 lduh [ %i5 ], %g1
203d7f0: 82 00 7f ff add %g1, -1, %g1
203d7f4: 80 a4 00 01 cmp %l0, %g1
203d7f8: 12 80 00 17 bne 203d854 <fat_set_fat_cluster+0x20c> <== ALWAYS TAKEN
203d7fc: f8 2f 60 7c stb %i4, [ %i5 + 0x7c ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
203d800: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203d804: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
203d808: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203d80c: 7f ff a0 b0 call 2025acc <fat_buf_access> <== NOT EXECUTED
203d810: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
203d814: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203d818: 12 bf ff 9a bne 203d680 <fat_set_fat_cluster+0x38> <== NOT EXECUTED
203d81c: 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);
203d820: 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;
203d824: 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)) =
203d828: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
203d82c: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
203d830: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
203d834: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
203d838: 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)) =
203d83c: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
203d840: b4 16 80 02 or %i2, %g2, %i2 <== NOT EXECUTED
203d844: 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;
203d848: f8 2f 60 7c stb %i4, [ %i5 + 0x7c ] <== NOT EXECUTED
203d84c: 81 c7 e0 08 ret <== NOT EXECUTED
203d850: 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;
203d854: c2 07 bf fc ld [ %fp + -4 ], %g1
203d858: a0 04 20 01 inc %l0
203d85c: 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);
203d860: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
203d864: c4 08 40 10 ldub [ %g1 + %l0 ], %g2
203d868: 84 08 bf f0 and %g2, -16, %g2
203d86c: c4 28 40 10 stb %g2, [ %g1 + %l0 ]
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
203d870: c2 07 bf fc ld [ %fp + -4 ], %g1
203d874: 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)) =
203d878: c4 08 40 10 ldub [ %g1 + %l0 ], %g2
203d87c: b4 10 80 1a or %g2, %i2, %i2
203d880: f4 28 40 10 stb %i2, [ %g1 + %l0 ]
203d884: 81 c7 e0 08 ret
203d888: 81 e8 00 00 restore
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
203d88c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
203d890: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
203d894: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
203d898: 85 36 a0 08 srl %i2, 8, %g2 <== NOT EXECUTED
203d89c: b5 36 a0 18 srl %i2, 0x18, %i2 <== NOT EXECUTED
203d8a0: b4 10 80 1a or %g2, %i2, %i2 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
203d8a4: 10 80 00 0e b 203d8dc <fat_set_fat_cluster+0x294> <== NOT EXECUTED
203d8a8: f4 30 40 10 sth %i2, [ %g1 + %l0 ] <== 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));
203d8ac: 11 3c 00 00 sethi %hi(0xf0000000), %o0 <== NOT EXECUTED
203d8b0: 7f ff fe ea call 203d458 <CPU_swap_u32> <== NOT EXECUTED
203d8b4: 90 2e 80 08 andn %i2, %o0, %o0 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
203d8b8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== 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));
203d8bc: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
203d8c0: f8 00 60 1c ld [ %g1 + 0x1c ], %i4 <== NOT EXECUTED
203d8c4: 7f ff fe e5 call 203d458 <CPU_swap_u32> <== NOT EXECUTED
203d8c8: 11 3c 00 00 sethi %hi(0xf0000000), %o0 <== NOT EXECUTED
203d8cc: c2 07 00 10 ld [ %i4 + %l0 ], %g1 <== NOT EXECUTED
203d8d0: 82 0a 00 01 and %o0, %g1, %g1 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
fat32_clv | (*((uint32_t *)(block0->buffer + ofs)));
203d8d4: b6 10 40 1b or %g1, %i3, %i3 <== 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)) =
203d8d8: f6 27 00 10 st %i3, [ %i4 + %l0 ] <== NOT EXECUTED
203d8dc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
203d8e0: c2 2f 60 7c stb %g1, [ %i5 + 0x7c ] <== NOT EXECUTED
203d8e4: 81 c7 e0 08 ret <== NOT EXECUTED
203d8e8: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
203d8ec: 40 00 10 ed call 2041ca0 <__errno> <== NOT EXECUTED
203d8f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d8f4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
203d8f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
203d8fc: 81 c7 e0 08 ret <== NOT EXECUTED
203d900: 81 e8 00 00 restore <== NOT EXECUTED
02026248 <fat_shutdown_drive>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
2026248: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
202624c: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
2026250: 90 10 00 18 mov %i0, %o0
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
2026254: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
2026258: 80 88 60 04 btst 4, %g1
202625c: 02 80 00 08 be 202627c <fat_shutdown_drive+0x34> <== ALWAYS TAKEN
2026260: b8 10 20 00 clr %i4
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
2026264: d2 07 60 40 ld [ %i5 + 0x40 ], %o1 <== NOT EXECUTED
2026268: 7f ff ff db call 20261d4 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
202626c: d4 07 60 44 ld [ %i5 + 0x44 ], %o2 <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
2026270: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2026274: 32 80 00 02 bne,a 202627c <fat_shutdown_drive+0x34> <== NOT EXECUTED
2026278: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
rc = -1;
}
fat_buf_release(fs_info);
202627c: 7f ff fe 92 call 2025cc4 <fat_buf_release>
2026280: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
2026284: 7f ff 81 36 call 200675c <rtems_bdbuf_syncdev>
2026288: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
202628c: 80 a2 20 00 cmp %o0, 0
2026290: 32 80 00 02 bne,a 2026298 <fat_shutdown_drive+0x50> <== NEVER TAKEN
2026294: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
rc = -1;
2026298: b6 10 20 00 clr %i3
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
202629c: f4 07 60 60 ld [ %i5 + 0x60 ], %i2
while ( (node = rtems_chain_get(the_chain)) != NULL )
20262a0: 10 80 00 04 b 20262b0 <fat_shutdown_drive+0x68>
20262a4: b4 06 80 1b add %i2, %i3, %i2
free(node);
20262a8: 7f ff 89 34 call 2008778 <free> <== NOT EXECUTED
20262ac: 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 );
20262b0: 7f ff 9e fd call 200dea4 <_Chain_Get>
20262b4: 90 10 00 1a mov %i2, %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 )
20262b8: 80 a2 20 00 cmp %o0, 0
20262bc: 12 bf ff fb bne 20262a8 <fat_shutdown_drive+0x60> <== NEVER TAKEN
20262c0: 01 00 00 00 nop
20262c4: b6 06 e0 0c add %i3, 0xc, %i3
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++)
20262c8: 80 a6 e0 18 cmp %i3, 0x18
20262cc: 32 bf ff f5 bne,a 20262a0 <fat_shutdown_drive+0x58>
20262d0: f4 07 60 60 ld [ %i5 + 0x60 ], %i2
20262d4: b6 10 20 00 clr %i3
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
20262d8: f4 07 60 64 ld [ %i5 + 0x64 ], %i2
while ( (node = rtems_chain_get(the_chain)) != NULL )
20262dc: 10 80 00 04 b 20262ec <fat_shutdown_drive+0xa4>
20262e0: b4 06 80 1b add %i2, %i3, %i2
free(node);
20262e4: 7f ff 89 25 call 2008778 <free> <== NOT EXECUTED
20262e8: 01 00 00 00 nop <== NOT EXECUTED
20262ec: 7f ff 9e ee call 200dea4 <_Chain_Get>
20262f0: 90 10 00 1a mov %i2, %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 )
20262f4: 80 a2 20 00 cmp %o0, 0
20262f8: 12 bf ff fb bne 20262e4 <fat_shutdown_drive+0x9c> <== NEVER TAKEN
20262fc: 01 00 00 00 nop
2026300: b6 06 e0 0c add %i3, 0xc, %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
2026304: 80 a6 e0 18 cmp %i3, 0x18
2026308: 32 bf ff f5 bne,a 20262dc <fat_shutdown_drive+0x94>
202630c: f4 07 60 64 ld [ %i5 + 0x64 ], %i2
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
2026310: 7f ff 89 1a call 2008778 <free>
2026314: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
free(fs_info->rhash);
2026318: 7f ff 89 18 call 2008778 <free>
202631c: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
free(fs_info->uino);
2026320: 7f ff 89 16 call 2008778 <free>
2026324: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free(fs_info->sec_buf);
2026328: 7f ff 89 14 call 2008778 <free>
202632c: d0 07 60 84 ld [ %i5 + 0x84 ], %o0
close(fs_info->vol.fd);
2026330: 7f ff 88 59 call 2008494 <close>
2026334: d0 07 60 54 ld [ %i5 + 0x54 ], %o0
if (rc)
2026338: 80 a7 20 00 cmp %i4, 0
202633c: 02 80 00 06 be 2026354 <fat_shutdown_drive+0x10c> <== ALWAYS TAKEN
2026340: 01 00 00 00 nop
errno = EIO;
2026344: 40 00 6e 57 call 2041ca0 <__errno> <== NOT EXECUTED
2026348: 01 00 00 00 nop <== NOT EXECUTED
202634c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2026350: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
2026354: 81 c7 e0 08 ret
2026358: 91 e8 00 1c restore %g0, %i4, %o0
0203dd50 <fchdir>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchdir( int fd )
{
203dd50: 9d e3 bf 38 save %sp, -200, %sp
st.st_mode = 0;
st.st_uid = 0;
st.st_gid = 0;
rtems_libio_check_fd( fd );
203dd54: 03 00 81 ab sethi %hi(0x206ac00), %g1
203dd58: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 206afc0 <rtems_libio_number_iops>
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
203dd5c: c0 27 bf a4 clr [ %fp + -92 ]
st.st_uid = 0;
203dd60: c0 37 bf aa clrh [ %fp + -86 ]
st.st_gid = 0;
rtems_libio_check_fd( fd );
203dd64: 80 a6 00 01 cmp %i0, %g1
203dd68: 1a 80 00 0c bcc 203dd98 <fchdir+0x48>
203dd6c: c0 37 bf ac clrh [ %fp + -84 ]
iop = rtems_libio_iop( fd );
203dd70: bb 2e 20 03 sll %i0, 3, %i5
203dd74: 03 00 81 bc sethi %hi(0x206f000), %g1
203dd78: b1 2e 20 06 sll %i0, 6, %i0
203dd7c: b0 07 40 18 add %i5, %i0, %i0
203dd80: fa 00 61 48 ld [ %g1 + 0x148 ], %i5
203dd84: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open( iop );
203dd88: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
203dd8c: 80 88 61 00 btst 0x100, %g1
203dd90: 32 80 00 08 bne,a 203ddb0 <fchdir+0x60>
203dd94: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
203dd98: 40 00 0f c2 call 2041ca0 <__errno>
203dd9c: b0 10 3f ff mov -1, %i0
203dda0: 82 10 20 09 mov 9, %g1
203dda4: c2 22 00 00 st %g1, [ %o0 ]
203dda8: 81 c7 e0 08 ret
203ddac: 81 e8 00 00 restore
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->lock_h)( loc->mt_entry );
203ddb0: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
203ddb4: c2 00 40 00 ld [ %g1 ], %g1
203ddb8: 9f c0 40 00 call %g1
203ddbc: b8 07 60 1c add %i5, 0x1c, %i4
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
203ddc0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
203ddc4: 90 10 00 1c mov %i4, %o0
203ddc8: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
203ddcc: 9f c0 40 00 call %g1
203ddd0: 92 07 bf 98 add %fp, -104, %o1
if ( rv == 0 ) {
203ddd4: b0 92 20 00 orcc %o0, 0, %i0
203ddd8: 32 80 00 14 bne,a 203de28 <fchdir+0xd8> <== NEVER TAKEN
203dddc: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
bool access_ok = rtems_filesystem_check_access(
203dde0: d2 07 bf a4 ld [ %fp + -92 ], %o1
203dde4: d4 17 bf aa lduh [ %fp + -86 ], %o2
203dde8: d6 17 bf ac lduh [ %fp + -84 ], %o3
203ddec: 7f ff ac 28 call 2028e8c <rtems_filesystem_check_access>
203ddf0: 90 10 20 01 mov 1, %o0
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
203ddf4: 80 8a 20 ff btst 0xff, %o0
203ddf8: 02 80 00 07 be 203de14 <fchdir+0xc4>
203ddfc: 01 00 00 00 nop
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
203de00: 90 07 bf e4 add %fp, -28, %o0
203de04: 7f ff a6 11 call 2027648 <rtems_filesystem_location_clone>
203de08: 92 10 00 1c mov %i4, %o1
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->unlock_h)( loc->mt_entry );
203de0c: 10 80 00 07 b 203de28 <fchdir+0xd8>
203de10: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
} else {
errno = EACCES;
203de14: 40 00 0f a3 call 2041ca0 <__errno>
203de18: b0 10 3f ff mov -1, %i0
203de1c: 82 10 20 0d mov 0xd, %g1
203de20: c2 22 00 00 st %g1, [ %o0 ]
203de24: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
203de28: c2 00 60 04 ld [ %g1 + 4 ], %g1
203de2c: 9f c0 40 00 call %g1
203de30: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
rv = -1;
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
203de34: 80 a6 20 00 cmp %i0, 0
203de38: 12 80 00 05 bne 203de4c <fchdir+0xfc>
203de3c: 01 00 00 00 nop
rv = rtems_filesystem_chdir( &loc );
203de40: 7f ff a5 7e call 2027438 <rtems_filesystem_chdir>
203de44: 90 07 bf e4 add %fp, -28, %o0
203de48: b0 10 00 08 mov %o0, %i0
}
return rv;
}
203de4c: 81 c7 e0 08 ret
203de50: 81 e8 00 00 restore
02027690 <fchmod>:
#include <sys/stat.h>
#include <rtems/libio_.h>
int fchmod( int fd, mode_t mode )
{
2027690: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2027694: 03 00 81 ab sethi %hi(0x206ac00), %g1
2027698: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 206afc0 <rtems_libio_number_iops>
202769c: 80 a6 00 01 cmp %i0, %g1
20276a0: 1a 80 00 0c bcc 20276d0 <fchmod+0x40>
20276a4: 01 00 00 00 nop
iop = rtems_libio_iop( fd );
20276a8: bb 2e 20 03 sll %i0, 3, %i5
20276ac: 03 00 81 bc sethi %hi(0x206f000), %g1
20276b0: b1 2e 20 06 sll %i0, 6, %i0
20276b4: b0 07 40 18 add %i5, %i0, %i0
20276b8: fa 00 61 48 ld [ %g1 + 0x148 ], %i5
20276bc: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
20276c0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
20276c4: 80 88 61 00 btst 0x100, %g1
20276c8: 32 80 00 08 bne,a 20276e8 <fchmod+0x58>
20276cc: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
20276d0: 40 00 69 74 call 2041ca0 <__errno>
20276d4: b0 10 3f ff mov -1, %i0
20276d8: 82 10 20 09 mov 9, %g1
20276dc: c2 22 00 00 st %g1, [ %o0 ]
20276e0: 81 c7 e0 08 ret
20276e4: 81 e8 00 00 restore
if (iop->pathinfo.mt_entry->writeable) {
20276e8: c2 0a 20 1d ldub [ %o0 + 0x1d ], %g1
20276ec: 80 a0 60 00 cmp %g1, 0
20276f0: 02 80 00 12 be 2027738 <fchmod+0xa8> <== NEVER TAKEN
20276f4: 01 00 00 00 nop
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->lock_h)( loc->mt_entry );
20276f8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
20276fc: c2 00 40 00 ld [ %g1 ], %g1
2027700: 9f c0 40 00 call %g1
2027704: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.ops->fchmod_h)( &iop->pathinfo, mode );
2027708: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
202770c: 90 07 60 1c add %i5, 0x1c, %o0
2027710: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
2027714: 9f c0 40 00 call %g1
2027718: 92 10 00 19 mov %i1, %o1
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->unlock_h)( loc->mt_entry );
202771c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2027720: b0 10 00 08 mov %o0, %i0
2027724: c2 00 60 04 ld [ %g1 + 4 ], %g1
2027728: 9f c0 40 00 call %g1
202772c: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
2027730: 81 c7 e0 08 ret
2027734: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2027738: 40 00 69 5a call 2041ca0 <__errno> <== NOT EXECUTED
202773c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2027740: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
2027744: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2027748: 81 c7 e0 08 ret <== NOT EXECUTED
202774c: 81 e8 00 00 restore <== NOT EXECUTED
02027750 <fchown>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchown( int fd, uid_t owner, gid_t group )
{
2027750: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2027754: 03 00 81 ab sethi %hi(0x206ac00), %g1
2027758: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 206afc0 <rtems_libio_number_iops>
202775c: 80 a6 00 01 cmp %i0, %g1
2027760: 1a 80 00 0c bcc 2027790 <fchown+0x40>
2027764: 01 00 00 00 nop
iop = rtems_libio_iop( fd );
2027768: bb 2e 20 03 sll %i0, 3, %i5
202776c: 03 00 81 bc sethi %hi(0x206f000), %g1
2027770: b1 2e 20 06 sll %i0, 6, %i0
2027774: b0 07 40 18 add %i5, %i0, %i0
2027778: fa 00 61 48 ld [ %g1 + 0x148 ], %i5
202777c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2027780: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2027784: 80 88 61 00 btst 0x100, %g1
2027788: 32 80 00 08 bne,a 20277a8 <fchown+0x58>
202778c: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
2027790: 40 00 69 44 call 2041ca0 <__errno>
2027794: b0 10 3f ff mov -1, %i0
2027798: 82 10 20 09 mov 9, %g1
202779c: c2 22 00 00 st %g1, [ %o0 ]
20277a0: 81 c7 e0 08 ret
20277a4: 81 e8 00 00 restore
if (iop->pathinfo.mt_entry->writeable) {
20277a8: c2 0a 20 1d ldub [ %o0 + 0x1d ], %g1
20277ac: 80 a0 60 00 cmp %g1, 0
20277b0: 02 80 00 13 be 20277fc <fchown+0xac> <== NEVER TAKEN
20277b4: 01 00 00 00 nop
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->lock_h)( loc->mt_entry );
20277b8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
20277bc: c2 00 40 00 ld [ %g1 ], %g1
20277c0: 9f c0 40 00 call %g1
20277c4: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
20277c8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
20277cc: 90 07 60 1c add %i5, 0x1c, %o0
20277d0: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
20277d4: 92 10 00 19 mov %i1, %o1
20277d8: 9f c0 40 00 call %g1
20277dc: 94 10 00 1a mov %i2, %o2
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->unlock_h)( loc->mt_entry );
20277e0: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
20277e4: b0 10 00 08 mov %o0, %i0
20277e8: c2 00 60 04 ld [ %g1 + 4 ], %g1
20277ec: 9f c0 40 00 call %g1
20277f0: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
20277f4: 81 c7 e0 08 ret
20277f8: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
20277fc: 40 00 69 29 call 2041ca0 <__errno> <== NOT EXECUTED
2027800: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2027804: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
2027808: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
202780c: 81 c7 e0 08 ret <== NOT EXECUTED
2027810: 81 e8 00 00 restore <== NOT EXECUTED
0203de7c <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
203de7c: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
203de80: 05 00 81 ab sethi %hi(0x206ac00), %g2
203de84: c4 00 a3 c0 ld [ %g2 + 0x3c0 ], %g2 ! 206afc0 <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
203de88: 82 07 a0 4c add %fp, 0x4c, %g1
203de8c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
203de90: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
203de94: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
203de98: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
203de9c: 80 a6 00 02 cmp %i0, %g2
203dea0: 1a 80 00 0c bcc 203ded0 <fcntl+0x54>
203dea4: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
203dea8: bb 2e 20 03 sll %i0, 3, %i5
203deac: 05 00 81 bc sethi %hi(0x206f000), %g2
203deb0: b1 2e 20 06 sll %i0, 6, %i0
203deb4: b0 07 40 18 add %i5, %i0, %i0
203deb8: fa 00 a1 48 ld [ %g2 + 0x148 ], %i5
203debc: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
203dec0: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
203dec4: 80 8a 21 00 btst 0x100, %o0
203dec8: 12 80 00 06 bne 203dee0 <fcntl+0x64>
203decc: 80 a6 60 09 cmp %i1, 9
203ded0: 40 00 0f 74 call 2041ca0 <__errno>
203ded4: 01 00 00 00 nop
203ded8: 10 80 00 5b b 203e044 <fcntl+0x1c8>
203dedc: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
203dee0: 18 80 00 56 bgu 203e038 <fcntl+0x1bc>
203dee4: 85 2e 60 02 sll %i1, 2, %g2
203dee8: 07 00 80 f7 sethi %hi(0x203dc00), %g3
203deec: 86 10 e2 54 or %g3, 0x254, %g3 ! 203de54 <fchdir+0x104>
203def0: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
203def4: 81 c0 80 00 jmp %g2
203def8: 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();
203defc: 7f ff 2a f4 call 2008acc <rtems_libio_allocate>
203df00: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff>
if (diop != NULL) {
203df04: 80 a2 20 00 cmp %o0, 0
203df08: 02 80 00 60 be 203e088 <fcntl+0x20c>
203df0c: b8 10 00 08 mov %o0, %i4
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
203df10: 7f ff 2a d9 call 2008a74 <rtems_libio_to_fcntl_flags>
203df14: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
203df18: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
rtems_libio_t *diop = rtems_libio_allocate();
if (diop != NULL) {
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
oflag &= ~O_CREAT;
203df1c: b0 0a 3d ff and %o0, -513, %i0
diop->flags |= rtems_libio_fcntl_flags( oflag );
203df20: 7f ff 2a c8 call 2008a40 <rtems_libio_fcntl_flags>
203df24: 90 10 00 18 mov %i0, %o0
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->lock_h)( loc->mt_entry );
203df28: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
203df2c: b6 12 00 1b or %o0, %i3, %i3
203df30: c2 00 40 00 ld [ %g1 ], %g1
203df34: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
203df38: 9f c0 40 00 call %g1
203df3c: f6 27 20 18 st %i3, [ %i4 + 0x18 ]
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
203df40: 92 07 60 1c add %i5, 0x1c, %o1
203df44: 7f ff a5 c1 call 2027648 <rtems_filesystem_location_clone>
203df48: 90 07 20 1c add %i4, 0x1c, %o0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
(*loc->ops->unlock_h)( loc->mt_entry );
203df4c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
203df50: c2 00 60 04 ld [ %g1 + 4 ], %g1
203df54: 9f c0 40 00 call %g1
203df58: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
/*
* 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 );
203df5c: c2 07 20 2c ld [ %i4 + 0x2c ], %g1
203df60: 94 10 00 18 mov %i0, %o2
203df64: c2 00 40 00 ld [ %g1 ], %g1
203df68: 90 10 00 1c mov %i4, %o0
203df6c: 92 10 20 00 clr %o1
203df70: 9f c0 40 00 call %g1
203df74: 96 10 20 00 clr %o3
if ( rv == 0 ) {
203df78: b0 92 20 00 orcc %o0, 0, %i0
203df7c: 12 80 00 10 bne 203dfbc <fcntl+0x140> <== NEVER TAKEN
203df80: 03 00 81 bc sethi %hi(0x206f000), %g1
rv = diop - rtems_libio_iops;
203df84: f0 00 61 48 ld [ %g1 + 0x148 ], %i0 ! 206f148 <rtems_libio_iops>
203df88: b8 27 00 18 sub %i4, %i0, %i4
203df8c: b9 3f 20 03 sra %i4, 3, %i4
203df90: 85 2f 20 06 sll %i4, 6, %g2
203df94: 83 2f 20 03 sll %i4, 3, %g1
203df98: 82 20 80 01 sub %g2, %g1, %g1
203df9c: 85 28 60 06 sll %g1, 6, %g2
203dfa0: 82 00 40 02 add %g1, %g2, %g1
203dfa4: 82 00 40 1c add %g1, %i4, %g1
203dfa8: b1 28 60 0f sll %g1, 0xf, %i0
203dfac: b0 26 00 01 sub %i0, %g1, %i0
203dfb0: b1 2e 20 03 sll %i0, 3, %i0
203dfb4: 10 80 00 27 b 203e050 <fcntl+0x1d4>
203dfb8: b0 06 00 1c add %i0, %i4, %i0
} else {
rtems_libio_free( diop );
203dfbc: 7f ff 2a f3 call 2008b88 <rtems_libio_free> <== NOT EXECUTED
203dfc0: 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) {
203dfc4: 10 80 00 24 b 203e054 <fcntl+0x1d8> <== NOT EXECUTED
203dfc8: 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);
203dfcc: 90 0a 28 00 and %o0, 0x800, %o0
203dfd0: 80 a0 00 08 cmp %g0, %o0
203dfd4: 10 80 00 22 b 203e05c <fcntl+0x1e0>
203dfd8: b0 40 20 00 addx %g0, 0, %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 ) )
203dfdc: c2 00 40 00 ld [ %g1 ], %g1
203dfe0: 80 a0 60 00 cmp %g1, 0
203dfe4: 22 80 00 0e be,a 203e01c <fcntl+0x1a0>
203dfe8: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
203dfec: 10 80 00 0c b 203e01c <fcntl+0x1a0>
203dff0: 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 );
203dff4: 7f ff 2a a0 call 2008a74 <rtems_libio_to_fcntl_flags>
203dff8: 01 00 00 00 nop
203dffc: 10 80 00 15 b 203e050 <fcntl+0x1d4>
203e000: b0 10 00 08 mov %o0, %i0
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
203e004: 7f ff 2a 8f call 2008a40 <rtems_libio_fcntl_flags>
203e008: 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);
203e00c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
203e010: 90 0a 22 01 and %o0, 0x201, %o0
203e014: 82 08 7d fe and %g1, -514, %g1
203e018: 90 12 00 01 or %o0, %g1, %o0
203e01c: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
203e020: 10 80 00 0f b 203e05c <fcntl+0x1e0>
203e024: b0 10 20 00 clr %i0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
203e028: 40 00 0f 1e call 2041ca0 <__errno>
203e02c: 01 00 00 00 nop
203e030: 10 80 00 05 b 203e044 <fcntl+0x1c8>
203e034: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
ret = -1;
break;
default:
errno = EINVAL;
203e038: 40 00 0f 1a call 2041ca0 <__errno>
203e03c: 01 00 00 00 nop
203e040: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
203e044: c2 22 00 00 st %g1, [ %o0 ]
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
203e048: 81 c7 e0 08 ret
203e04c: 91 e8 3f ff restore %g0, -1, %o0
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
203e050: 80 a6 20 00 cmp %i0, 0
203e054: 06 80 00 0d bl 203e088 <fcntl+0x20c> <== NEVER TAKEN
203e058: 01 00 00 00 nop
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
203e05c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
203e060: 90 10 00 1d mov %i5, %o0
203e064: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
203e068: 9f c0 40 00 call %g1
203e06c: 92 10 00 19 mov %i1, %o1
if (err) {
203e070: ba 92 20 00 orcc %o0, 0, %i5
203e074: 02 80 00 05 be 203e088 <fcntl+0x20c> <== ALWAYS TAKEN
203e078: 01 00 00 00 nop
errno = err;
203e07c: 40 00 0f 09 call 2041ca0 <__errno> <== NOT EXECUTED
203e080: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
203e084: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
203e088: 81 c7 e0 08 ret
203e08c: 81 e8 00 00 restore
0200dd7c <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200dd7c: 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) {
200dd80: 37 00 80 8d sethi %hi(0x2023400), %i3
200dd84: c2 06 e2 88 ld [ %i3 + 0x288 ], %g1 ! 2023688 <pipe_semaphore>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200dd88: ba 10 00 18 mov %i0, %i5
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
200dd8c: 80 a0 60 00 cmp %g1, 0
200dd90: 12 80 00 1a bne 200ddf8 <fifo_open+0x7c>
200dd94: b8 16 e2 88 or %i3, 0x288, %i4
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200dd98: 03 00 80 8e sethi %hi(0x2023800), %g1
200dd9c: d0 00 60 f4 ld [ %g1 + 0xf4 ], %o0 ! 20238f4 <rtems_libio_semaphore>
200dda0: 92 10 20 00 clr %o1
200dda4: 7f ff ec e0 call 2009124 <rtems_semaphore_obtain>
200dda8: 94 10 20 00 clr %o2
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
200ddac: c2 06 e2 88 ld [ %i3 + 0x288 ], %g1
200ddb0: 80 a0 60 00 cmp %g1, 0
200ddb4: 12 80 00 0a bne 200dddc <fifo_open+0x60> <== NEVER TAKEN
200ddb8: b6 10 20 00 clr %i3
sc = rtems_semaphore_create(
200ddbc: 11 14 12 54 sethi %hi(0x50495000), %o0
200ddc0: 92 10 20 01 mov 1, %o1
200ddc4: 90 12 20 45 or %o0, 0x45, %o0
200ddc8: 94 10 20 54 mov 0x54, %o2
200ddcc: 96 10 20 00 clr %o3
200ddd0: 7f ff ec 3b call 2008ebc <rtems_semaphore_create>
200ddd4: 98 10 00 1c mov %i4, %o4
200ddd8: b6 10 00 08 mov %o0, %i3
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200dddc: 03 00 80 8e sethi %hi(0x2023800), %g1
200dde0: d0 00 60 f4 ld [ %g1 + 0xf4 ], %o0 ! 20238f4 <rtems_libio_semaphore>
200dde4: 7f ff ed 1a call 200924c <rtems_semaphore_release>
200dde8: b0 10 3f f4 mov -12, %i0
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
200ddec: 80 a6 e0 00 cmp %i3, 0
200ddf0: 12 80 00 f3 bne 200e1bc <fifo_open+0x440>
200ddf4: 01 00 00 00 nop
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200ddf8: 03 00 80 8d sethi %hi(0x2023400), %g1
200ddfc: d0 00 62 88 ld [ %g1 + 0x288 ], %o0 ! 2023688 <pipe_semaphore>
200de00: 92 10 20 00 clr %o1
200de04: 94 10 20 00 clr %o2
200de08: 7f ff ec c7 call 2009124 <rtems_semaphore_obtain>
200de0c: b0 10 3f f4 mov -12, %i0
}
if (sc == RTEMS_SUCCESSFUL) {
200de10: 80 a2 20 00 cmp %o0, 0
200de14: 12 80 00 ea bne 200e1bc <fifo_open+0x440> <== NEVER TAKEN
200de18: 01 00 00 00 nop
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
200de1c: f8 07 40 00 ld [ %i5 ], %i4
if (pipe == NULL) {
200de20: 80 a7 20 00 cmp %i4, 0
200de24: 32 80 00 56 bne,a 200df7c <fifo_open+0x200>
200de28: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
200de2c: 7f ff dc 0f call 2004e68 <malloc>
200de30: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
200de34: b8 92 20 00 orcc %o0, 0, %i4
200de38: 02 80 00 4e be 200df70 <fifo_open+0x1f4>
200de3c: 92 10 20 00 clr %o1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
200de40: 40 00 13 35 call 2012b14 <memset>
200de44: 94 10 20 34 mov 0x34, %o2
pipe->Size = PIPE_BUF;
200de48: 82 10 22 00 mov 0x200, %g1
pipe->Buffer = malloc(pipe->Size);
200de4c: 90 10 22 00 mov 0x200, %o0
200de50: 7f ff dc 06 call 2004e68 <malloc>
200de54: c2 27 20 04 st %g1, [ %i4 + 4 ]
if (! pipe->Buffer)
200de58: 80 a2 20 00 cmp %o0, 0
200de5c: 02 80 00 43 be 200df68 <fifo_open+0x1ec> <== NEVER TAKEN
200de60: d0 27 00 00 st %o0, [ %i4 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
200de64: 37 00 80 8b sethi %hi(0x2022c00), %i3
200de68: d0 4e e3 34 ldsb [ %i3 + 0x334 ], %o0 ! 2022f34 <c.6980>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
200de6c: 35 14 12 5c sethi %hi(0x50497000), %i2
200de70: 82 16 a2 00 or %i2, 0x200, %g1 ! 50497200 <RAM_END+0x4e097200>
200de74: 92 10 20 00 clr %o1
200de78: 90 12 00 01 or %o0, %g1, %o0
200de7c: 94 10 20 00 clr %o2
200de80: 40 00 05 c7 call 200f59c <rtems_barrier_create>
200de84: 96 07 20 2c add %i4, 0x2c, %o3
200de88: 80 a2 20 00 cmp %o0, 0
200de8c: 12 80 00 35 bne 200df60 <fifo_open+0x1e4>
200de90: d0 4e e3 34 ldsb [ %i3 + 0x334 ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
200de94: 03 14 12 5d sethi %hi(0x50497400), %g1
200de98: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x4e097700>
200de9c: 92 10 20 00 clr %o1
200dea0: 90 12 00 01 or %o0, %g1, %o0
200dea4: 94 10 20 00 clr %o2
200dea8: 40 00 05 bd call 200f59c <rtems_barrier_create>
200deac: 96 07 20 30 add %i4, 0x30, %o3
200deb0: 80 a2 20 00 cmp %o0, 0
200deb4: 12 80 00 29 bne 200df58 <fifo_open+0x1dc>
200deb8: d0 4e e3 34 ldsb [ %i3 + 0x334 ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
200debc: b4 16 a3 00 or %i2, 0x300, %i2
200dec0: 92 10 20 01 mov 1, %o1
200dec4: 90 12 00 1a or %o0, %i2, %o0
200dec8: 94 10 20 10 mov 0x10, %o2
200decc: 96 10 20 00 clr %o3
200ded0: 7f ff eb fb call 2008ebc <rtems_semaphore_create>
200ded4: 98 07 20 28 add %i4, 0x28, %o4
200ded8: 80 a2 20 00 cmp %o0, 0
200dedc: 12 80 00 1d bne 200df50 <fifo_open+0x1d4>
200dee0: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
200dee4: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
200dee8: 31 00 80 90 sethi %hi(0x2024000), %i0
200deec: 7f ff f3 05 call 200ab00 <_Objects_Get>
200def0: 90 16 23 b0 or %i0, 0x3b0, %o0 ! 20243b0 <_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;
200def4: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200def8: 35 04 00 00 sethi %hi(0x10000000), %i2
200defc: 82 10 40 1a or %g1, %i2, %g1
_Thread_Enable_dispatch();
200df00: 7f ff f6 b3 call 200b9cc <_Thread_Enable_dispatch>
200df04: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
200df08: d2 07 20 30 ld [ %i4 + 0x30 ], %o1
200df0c: 94 07 bf fc add %fp, -4, %o2
200df10: 7f ff f2 fc call 200ab00 <_Objects_Get>
200df14: 90 16 23 b0 or %i0, 0x3b0, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
200df18: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200df1c: b4 10 40 1a or %g1, %i2, %i2
_Thread_Enable_dispatch();
200df20: 7f ff f6 ab call 200b9cc <_Thread_Enable_dispatch>
200df24: f4 22 20 4c st %i2, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200df28: c2 0e e3 34 ldub [ %i3 + 0x334 ], %g1
200df2c: 84 00 60 01 add %g1, 1, %g2
200df30: 83 28 60 18 sll %g1, 0x18, %g1
200df34: 83 38 60 18 sra %g1, 0x18, %g1
200df38: 80 a0 60 7a cmp %g1, 0x7a
200df3c: 12 80 00 0f bne 200df78 <fifo_open+0x1fc>
200df40: c4 2e e3 34 stb %g2, [ %i3 + 0x334 ]
c = 'a';
200df44: 82 10 20 61 mov 0x61, %g1
200df48: 10 80 00 0c b 200df78 <fifo_open+0x1fc>
200df4c: c2 2e e3 34 stb %g1, [ %i3 + 0x334 ]
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
200df50: 40 00 05 c4 call 200f660 <rtems_barrier_delete>
200df54: d0 07 20 30 ld [ %i4 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
200df58: 40 00 05 c2 call 200f660 <rtems_barrier_delete>
200df5c: d0 07 20 2c ld [ %i4 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
200df60: 7f ff da 9a call 20049c8 <free>
200df64: d0 07 00 00 ld [ %i4 ], %o0
err_buf:
free(pipe);
200df68: 7f ff da 98 call 20049c8 <free>
200df6c: 90 10 00 1c mov %i4, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200df70: 10 80 00 13 b 200dfbc <fifo_open+0x240>
200df74: b0 10 3f f4 mov -12, %i0
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200df78: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
200df7c: 92 10 20 00 clr %o1
200df80: 7f ff ec 69 call 2009124 <rtems_semaphore_obtain>
200df84: 94 10 20 00 clr %o2
err = -EINTR;
if (*pipep == NULL) {
200df88: c2 07 40 00 ld [ %i5 ], %g1
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200df8c: 80 a0 00 08 cmp %g0, %o0
200df90: b0 60 20 00 subx %g0, 0, %i0
err = -EINTR;
if (*pipep == NULL) {
200df94: 80 a0 60 00 cmp %g1, 0
200df98: 12 80 00 09 bne 200dfbc <fifo_open+0x240>
200df9c: b0 0e 3f fc and %i0, -4, %i0
if (err)
200dfa0: 80 a6 20 00 cmp %i0, 0
200dfa4: 22 80 00 06 be,a 200dfbc <fifo_open+0x240> <== ALWAYS TAKEN
200dfa8: f8 27 40 00 st %i4, [ %i5 ]
pipe_free(pipe);
200dfac: 7f ff ff 37 call 200dc88 <pipe_free> <== NOT EXECUTED
200dfb0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200dfb4: 10 80 00 03 b 200dfc0 <fifo_open+0x244> <== NOT EXECUTED
200dfb8: 03 00 80 8d sethi %hi(0x2023400), %g1 <== NOT EXECUTED
200dfbc: 03 00 80 8d sethi %hi(0x2023400), %g1
200dfc0: 7f ff ec a3 call 200924c <rtems_semaphore_release>
200dfc4: d0 00 62 88 ld [ %g1 + 0x288 ], %o0 ! 2023688 <pipe_semaphore>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
200dfc8: 80 a6 20 00 cmp %i0, 0
200dfcc: 12 80 00 7c bne 200e1bc <fifo_open+0x440>
200dfd0: 01 00 00 00 nop
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
200dfd4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
200dfd8: 82 08 60 06 and %g1, 6, %g1
200dfdc: 80 a0 60 04 cmp %g1, 4
200dfe0: 02 80 00 2e be 200e098 <fifo_open+0x31c>
200dfe4: f8 07 40 00 ld [ %i5 ], %i4
200dfe8: 80 a0 60 06 cmp %g1, 6
200dfec: 02 80 00 56 be 200e144 <fifo_open+0x3c8>
200dff0: 80 a0 60 02 cmp %g1, 2
200dff4: 12 80 00 6a bne 200e19c <fifo_open+0x420> <== NEVER TAKEN
200dff8: 01 00 00 00 nop
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
200dffc: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
200e000: 82 00 60 01 inc %g1
200e004: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
if (pipe->Readers ++ == 0)
200e008: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
200e00c: 84 00 60 01 add %g1, 1, %g2
200e010: 80 a0 60 00 cmp %g1, 0
200e014: 12 80 00 05 bne 200e028 <fifo_open+0x2ac> <== NEVER TAKEN
200e018: c4 27 20 10 st %g2, [ %i4 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200e01c: d0 07 20 30 ld [ %i4 + 0x30 ], %o0
200e020: 40 00 05 b9 call 200f704 <rtems_barrier_release>
200e024: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
200e028: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
200e02c: 80 a0 60 00 cmp %g1, 0
200e030: 12 80 00 5b bne 200e19c <fifo_open+0x420>
200e034: 01 00 00 00 nop
/* Not an error */
if (LIBIO_NODELAY(iop))
200e038: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
200e03c: 80 88 60 01 btst 1, %g1
200e040: 12 80 00 57 bne 200e19c <fifo_open+0x420>
200e044: 01 00 00 00 nop
break;
prevCounter = pipe->writerCounter;
200e048: f6 07 20 24 ld [ %i4 + 0x24 ], %i3
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
200e04c: 7f ff ec 80 call 200924c <rtems_semaphore_release>
200e050: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
200e054: d0 07 20 2c ld [ %i4 + 0x2c ], %o0
200e058: 40 00 05 c2 call 200f760 <rtems_barrier_wait>
200e05c: 92 10 20 00 clr %o1
200e060: 80 a2 20 00 cmp %o0, 0
200e064: 12 80 00 52 bne 200e1ac <fifo_open+0x430> <== NEVER TAKEN
200e068: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200e06c: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
200e070: 7f ff ec 2d call 2009124 <rtems_semaphore_obtain>
200e074: 94 10 20 00 clr %o2
200e078: 80 a2 20 00 cmp %o0, 0
200e07c: 32 80 00 4d bne,a 200e1b0 <fifo_open+0x434> <== NEVER TAKEN
200e080: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
200e084: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
200e088: 80 a6 c0 01 cmp %i3, %g1
200e08c: 02 bf ff f0 be 200e04c <fifo_open+0x2d0> <== NEVER TAKEN
200e090: 01 00 00 00 nop
200e094: 30 80 00 42 b,a 200e19c <fifo_open+0x420>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
200e098: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
200e09c: 82 00 60 01 inc %g1
200e0a0: c2 27 20 24 st %g1, [ %i4 + 0x24 ]
if (pipe->Writers ++ == 0)
200e0a4: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
200e0a8: 84 00 60 01 add %g1, 1, %g2
200e0ac: 80 a0 60 00 cmp %g1, 0
200e0b0: 12 80 00 05 bne 200e0c4 <fifo_open+0x348> <== NEVER TAKEN
200e0b4: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e0b8: d0 07 20 2c ld [ %i4 + 0x2c ], %o0
200e0bc: 40 00 05 92 call 200f704 <rtems_barrier_release>
200e0c0: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
200e0c4: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
200e0c8: 80 a0 60 00 cmp %g1, 0
200e0cc: 12 80 00 34 bne 200e19c <fifo_open+0x420>
200e0d0: 01 00 00 00 nop
200e0d4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
200e0d8: 80 88 60 01 btst 1, %g1
200e0dc: 22 80 00 07 be,a 200e0f8 <fifo_open+0x37c>
200e0e0: f6 07 20 20 ld [ %i4 + 0x20 ], %i3
PIPE_UNLOCK(pipe);
200e0e4: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
200e0e8: 7f ff ec 59 call 200924c <rtems_semaphore_release>
200e0ec: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
200e0f0: 10 80 00 31 b 200e1b4 <fifo_open+0x438>
200e0f4: 90 10 00 1d mov %i5, %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
200e0f8: 7f ff ec 55 call 200924c <rtems_semaphore_release>
200e0fc: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
200e100: d0 07 20 30 ld [ %i4 + 0x30 ], %o0
200e104: 40 00 05 97 call 200f760 <rtems_barrier_wait>
200e108: 92 10 20 00 clr %o1
200e10c: 80 a2 20 00 cmp %o0, 0
200e110: 12 80 00 27 bne 200e1ac <fifo_open+0x430> <== NEVER TAKEN
200e114: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200e118: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
200e11c: 7f ff ec 02 call 2009124 <rtems_semaphore_obtain>
200e120: 94 10 20 00 clr %o2
200e124: 80 a2 20 00 cmp %o0, 0
200e128: 32 80 00 22 bne,a 200e1b0 <fifo_open+0x434> <== NEVER TAKEN
200e12c: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
200e130: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
200e134: 80 a6 c0 01 cmp %i3, %g1
200e138: 02 bf ff f0 be 200e0f8 <fifo_open+0x37c> <== NEVER TAKEN
200e13c: 01 00 00 00 nop
200e140: 30 80 00 17 b,a 200e19c <fifo_open+0x420>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
200e144: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
200e148: 82 00 60 01 inc %g1
200e14c: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
if (pipe->Readers ++ == 0)
200e150: c2 07 20 10 ld [ %i4 + 0x10 ], %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+0x3f4> <== NEVER TAKEN
200e160: c4 27 20 10 st %g2, [ %i4 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200e164: d0 07 20 30 ld [ %i4 + 0x30 ], %o0
200e168: 40 00 05 67 call 200f704 <rtems_barrier_release>
200e16c: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
200e170: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
200e174: 82 00 60 01 inc %g1
200e178: c2 27 20 24 st %g1, [ %i4 + 0x24 ]
if (pipe->Writers ++ == 0)
200e17c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
200e180: 84 00 60 01 add %g1, 1, %g2
200e184: 80 a0 60 00 cmp %g1, 0
200e188: 12 80 00 05 bne 200e19c <fifo_open+0x420> <== NEVER TAKEN
200e18c: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e190: d0 07 20 2c ld [ %i4 + 0x2c ], %o0
200e194: 40 00 05 5c call 200f704 <rtems_barrier_release>
200e198: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
200e19c: 7f ff ec 2c call 200924c <rtems_semaphore_release>
200e1a0: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
return 0;
200e1a4: 81 c7 e0 08 ret
200e1a8: 81 e8 00 00 restore
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
200e1ac: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
200e1b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200e1b4: 7f ff fe c0 call 200dcb4 <pipe_release>
200e1b8: 92 10 00 19 mov %i1, %o1
return err;
}
200e1bc: 81 c7 e0 08 ret
200e1c0: 81 e8 00 00 restore
02009790 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
2009790: 9d e3 bf a0 save %sp, -96, %sp
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
2009794: 03 00 80 4a sethi %hi(0x2012800), %g1
2009798: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 2012870 <rtems_libio_number_iops>
200979c: 80 a6 00 01 cmp %i0, %g1
20097a0: 1a 80 00 0c bcc 20097d0 <fpathconf+0x40> <== ALWAYS TAKEN
20097a4: 01 00 00 00 nop
iop = rtems_libio_iop(fd);
20097a8: 83 2e 20 03 sll %i0, 3, %g1 <== NOT EXECUTED
20097ac: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
20097b0: b0 00 40 18 add %g1, %i0, %i0 <== NOT EXECUTED
20097b4: 03 00 80 4c sethi %hi(0x2013000), %g1 <== NOT EXECUTED
20097b8: c2 00 61 7c ld [ %g1 + 0x17c ], %g1 ! 201317c <rtems_libio_iops><== NOT EXECUTED
20097bc: b0 00 40 18 add %g1, %i0, %i0 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
20097c0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
20097c4: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
20097c8: 12 80 00 08 bne 20097e8 <fpathconf+0x58> <== NOT EXECUTED
20097cc: 80 a6 60 0b cmp %i1, 0xb <== NOT EXECUTED
20097d0: 40 00 09 60 call 200bd50 <__errno>
20097d4: b0 10 3f ff mov -1, %i0
20097d8: 82 10 20 09 mov 9, %g1
20097dc: c2 22 00 00 st %g1, [ %o0 ]
20097e0: 81 c7 e0 08 ret
20097e4: 81 e8 00 00 restore
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
20097e8: 18 80 00 2c bgu 2009898 <fpathconf+0x108> <== NOT EXECUTED
20097ec: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
20097f0: b3 2e 60 02 sll %i1, 2, %i1 <== NOT EXECUTED
20097f4: 05 00 80 25 sethi %hi(0x2009400), %g2 <== NOT EXECUTED
20097f8: 84 10 a3 60 or %g2, 0x360, %g2 ! 2009760 <_close_r+0x10> <== NOT EXECUTED
20097fc: c4 00 80 19 ld [ %g2 + %i1 ], %g2 <== NOT EXECUTED
2009800: 81 c0 80 00 jmp %g2 <== NOT EXECUTED
2009804: 01 00 00 00 nop <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
2009808: f0 00 60 28 ld [ %g1 + 0x28 ], %i0 <== NOT EXECUTED
break;
200980c: 81 c7 e0 08 ret <== NOT EXECUTED
2009810: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2009814: f0 00 60 2c ld [ %g1 + 0x2c ], %i0 <== NOT EXECUTED
break;
2009818: 81 c7 e0 08 ret <== NOT EXECUTED
200981c: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2009820: f0 00 60 30 ld [ %g1 + 0x30 ], %i0 <== NOT EXECUTED
break;
2009824: 81 c7 e0 08 ret <== NOT EXECUTED
2009828: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_NAME_MAX:
return_value = the_limits->name_max;
200982c: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 <== NOT EXECUTED
break;
2009830: 81 c7 e0 08 ret <== NOT EXECUTED
2009834: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PATH_MAX:
return_value = the_limits->path_max;
2009838: f0 00 60 38 ld [ %g1 + 0x38 ], %i0 <== NOT EXECUTED
break;
200983c: 81 c7 e0 08 ret <== NOT EXECUTED
2009840: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
2009844: f0 00 60 3c ld [ %g1 + 0x3c ], %i0 <== NOT EXECUTED
break;
2009848: 81 c7 e0 08 ret <== NOT EXECUTED
200984c: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
2009850: f0 00 60 44 ld [ %g1 + 0x44 ], %i0 <== NOT EXECUTED
break;
2009854: 81 c7 e0 08 ret <== NOT EXECUTED
2009858: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
200985c: f0 00 60 48 ld [ %g1 + 0x48 ], %i0 <== NOT EXECUTED
break;
2009860: 81 c7 e0 08 ret <== NOT EXECUTED
2009864: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
2009868: f0 00 60 54 ld [ %g1 + 0x54 ], %i0 <== NOT EXECUTED
break;
200986c: 81 c7 e0 08 ret <== NOT EXECUTED
2009870: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
2009874: f0 00 60 40 ld [ %g1 + 0x40 ], %i0 <== NOT EXECUTED
break;
2009878: 81 c7 e0 08 ret <== NOT EXECUTED
200987c: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
2009880: f0 00 60 4c ld [ %g1 + 0x4c ], %i0 <== NOT EXECUTED
break;
2009884: 81 c7 e0 08 ret <== NOT EXECUTED
2009888: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
200988c: f0 00 60 50 ld [ %g1 + 0x50 ], %i0 <== NOT EXECUTED
break;
2009890: 81 c7 e0 08 ret <== NOT EXECUTED
2009894: 81 e8 00 00 restore <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2009898: 40 00 09 2e call 200bd50 <__errno> <== NOT EXECUTED
200989c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20098a0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20098a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return return_value;
}
20098a8: 81 c7 e0 08 ret <== NOT EXECUTED
20098ac: 81 e8 00 00 restore <== NOT EXECUTED
02003710 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
2003710: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
2003714: 03 00 80 76 sethi %hi(0x201d800), %g1
2003718: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 201dab0 <rtems_malloc_statistics>
200371c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
2003720: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
2003724: 84 00 a0 01 inc %g2
if ( !ptr )
2003728: 80 a6 20 00 cmp %i0, 0
200372c: 02 80 00 21 be 20037b0 <free+0xa0>
2003730: 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()) &&
2003734: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003738: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 ! 201dd68 <_System_state_Current>
200373c: 80 a0 60 03 cmp %g1, 3
2003740: 12 80 00 09 bne 2003764 <free+0x54> <== NEVER TAKEN
2003744: 03 00 80 75 sethi %hi(0x201d400), %g1
!malloc_is_system_state_OK() ) {
2003748: 40 00 00 7c call 2003938 <malloc_is_system_state_OK>
200374c: 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()) &&
2003750: 80 8a 20 ff btst 0xff, %o0
2003754: 12 80 00 04 bne 2003764 <free+0x54>
2003758: 03 00 80 75 sethi %hi(0x201d400), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
200375c: 40 00 00 96 call 20039b4 <malloc_deferred_free>
2003760: 81 e8 00 00 restore
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
2003764: c2 00 62 f4 ld [ %g1 + 0x2f4 ], %g1
2003768: 80 a0 60 00 cmp %g1, 0
200376c: 02 80 00 06 be 2003784 <free+0x74>
2003770: 3b 00 80 73 sethi %hi(0x201cc00), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
2003774: c2 00 60 08 ld [ %g1 + 8 ], %g1
2003778: 9f c0 40 00 call %g1
200377c: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
2003780: 3b 00 80 73 sethi %hi(0x201cc00), %i5
2003784: d0 07 63 18 ld [ %i5 + 0x318 ], %o0 ! 201cf18 <RTEMS_Malloc_Heap>
2003788: 40 00 17 6c call 2009538 <_Protected_heap_Free>
200378c: 92 10 00 19 mov %i1, %o1
2003790: 80 8a 20 ff btst 0xff, %o0
2003794: 12 80 00 07 bne 20037b0 <free+0xa0>
2003798: 31 00 80 6e sethi %hi(0x201b800), %i0
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
200379c: c2 07 63 18 ld [ %i5 + 0x318 ], %g1
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
20037a0: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
20037a4: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
20037a8: 40 00 03 7e call 20045a0 <printk>
20037ac: 91 ee 20 10 restore %i0, 0x10, %o0
20037b0: 81 c7 e0 08 ret
20037b4: 81 e8 00 00 restore
02019fa4 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
2019fa4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
2019fa8: 80 a6 60 00 cmp %i1, 0
2019fac: 32 80 00 06 bne,a 2019fc4 <fstat+0x20> <== ALWAYS TAKEN
2019fb0: 03 00 80 73 sethi %hi(0x201cc00), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
2019fb4: 7f ff d6 30 call 200f874 <__errno> <== NOT EXECUTED
2019fb8: 01 00 00 00 nop <== NOT EXECUTED
2019fbc: 10 80 00 12 b 201a004 <fstat+0x60> <== NOT EXECUTED
2019fc0: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
2019fc4: c2 00 63 5c ld [ %g1 + 0x35c ], %g1
2019fc8: 80 a6 00 01 cmp %i0, %g1
2019fcc: 1a 80 00 0b bcc 2019ff8 <fstat+0x54>
2019fd0: 83 2e 20 03 sll %i0, 3, %g1
2019fd4: b1 2e 20 06 sll %i0, 6, %i0
2019fd8: b0 00 40 18 add %g1, %i0, %i0
2019fdc: 03 00 80 76 sethi %hi(0x201d800), %g1
2019fe0: c2 00 62 98 ld [ %g1 + 0x298 ], %g1 ! 201da98 <rtems_libio_iops>
2019fe4: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
2019fe8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2019fec: 80 88 61 00 btst 0x100, %g1
2019ff0: 12 80 00 08 bne 201a010 <fstat+0x6c>
2019ff4: 94 10 20 48 mov 0x48, %o2
2019ff8: 7f ff d6 1f call 200f874 <__errno>
2019ffc: 01 00 00 00 nop
201a000: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a004: c2 22 00 00 st %g1, [ %o0 ]
201a008: 81 c7 e0 08 ret
201a00c: 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) );
201a010: 90 10 00 19 mov %i1, %o0
201a014: 7f ff d8 b0 call 20102d4 <memset>
201a018: 92 10 20 00 clr %o1
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
201a01c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
201a020: 90 06 20 1c add %i0, 0x1c, %o0
201a024: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
201a028: 9f c0 40 00 call %g1
201a02c: 92 10 00 19 mov %i1, %o1
}
201a030: 81 c7 e0 08 ret
201a034: 91 e8 00 08 restore %g0, %o0, %o0
02003600 <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) {
2003600: 03 00 80 84 sethi %hi(0x2021000), %g1
2003604: c4 00 63 a8 ld [ %g1 + 0x3a8 ], %g2 ! 20213a8 <disktab_size>
2003608: 80 a2 00 02 cmp %o0, %g2
200360c: 1a 80 00 1e bcc 2003684 <get_disk_entry+0x84> <== NEVER TAKEN
2003610: 82 10 20 00 clr %g1
2003614: 05 00 80 84 sethi %hi(0x2021000), %g2
2003618: c4 00 a3 ac ld [ %g2 + 0x3ac ], %g2 ! 20213ac <disktab>
200361c: 80 a0 a0 00 cmp %g2, 0
2003620: 02 80 00 19 be 2003684 <get_disk_entry+0x84> <== NEVER TAKEN
2003624: 01 00 00 00 nop
rtems_disk_device_table *dtab = disktab + major;
2003628: 91 2a 20 03 sll %o0, 3, %o0
200362c: 86 00 80 08 add %g2, %o0, %g3
if (minor < dtab->size && dtab->minor != NULL) {
2003630: c6 00 e0 04 ld [ %g3 + 4 ], %g3
2003634: 80 a2 40 03 cmp %o1, %g3
2003638: 1a 80 00 13 bcc 2003684 <get_disk_entry+0x84> <== NEVER TAKEN
200363c: 01 00 00 00 nop
2003640: c4 00 80 08 ld [ %g2 + %o0 ], %g2
2003644: 80 a0 a0 00 cmp %g2, 0
2003648: 02 80 00 0f be 2003684 <get_disk_entry+0x84> <== NEVER TAKEN
200364c: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
2003650: c2 00 80 09 ld [ %g2 + %o1 ], %g1
if (dd != NULL && !lookup_only) {
2003654: 80 a0 60 00 cmp %g1, 0
2003658: 02 80 00 0b be 2003684 <get_disk_entry+0x84>
200365c: 80 a2 a0 00 cmp %o2, 0
2003660: 12 80 00 09 bne 2003684 <get_disk_entry+0x84>
2003664: 01 00 00 00 nop
if (!dd->deleted) {
2003668: c4 08 60 30 ldub [ %g1 + 0x30 ], %g2
200366c: 80 a0 a0 00 cmp %g2, 0
2003670: 32 80 00 05 bne,a 2003684 <get_disk_entry+0x84>
2003674: 82 10 20 00 clr %g1
++dd->uses;
2003678: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200367c: 84 00 a0 01 inc %g2
2003680: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return dd;
}
}
return NULL;
}
2003684: 81 c3 e0 08 retl
2003688: 90 10 00 01 mov %g1, %o0
020049fc <get_sector>:
*/
static rtems_status_code
get_sector(int fd,
uint32_t sector_num,
rtems_sector_data_t **sector)
{
20049fc: 9d e3 bf a0 save %sp, -96, %sp
2004a00: ba 10 00 18 mov %i0, %i5
rtems_sector_data_t *s;
ssize_t n;
off_t off;
off_t new_off;
if (sector == NULL)
2004a04: 80 a6 a0 00 cmp %i2, 0
2004a08: 02 80 00 1c be 2004a78 <get_sector+0x7c> <== NEVER TAKEN
2004a0c: b0 10 20 19 mov 0x19, %i0
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
2004a10: b9 2e 60 09 sll %i1, 9, %i4
new_off = lseek(fd, off, SEEK_SET);
2004a14: 90 10 00 1d mov %i5, %o0
2004a18: 92 10 20 00 clr %o1
2004a1c: 94 10 00 1c mov %i4, %o2
2004a20: 40 00 05 54 call 2005f70 <lseek>
2004a24: 96 10 20 00 clr %o3
if (new_off != off) {
2004a28: 80 a2 20 00 cmp %o0, 0
2004a2c: 12 80 00 13 bne 2004a78 <get_sector+0x7c> <== NEVER TAKEN
2004a30: b0 10 20 1b mov 0x1b, %i0
2004a34: 80 a2 40 1c cmp %o1, %i4
2004a38: 12 80 00 10 bne 2004a78 <get_sector+0x7c> <== NEVER TAKEN
2004a3c: 90 10 22 04 mov 0x204, %o0
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
2004a40: 40 00 06 1e call 20062b8 <malloc>
2004a44: b0 10 20 1a mov 0x1a, %i0
if (s == NULL)
2004a48: 80 a2 20 00 cmp %o0, 0
2004a4c: 02 80 00 0b be 2004a78 <get_sector+0x7c> <== NEVER TAKEN
2004a50: b8 10 00 08 mov %o0, %i4
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
2004a54: 90 10 00 1d mov %i5, %o0
2004a58: 92 07 20 04 add %i4, 4, %o1
2004a5c: 40 00 08 df call 2006dd8 <read>
2004a60: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
2004a64: 80 a2 22 00 cmp %o0, 0x200
2004a68: 02 80 00 06 be 2004a80 <get_sector+0x84> <== ALWAYS TAKEN
2004a6c: 90 10 00 1c mov %i4, %o0
{
free(s);
2004a70: 40 00 03 fc call 2005a60 <free> <== NOT EXECUTED
2004a74: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
2004a78: 81 c7 e0 08 ret <== NOT EXECUTED
2004a7c: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
2004a80: f2 27 00 00 st %i1, [ %i4 ]
*sector = s;
2004a84: f8 26 80 00 st %i4, [ %i2 ]
2004a88: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
2004a8c: 81 c7 e0 08 ret
2004a90: 81 e8 00 00 restore
0205cd7c <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
205cd7c: 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 );
205cd80: 03 00 81 ab sethi %hi(0x206ac00), %g1
205cd84: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 206afc0 <rtems_libio_number_iops>
205cd88: 80 a6 00 01 cmp %i0, %g1
205cd8c: 1a 80 00 08 bcc 205cdac <getdents+0x30> <== NEVER TAKEN
205cd90: ba 10 20 00 clr %i5
205cd94: bb 2e 20 03 sll %i0, 3, %i5
205cd98: 03 00 81 bc sethi %hi(0x206f000), %g1
205cd9c: b1 2e 20 06 sll %i0, 6, %i0
205cda0: b0 07 40 18 add %i5, %i0, %i0
205cda4: fa 00 61 48 ld [ %g1 + 0x148 ], %i5
205cda8: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
205cdac: 7f ff 31 30 call 202926c <rtems_filesystem_node_type>
205cdb0: 90 07 60 1c add %i5, 0x1c, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
205cdb4: 80 a2 20 00 cmp %o0, 0
205cdb8: 22 80 00 08 be,a 205cdd8 <getdents+0x5c>
205cdbc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
rtems_set_errno_and_return_minus_one( ENOTDIR );
205cdc0: 7f ff 93 b8 call 2041ca0 <__errno>
205cdc4: b0 10 3f ff mov -1, %i0
205cdc8: 82 10 20 14 mov 0x14, %g1
205cdcc: c2 22 00 00 st %g1, [ %o0 ]
205cdd0: 81 c7 e0 08 ret
205cdd4: 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 );
205cdd8: 90 10 00 1d mov %i5, %o0
205cddc: c2 00 60 08 ld [ %g1 + 8 ], %g1
205cde0: 92 10 00 19 mov %i1, %o1
205cde4: 9f c0 40 00 call %g1
205cde8: 94 10 00 1a mov %i2, %o2
}
205cdec: 81 c7 e0 08 ret
205cdf0: 91 e8 00 08 restore %g0, %o0, %o0
02027e9c <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
2027e9c: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
2027ea0: 03 00 81 ba sethi %hi(0x206e800), %g1
2027ea4: c4 48 63 58 ldsb [ %g1 + 0x358 ], %g2 ! 206eb58 <etc_passwd_initted.6868>
2027ea8: 80 a0 a0 00 cmp %g2, 0
2027eac: 12 80 00 32 bne 2027f74 <init_etc_passwd_group+0xd8>
2027eb0: 01 00 00 00 nop
return;
etc_passwd_initted = 1;
2027eb4: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
mkdir("/etc", 0777);
2027eb8: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
2027ebc: c4 28 63 58 stb %g2, [ %g1 + 0x358 ]
mkdir("/etc", 0777);
2027ec0: 11 00 81 77 sethi %hi(0x205dc00), %o0
2027ec4: 7f ff 84 1b call 2008f30 <mkdir>
2027ec8: 90 12 23 18 or %o0, 0x318, %o0 ! 205df18 <_rodata_start+0x9e8>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
2027ecc: 3b 00 81 77 sethi %hi(0x205dc00), %i5
2027ed0: 13 00 81 a9 sethi %hi(0x206a400), %o1
2027ed4: 90 17 63 a0 or %i5, 0x3a0, %o0
2027ed8: 40 00 6a 29 call 204277c <fopen>
2027edc: 92 12 61 a0 or %o1, 0x1a0, %o1
2027ee0: 80 a2 20 00 cmp %o0, 0
2027ee4: 12 80 00 0d bne 2027f18 <init_etc_passwd_group+0x7c>
2027ee8: 01 00 00 00 nop
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
2027eec: 90 17 63 a0 or %i5, 0x3a0, %o0
2027ef0: 13 00 81 87 sethi %hi(0x2061c00), %o1
2027ef4: 40 00 6a 22 call 204277c <fopen>
2027ef8: 92 12 62 98 or %o1, 0x298, %o1 ! 2061e98 <rtems_rtc_shell_usage+0x518>
2027efc: b0 92 20 00 orcc %o0, 0, %i0
2027f00: 02 80 00 08 be 2027f20 <init_etc_passwd_group+0x84> <== NEVER TAKEN
2027f04: 11 00 81 8f sethi %hi(0x2063c00), %o0
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
2027f08: 92 10 00 18 mov %i0, %o1
2027f0c: 40 00 6a 80 call 204290c <fputs>
2027f10: 90 12 22 40 or %o0, 0x240, %o0
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
2027f14: 90 10 00 18 mov %i0, %o0
2027f18: 40 00 67 b4 call 2041de8 <fclose>
2027f1c: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
2027f20: 3b 00 81 78 sethi %hi(0x205e000), %i5
2027f24: 13 00 81 a9 sethi %hi(0x206a400), %o1
2027f28: 90 17 60 58 or %i5, 0x58, %o0
2027f2c: 40 00 6a 14 call 204277c <fopen>
2027f30: 92 12 61 a0 or %o1, 0x1a0, %o1
2027f34: b0 92 20 00 orcc %o0, 0, %i0
2027f38: 12 80 00 0d bne 2027f6c <init_etc_passwd_group+0xd0>
2027f3c: 01 00 00 00 nop
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
2027f40: 90 17 60 58 or %i5, 0x58, %o0
2027f44: 13 00 81 87 sethi %hi(0x2061c00), %o1
2027f48: 40 00 6a 0d call 204277c <fopen>
2027f4c: 92 12 62 98 or %o1, 0x298, %o1 ! 2061e98 <rtems_rtc_shell_usage+0x518>
2027f50: b0 92 20 00 orcc %o0, 0, %i0
2027f54: 02 80 00 08 be 2027f74 <init_etc_passwd_group+0xd8> <== NEVER TAKEN
2027f58: 01 00 00 00 nop
fprintf( fp, "root:x:0:root\n"
2027f5c: 11 00 81 8f sethi %hi(0x2063c00), %o0
2027f60: 92 10 00 18 mov %i0, %o1
2027f64: 40 00 6a 6a call 204290c <fputs>
2027f68: 90 12 22 a8 or %o0, 0x2a8, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
2027f6c: 40 00 67 9f call 2041de8 <fclose>
2027f70: 81 e8 00 00 restore
2027f74: 81 c7 e0 08 ret
2027f78: 81 e8 00 00 restore
020062e4 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
20062e4: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
20062e8: c4 06 60 30 ld [ %i1 + 0x30 ], %g2
20062ec: 80 88 a0 20 btst 0x20, %g2
20062f0: 32 80 00 02 bne,a 20062f8 <iproc+0x14> <== NEVER TAKEN
20062f4: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
20062f8: 80 88 a2 00 btst 0x200, %g2
20062fc: 02 80 00 0c be 200632c <iproc+0x48>
2006300: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
2006304: 03 00 80 74 sethi %hi(0x201d000), %g1
2006308: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 201d1c0 <__ctype_ptr__>
200630c: 82 00 40 18 add %g1, %i0, %g1
2006310: c2 08 60 01 ldub [ %g1 + 1 ], %g1
2006314: 82 08 60 03 and %g1, 3, %g1
2006318: 80 a0 60 01 cmp %g1, 1
200631c: 22 80 00 02 be,a 2006324 <iproc+0x40>
2006320: b0 06 20 20 add %i0, 0x20, %i0
2006324: b0 0e 20 ff and %i0, 0xff, %i0
if (c == '\r') {
2006328: 80 a6 20 0d cmp %i0, 0xd
200632c: 12 80 00 0a bne 2006354 <iproc+0x70>
2006330: 80 a6 20 0a cmp %i0, 0xa
if (tty->termios.c_iflag & IGNCR)
2006334: 80 88 a0 80 btst 0x80, %g2
2006338: 12 80 00 5b bne 20064a4 <iproc+0x1c0> <== NEVER TAKEN
200633c: 82 10 20 00 clr %g1
return 0;
if (tty->termios.c_iflag & ICRNL)
2006340: 80 88 a1 00 btst 0x100, %g2
2006344: 32 80 00 0d bne,a 2006378 <iproc+0x94> <== ALWAYS TAKEN
2006348: 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)) {
200634c: 10 80 00 0c b 200637c <iproc+0x98> <== NOT EXECUTED
2006350: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== 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)) {
2006354: 12 80 00 07 bne 2006370 <iproc+0x8c>
2006358: 80 a6 20 00 cmp %i0, 0
200635c: 80 88 a0 40 btst 0x40, %g2
2006360: 32 80 00 06 bne,a 2006378 <iproc+0x94> <== NEVER TAKEN
2006364: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
2006368: 10 80 00 05 b 200637c <iproc+0x98>
200636c: c4 06 60 3c ld [ %i1 + 0x3c ], %g2
2006370: 02 80 00 3a be 2006458 <iproc+0x174> <== NEVER TAKEN
2006374: 03 00 80 74 sethi %hi(0x201d000), %g1
2006378: c4 06 60 3c ld [ %i1 + 0x3c ], %g2
200637c: 80 88 a0 02 btst 2, %g2
2006380: 02 80 00 36 be 2006458 <iproc+0x174>
2006384: 03 00 80 74 sethi %hi(0x201d000), %g1
if (c == tty->termios.c_cc[VERASE]) {
2006388: c2 0e 60 43 ldub [ %i1 + 0x43 ], %g1
erase (tty, 0);
200638c: 90 10 00 19 mov %i1, %o0
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
2006390: 80 a0 40 18 cmp %g1, %i0
2006394: 02 80 00 08 be 20063b4 <iproc+0xd0>
2006398: 92 10 20 00 clr %o1
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
200639c: c2 0e 60 44 ldub [ %i1 + 0x44 ], %g1
20063a0: 80 a0 40 18 cmp %g1, %i0
20063a4: 32 80 00 08 bne,a 20063c4 <iproc+0xe0>
20063a8: c6 0e 60 45 ldub [ %i1 + 0x45 ], %g3
erase (tty, 1);
20063ac: 90 10 00 19 mov %i1, %o0
20063b0: 92 10 20 01 mov 1, %o1
20063b4: 7f ff ff 46 call 20060cc <erase>
20063b8: 01 00 00 00 nop
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
20063bc: 10 80 00 3a b 20064a4 <iproc+0x1c0>
20063c0: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
20063c4: 80 a0 c0 18 cmp %g3, %i0
20063c8: 02 80 00 37 be 20064a4 <iproc+0x1c0> <== NEVER TAKEN
20063cc: 82 10 20 01 mov 1, %g1
return 1;
} else if (c == '\n') {
20063d0: 80 a6 20 0a cmp %i0, 0xa
20063d4: 32 80 00 0d bne,a 2006408 <iproc+0x124>
20063d8: c2 0e 60 4c ldub [ %i1 + 0x4c ], %g1
if (tty->termios.c_lflag & (ECHO | ECHONL))
20063dc: 80 88 a0 48 btst 0x48, %g2
20063e0: 22 80 00 06 be,a 20063f8 <iproc+0x114> <== NEVER TAKEN
20063e4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
20063e8: 90 10 20 0a mov 0xa, %o0
20063ec: 7f ff ff 18 call 200604c <echo>
20063f0: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
20063f4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20063f8: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
20063fc: 86 10 20 0a mov 0xa, %g3
2006400: 10 80 00 12 b 2006448 <iproc+0x164>
2006404: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
2006408: 80 a0 40 18 cmp %g1, %i0
200640c: 02 80 00 07 be 2006428 <iproc+0x144> <== NEVER TAKEN
2006410: 80 88 a0 08 btst 8, %g2
2006414: c2 0e 60 51 ldub [ %i1 + 0x51 ], %g1
2006418: 80 a0 40 18 cmp %g1, %i0
200641c: 12 80 00 0f bne 2006458 <iproc+0x174> <== ALWAYS TAKEN
2006420: 03 00 80 74 sethi %hi(0x201d000), %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
2006424: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED
2006428: 22 80 00 06 be,a 2006440 <iproc+0x15c> <== NOT EXECUTED
200642c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
2006430: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2006434: 7f ff ff 06 call 200604c <echo> <== NOT EXECUTED
2006438: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
200643c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
2006440: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
2006444: f0 28 80 01 stb %i0, [ %g2 + %g1 ] <== NOT EXECUTED
2006448: 82 00 60 01 inc %g1
200644c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
return 1;
2006450: 10 80 00 15 b 20064a4 <iproc+0x1c0>
2006454: 82 10 20 01 mov 1, %g1
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
2006458: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
200645c: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
2006460: 84 00 bf ff add %g2, -1, %g2
2006464: 80 a0 c0 02 cmp %g3, %g2
2006468: 1a 80 00 0f bcc 20064a4 <iproc+0x1c0> <== NEVER TAKEN
200646c: 82 10 20 00 clr %g1
if (tty->termios.c_lflag & ECHO)
2006470: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
2006474: 80 88 60 08 btst 8, %g1
2006478: 22 80 00 06 be,a 2006490 <iproc+0x1ac> <== NEVER TAKEN
200647c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
2006480: 90 10 00 18 mov %i0, %o0
2006484: 7f ff fe f2 call 200604c <echo>
2006488: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
200648c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2006490: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
2006494: f0 28 80 01 stb %i0, [ %g2 + %g1 ]
2006498: 82 00 60 01 inc %g1
200649c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
return 0;
20064a0: 82 10 20 00 clr %g1
}
20064a4: 81 c7 e0 08 ret
20064a8: 91 e8 00 01 restore %g0, %g1, %o0
0201a464 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
201a464: 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() )
201a468: 7f ff fe f9 call 201a04c <getpid>
201a46c: 01 00 00 00 nop
201a470: 80 a6 00 08 cmp %i0, %o0
201a474: 02 80 00 06 be 201a48c <killinfo+0x28>
201a478: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
201a47c: 7f ff d4 fe call 200f874 <__errno>
201a480: 01 00 00 00 nop
201a484: 10 80 00 a5 b 201a718 <killinfo+0x2b4>
201a488: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
/*
* Validate the signal passed.
*/
if ( !sig )
201a48c: 02 80 00 06 be 201a4a4 <killinfo+0x40>
201a490: 01 00 00 00 nop
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
201a494: ba 06 7f ff add %i1, -1, %i5
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201a498: 80 a7 60 1f cmp %i5, 0x1f
201a49c: 28 80 00 06 bleu,a 201a4b4 <killinfo+0x50>
201a4a0: 83 2e 60 02 sll %i1, 2, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
201a4a4: 7f ff d4 f4 call 200f874 <__errno>
201a4a8: 01 00 00 00 nop
201a4ac: 10 80 00 9b b 201a718 <killinfo+0x2b4>
201a4b0: 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 )
201a4b4: 85 2e 60 04 sll %i1, 4, %g2
201a4b8: 84 20 80 01 sub %g2, %g1, %g2
201a4bc: 03 00 80 78 sethi %hi(0x201e000), %g1
201a4c0: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 201e1b0 <_POSIX_signals_Vectors>
201a4c4: 82 00 40 02 add %g1, %g2, %g1
201a4c8: c2 00 60 08 ld [ %g1 + 8 ], %g1
201a4cc: 80 a0 60 01 cmp %g1, 1
201a4d0: 02 80 00 7b be 201a6bc <killinfo+0x258>
201a4d4: b0 10 20 00 clr %i0
/*
* 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 ) )
201a4d8: 80 a6 60 04 cmp %i1, 4
201a4dc: 02 80 00 06 be 201a4f4 <killinfo+0x90>
201a4e0: 80 a6 60 08 cmp %i1, 8
201a4e4: 02 80 00 04 be 201a4f4 <killinfo+0x90>
201a4e8: 80 a6 60 0b cmp %i1, 0xb
201a4ec: 12 80 00 08 bne 201a50c <killinfo+0xa8>
201a4f0: 82 10 20 01 mov 1, %g1
return pthread_kill( pthread_self(), sig );
201a4f4: 40 00 01 2e call 201a9ac <pthread_self>
201a4f8: 01 00 00 00 nop
201a4fc: 40 00 00 f2 call 201a8c4 <pthread_kill>
201a500: 92 10 00 19 mov %i1, %o1
201a504: 81 c7 e0 08 ret
201a508: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
201a50c: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
201a510: c2 27 bf f8 st %g1, [ %fp + -8 ]
if ( !value ) {
201a514: 80 a6 a0 00 cmp %i2, 0
201a518: 12 80 00 04 bne 201a528 <killinfo+0xc4>
201a51c: bb 28 40 1d sll %g1, %i5, %i5
siginfo->si_value.sival_int = 0;
201a520: 10 80 00 04 b 201a530 <killinfo+0xcc>
201a524: c0 27 bf fc clr [ %fp + -4 ]
} else {
siginfo->si_value = *value;
201a528: c2 06 80 00 ld [ %i2 ], %g1
201a52c: 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++;
201a530: 03 00 80 77 sethi %hi(0x201dc00), %g1
201a534: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201dc10 <_Thread_Dispatch_disable_level>
201a538: 84 00 a0 01 inc %g2
201a53c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
return _Thread_Dispatch_disable_level;
201a540: c2 00 60 10 ld [ %g1 + 0x10 ], %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;
201a544: 03 00 80 78 sethi %hi(0x201e000), %g1
201a548: d0 00 61 5c ld [ %g1 + 0x15c ], %o0 ! 201e15c <_Per_CPU_Information+0xc>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
201a54c: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
201a550: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1
201a554: 80 af 40 01 andncc %i5, %g1, %g0
201a558: 12 80 00 51 bne 201a69c <killinfo+0x238>
201a55c: 03 00 80 78 sethi %hi(0x201e000), %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
201a560: d0 00 63 3c ld [ %g1 + 0x33c ], %o0 ! 201e33c <_POSIX_signals_Wait_queue>
/* 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 );
201a564: 03 00 80 78 sethi %hi(0x201e000), %g1
201a568: 10 80 00 0a b 201a590 <killinfo+0x12c>
201a56c: 82 10 63 40 or %g1, 0x340, %g1 ! 201e340 <_POSIX_signals_Wait_queue+0x4>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
201a570: 80 8f 40 03 btst %i5, %g3
201a574: 12 80 00 4a bne 201a69c <killinfo+0x238>
201a578: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
201a57c: c4 00 a0 d0 ld [ %g2 + 0xd0 ], %g2
201a580: 80 af 40 02 andncc %i5, %g2, %g0
201a584: 12 80 00 47 bne 201a6a0 <killinfo+0x23c>
201a588: 92 10 00 19 mov %i1, %o1
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 ) {
201a58c: d0 02 00 00 ld [ %o0 ], %o0
/* 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 );
201a590: 80 a2 00 01 cmp %o0, %g1
201a594: 32 bf ff f7 bne,a 201a570 <killinfo+0x10c>
201a598: c6 02 20 30 ld [ %o0 + 0x30 ], %g3
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201a59c: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a5a0: c4 08 62 74 ldub [ %g1 + 0x274 ], %g2 ! 201ce74 <rtems_maximum_priority>
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
201a5a4: 90 10 20 00 clr %o0
interested_priority = PRIORITY_MAXIMUM + 1;
201a5a8: 84 00 a0 01 inc %g2
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
201a5ac: 88 10 20 02 mov 2, %g4
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
201a5b0: 19 00 80 76 sethi %hi(0x201d800), %o4
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
201a5b4: 31 04 00 00 sethi %hi(0x10000000), %i0
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
201a5b8: 83 29 20 02 sll %g4, 2, %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 ] )
201a5bc: 86 13 23 78 or %o4, 0x378, %g3
201a5c0: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
201a5c4: 80 a0 60 00 cmp %g1, 0
201a5c8: 22 80 00 2f be,a 201a684 <killinfo+0x220> <== NEVER TAKEN
201a5cc: 88 01 20 01 inc %g4 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
201a5d0: c2 00 60 04 ld [ %g1 + 4 ], %g1
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a5d4: b4 10 20 01 mov 1, %i2
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
201a5d8: d4 10 60 10 lduh [ %g1 + 0x10 ], %o2
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a5dc: 10 80 00 26 b 201a674 <killinfo+0x210>
201a5e0: d6 00 60 1c ld [ %g1 + 0x1c ], %o3
the_thread = (Thread_Control *) object_table[ index ];
201a5e4: c2 02 c0 01 ld [ %o3 + %g1 ], %g1
if ( !the_thread )
201a5e8: 80 a0 60 00 cmp %g1, 0
201a5ec: 22 80 00 22 be,a 201a674 <killinfo+0x210>
201a5f0: b4 06 a0 01 inc %i2
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
201a5f4: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
201a5f8: 80 a0 c0 02 cmp %g3, %g2
201a5fc: 38 80 00 1e bgu,a 201a674 <killinfo+0x210>
201a600: b4 06 a0 01 inc %i2
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
201a604: de 00 61 5c ld [ %g1 + 0x15c ], %o7
201a608: de 03 e0 d0 ld [ %o7 + 0xd0 ], %o7
201a60c: 80 af 40 0f andncc %i5, %o7, %g0
201a610: 22 80 00 19 be,a 201a674 <killinfo+0x210>
201a614: b4 06 a0 01 inc %i2
*
* 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 ) {
201a618: 80 a0 c0 02 cmp %g3, %g2
201a61c: 2a 80 00 14 bcs,a 201a66c <killinfo+0x208>
201a620: 84 10 00 03 mov %g3, %g2
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
201a624: 80 a2 20 00 cmp %o0, 0
201a628: 22 80 00 13 be,a 201a674 <killinfo+0x210> <== NEVER TAKEN
201a62c: b4 06 a0 01 inc %i2 <== NOT EXECUTED
201a630: da 02 20 10 ld [ %o0 + 0x10 ], %o5
201a634: 80 a3 60 00 cmp %o5, 0
201a638: 22 80 00 0f be,a 201a674 <killinfo+0x210> <== NEVER TAKEN
201a63c: b4 06 a0 01 inc %i2 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201a640: de 00 60 10 ld [ %g1 + 0x10 ], %o7
201a644: 80 a3 e0 00 cmp %o7, 0
201a648: 22 80 00 09 be,a 201a66c <killinfo+0x208>
201a64c: 84 10 00 03 mov %g3, %g2
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
201a650: 80 8b 40 18 btst %o5, %i0
201a654: 32 80 00 08 bne,a 201a674 <killinfo+0x210>
201a658: b4 06 a0 01 inc %i2
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
201a65c: 80 8b c0 18 btst %o7, %i0
201a660: 22 80 00 05 be,a 201a674 <killinfo+0x210>
201a664: b4 06 a0 01 inc %i2
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201a668: 84 10 00 03 mov %g3, %g2
201a66c: 90 10 00 01 mov %g1, %o0
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a670: b4 06 a0 01 inc %i2
201a674: 80 a6 80 0a cmp %i2, %o2
201a678: 08 bf ff db bleu 201a5e4 <killinfo+0x180>
201a67c: 83 2e a0 02 sll %i2, 2, %g1
* + 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++) {
201a680: 88 01 20 01 inc %g4
201a684: 80 a1 20 04 cmp %g4, 4
201a688: 12 bf ff cd bne 201a5bc <killinfo+0x158>
201a68c: 83 29 20 02 sll %g4, 2, %g1
}
}
}
}
if ( interested ) {
201a690: 80 a2 20 00 cmp %o0, 0
201a694: 02 80 00 0c be 201a6c4 <killinfo+0x260>
201a698: 01 00 00 00 nop
/*
* 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 ) ) {
201a69c: 92 10 00 19 mov %i1, %o1
201a6a0: 40 00 00 36 call 201a778 <_POSIX_signals_Unblock_thread>
201a6a4: 94 07 bf f4 add %fp, -12, %o2
201a6a8: 80 8a 20 ff btst 0xff, %o0
201a6ac: 02 80 00 06 be 201a6c4 <killinfo+0x260>
201a6b0: 01 00 00 00 nop
_Thread_Enable_dispatch();
201a6b4: 7f ff be b3 call 200a180 <_Thread_Enable_dispatch>
201a6b8: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return 0;
201a6bc: 81 c7 e0 08 ret
201a6c0: 81 e8 00 00 restore
/*
* 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 );
201a6c4: 40 00 00 24 call 201a754 <_POSIX_signals_Set_process_signals>
201a6c8: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
201a6cc: 83 2e 60 02 sll %i1, 2, %g1
201a6d0: b3 2e 60 04 sll %i1, 4, %i1
201a6d4: b2 26 40 01 sub %i1, %g1, %i1
201a6d8: 03 00 80 78 sethi %hi(0x201e000), %g1
201a6dc: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 201e1b0 <_POSIX_signals_Vectors>
201a6e0: c2 00 40 19 ld [ %g1 + %i1 ], %g1
201a6e4: 80 a0 60 02 cmp %g1, 2
201a6e8: 12 80 00 17 bne 201a744 <killinfo+0x2e0>
201a6ec: 11 00 80 78 sethi %hi(0x201e000), %o0
psiginfo = (POSIX_signals_Siginfo_node *)
201a6f0: 7f ff b7 08 call 2008310 <_Chain_Get>
201a6f4: 90 12 23 30 or %o0, 0x330, %o0 ! 201e330 <_POSIX_signals_Inactive_siginfo>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
201a6f8: ba 92 20 00 orcc %o0, 0, %i5
201a6fc: 12 80 00 0a bne 201a724 <killinfo+0x2c0>
201a700: 92 07 bf f4 add %fp, -12, %o1
_Thread_Enable_dispatch();
201a704: 7f ff be 9f call 200a180 <_Thread_Enable_dispatch>
201a708: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
201a70c: 7f ff d4 5a call 200f874 <__errno>
201a710: 01 00 00 00 nop
201a714: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
201a718: c2 22 00 00 st %g1, [ %o0 ]
201a71c: 81 c7 e0 08 ret
201a720: 91 e8 3f ff restore %g0, -1, %o0
}
psiginfo->Info = *siginfo;
201a724: 90 07 60 08 add %i5, 8, %o0
201a728: 7f ff d6 af call 20101e4 <memcpy>
201a72c: 94 10 20 0c mov 0xc, %o2
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201a730: 11 00 80 78 sethi %hi(0x201e000), %o0
201a734: 92 10 00 1d mov %i5, %o1
201a738: 90 12 23 a8 or %o0, 0x3a8, %o0
201a73c: 7f ff b6 ea call 20082e4 <_Chain_Append>
201a740: 90 02 00 19 add %o0, %i1, %o0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
201a744: 7f ff be 8f call 200a180 <_Thread_Enable_dispatch>
201a748: b0 10 20 00 clr %i0
return 0;
}
201a74c: 81 c7 e0 08 ret
201a750: 81 e8 00 00 restore
02003ff0 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
2003ff0: 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()))
2003ff4: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003ff8: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 ! 201dd68 <_System_state_Current>
2003ffc: 80 a0 60 03 cmp %g1, 3
2004000: 12 80 00 16 bne 2004058 <libc_wrapup+0x68> <== NEVER TAKEN
2004004: 39 00 80 74 sethi %hi(0x201d000), %i4
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
2004008: 03 00 80 70 sethi %hi(0x201c000), %g1
200400c: fa 00 63 a8 ld [ %g1 + 0x3a8 ], %i5 ! 201c3a8 <_global_impure_ptr>
2004010: c2 07 21 c8 ld [ %i4 + 0x1c8 ], %g1
2004014: 80 a0 40 1d cmp %g1, %i5
2004018: 22 80 00 06 be,a 2004030 <libc_wrapup+0x40>
200401c: 3b 00 80 74 sethi %hi(0x201d000), %i5
_wrapup_reent(_global_impure_ptr);
2004020: 40 00 31 51 call 2010564 <_wrapup_reent>
2004024: 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;
2004028: fa 27 21 c8 st %i5, [ %i4 + 0x1c8 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
200402c: 3b 00 80 74 sethi %hi(0x201d000), %i5
2004030: c2 07 61 c8 ld [ %i5 + 0x1c8 ], %g1 ! 201d1c8 <_impure_ptr>
2004034: 40 00 2e 62 call 200f9bc <fclose>
2004038: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
200403c: c2 07 61 c8 ld [ %i5 + 0x1c8 ], %g1
2004040: 40 00 2e 5f call 200f9bc <fclose>
2004044: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
2004048: c2 07 61 c8 ld [ %i5 + 0x1c8 ], %g1
200404c: f0 00 60 0c ld [ %g1 + 0xc ], %i0
2004050: 40 00 2e 5b call 200f9bc <fclose>
2004054: 81 e8 00 00 restore
2004058: 81 c7 e0 08 ret <== NOT EXECUTED
200405c: 81 e8 00 00 restore <== NOT EXECUTED
0201a06c <lseek>:
#include <unistd.h>
#include <rtems/libio_.h>
off_t lseek( int fd, off_t offset, int whence )
{
201a06c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
off_t reference_offset;
off_t old_offset;
off_t new_offset;
rtems_libio_check_fd( fd );
201a070: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a074: c2 00 63 5c ld [ %g1 + 0x35c ], %g1 ! 201cf5c <rtems_libio_number_iops>
#include <unistd.h>
#include <rtems/libio_.h>
off_t lseek( int fd, off_t offset, int whence )
{
201a078: a0 10 00 19 mov %i1, %l0
rtems_libio_t *iop;
off_t reference_offset;
off_t old_offset;
off_t new_offset;
rtems_libio_check_fd( fd );
201a07c: 80 a6 00 01 cmp %i0, %g1
201a080: 1a 80 00 0c bcc 201a0b0 <lseek+0x44>
201a084: a2 10 00 1a mov %i2, %l1
iop = rtems_libio_iop( fd );
201a088: b5 2e 20 03 sll %i0, 3, %i2
201a08c: 03 00 80 76 sethi %hi(0x201d800), %g1
201a090: b1 2e 20 06 sll %i0, 6, %i0
201a094: b0 06 80 18 add %i2, %i0, %i0
201a098: f4 00 62 98 ld [ %g1 + 0x298 ], %i2
201a09c: b4 06 80 18 add %i2, %i0, %i2
rtems_libio_check_is_open(iop);
201a0a0: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
201a0a4: 80 88 61 00 btst 0x100, %g1
201a0a8: 32 80 00 06 bne,a 201a0c0 <lseek+0x54>
201a0ac: e4 06 a0 10 ld [ %i2 + 0x10 ], %l2
201a0b0: 7f ff d5 f1 call 200f874 <__errno>
201a0b4: 01 00 00 00 nop
201a0b8: 10 80 00 44 b 201a1c8 <lseek+0x15c>
201a0bc: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
old_offset = iop->offset;
switch ( whence ) {
201a0c0: 80 a6 e0 01 cmp %i3, 1
201a0c4: 02 80 00 0b be 201a0f0 <lseek+0x84>
201a0c8: f2 06 a0 14 ld [ %i2 + 0x14 ], %i1
201a0cc: 80 a6 e0 02 cmp %i3, 2
201a0d0: 02 80 00 06 be 201a0e8 <lseek+0x7c>
201a0d4: 80 a6 e0 00 cmp %i3, 0
case SEEK_SET:
reference_offset = 0;
201a0d8: 84 10 20 00 clr %g2
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
old_offset = iop->offset;
switch ( whence ) {
201a0dc: 02 80 00 07 be 201a0f8 <lseek+0x8c>
201a0e0: 86 10 20 00 clr %g3
201a0e4: 30 80 00 30 b,a 201a1a4 <lseek+0x138>
case SEEK_CUR:
reference_offset = old_offset;
break;
case SEEK_END:
reference_offset = iop->size;
break;
201a0e8: 10 80 00 04 b 201a0f8 <lseek+0x8c>
201a0ec: c4 1e a0 08 ldd [ %i2 + 8 ], %g2
switch ( whence ) {
case SEEK_SET:
reference_offset = 0;
break;
case SEEK_CUR:
reference_offset = old_offset;
201a0f0: 84 10 00 12 mov %l2, %g2
201a0f4: 86 10 00 19 mov %i1, %g3
default:
errno = EINVAL;
rv = (off_t) -1;
break;
}
new_offset = reference_offset + offset;
201a0f8: ba 80 c0 11 addcc %g3, %l1, %i5
201a0fc: b8 40 80 10 addx %g2, %l0, %i4
if ( rv == 0 ) {
if (
(reference_offset >= 0 && new_offset >= offset)
201a100: 80 a4 00 1c cmp %l0, %i4
201a104: 14 80 00 08 bg 201a124 <lseek+0xb8>
201a108: 82 10 20 01 mov 1, %g1
201a10c: 80 a4 00 1c cmp %l0, %i4
201a110: 12 80 00 07 bne 201a12c <lseek+0xc0>
201a114: 80 88 60 ff btst 0xff, %g1
201a118: 80 a4 40 1d cmp %l1, %i5
201a11c: 08 80 00 04 bleu 201a12c <lseek+0xc0> <== ALWAYS TAKEN
201a120: 80 88 60 ff btst 0xff, %g1
201a124: 82 10 20 00 clr %g1
break;
}
new_offset = reference_offset + offset;
if ( rv == 0 ) {
if (
201a128: 80 88 60 ff btst 0xff, %g1
201a12c: 02 80 00 05 be 201a140 <lseek+0xd4>
201a130: 80 a7 00 10 cmp %i4, %l0
201a134: 80 a0 a0 00 cmp %g2, 0
201a138: 16 80 00 10 bge 201a178 <lseek+0x10c> <== ALWAYS TAKEN
201a13c: 80 a7 00 10 cmp %i4, %l0
(reference_offset >= 0 && new_offset >= offset)
|| (reference_offset < 0 && new_offset <= offset)
201a140: 14 80 00 08 bg 201a160 <lseek+0xf4> <== NEVER TAKEN
201a144: 82 10 20 01 mov 1, %g1
201a148: 80 a7 00 10 cmp %i4, %l0
201a14c: 12 80 00 07 bne 201a168 <lseek+0xfc> <== ALWAYS TAKEN
201a150: 80 88 60 ff btst 0xff, %g1
201a154: 80 a7 40 11 cmp %i5, %l1 <== NOT EXECUTED
201a158: 08 80 00 04 bleu 201a168 <lseek+0xfc> <== NOT EXECUTED
201a15c: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
201a160: 82 10 20 00 clr %g1 <== NOT EXECUTED
201a164: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
201a168: 02 80 00 15 be 201a1bc <lseek+0x150> <== NEVER TAKEN
201a16c: 80 a0 a0 00 cmp %g2, 0
201a170: 16 80 00 13 bge 201a1bc <lseek+0x150> <== ALWAYS TAKEN
201a174: 01 00 00 00 nop
) {
switch ( rtems_filesystem_node_type( &iop->pathinfo ) ) {
201a178: 40 00 00 6f call 201a334 <rtems_filesystem_node_type>
201a17c: 90 06 a0 1c add %i2, 0x1c, %o0
201a180: 80 a2 20 00 cmp %o0, 0
201a184: 02 80 00 06 be 201a19c <lseek+0x130>
201a188: 80 a7 20 00 cmp %i4, 0
201a18c: 80 a2 20 04 cmp %o0, 4
201a190: 32 80 00 15 bne,a 201a1e4 <lseek+0x178>
201a194: c2 06 a0 2c ld [ %i2 + 0x2c ], %g1
case RTEMS_FILESYSTEM_DIRECTORY:
case RTEMS_FILESYSTEM_MEMORY_FILE:
if ( new_offset < 0 ) {
201a198: 80 a7 20 00 cmp %i4, 0
201a19c: 36 80 00 12 bge,a 201a1e4 <lseek+0x178>
201a1a0: c2 06 a0 2c ld [ %i2 + 0x2c ], %g1
errno = EINVAL;
201a1a4: 7f ff d5 b4 call 200f874 <__errno>
201a1a8: 01 00 00 00 nop
201a1ac: 10 80 00 07 b 201a1c8 <lseek+0x15c>
201a1b0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
if ( rv == 0 ) {
iop->offset = new_offset;
rv = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
if ( rv == (off_t) -1 ) {
iop->offset = old_offset;
201a1b4: 10 80 00 09 b 201a1d8 <lseek+0x16c>
201a1b8: f2 26 a0 14 st %i1, [ %i2 + 0x14 ]
}
}
} else {
errno = EOVERFLOW;
201a1bc: 7f ff d5 ae call 200f874 <__errno>
201a1c0: 01 00 00 00 nop
201a1c4: 82 10 20 8b mov 0x8b, %g1 ! 8b <PROM_START+0x8b>
201a1c8: c2 22 00 00 st %g1, [ %o0 ]
rv = (off_t) -1;
201a1cc: 11 3f ff ff sethi %hi(0xfffffc00), %o0
201a1d0: 90 12 23 ff or %o0, 0x3ff, %o0 ! ffffffff <RAM_END+0xfdbfffff>
201a1d4: 92 10 00 08 mov %o0, %o1
}
}
return rv;
}
201a1d8: b0 10 00 08 mov %o0, %i0
201a1dc: 81 c7 e0 08 ret
201a1e0: 93 e8 00 09 restore %g0, %o1, %o1
default:
break;
}
if ( rv == 0 ) {
iop->offset = new_offset;
201a1e4: f8 3e a0 10 std %i4, [ %i2 + 0x10 ]
rv = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
201a1e8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
201a1ec: 90 10 00 1a mov %i2, %o0
201a1f0: 92 10 00 10 mov %l0, %o1
201a1f4: 94 10 00 11 mov %l1, %o2
201a1f8: 9f c0 40 00 call %g1
201a1fc: 96 10 00 1b mov %i3, %o3
if ( rv == (off_t) -1 ) {
201a200: 80 a2 3f ff cmp %o0, -1
201a204: 12 bf ff f6 bne 201a1dc <lseek+0x170>
201a208: b0 10 00 08 mov %o0, %i0
201a20c: 80 a2 7f ff cmp %o1, -1
201a210: 12 bf ff f3 bne 201a1dc <lseek+0x170> <== NEVER TAKEN
201a214: 01 00 00 00 nop
iop->offset = old_offset;
201a218: 10 bf ff e7 b 201a1b4 <lseek+0x148>
201a21c: e4 26 a0 10 st %l2, [ %i2 + 0x10 ]
02003ab0 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
2003ab0: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
2003ab4: 03 00 80 76 sethi %hi(0x201d800), %g1
2003ab8: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 201dab0 <rtems_malloc_statistics>
2003abc: c4 00 60 04 ld [ %g1 + 4 ], %g2
#include "malloc_p.h"
void *malloc(
size_t size
)
{
2003ac0: ba 10 00 18 mov %i0, %i5
void *return_this;
MSBUMP(malloc_calls, 1);
2003ac4: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2003ac8: 7f ff ff ae call 2003980 <malloc_deferred_frees_process>
2003acc: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
2003ad0: 80 a7 60 00 cmp %i5, 0
2003ad4: 02 80 00 23 be 2003b60 <malloc+0xb0>
2003ad8: b0 10 20 00 clr %i0
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2003adc: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003ae0: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 ! 201dd68 <_System_state_Current>
2003ae4: 80 a0 60 03 cmp %g1, 3
2003ae8: 12 80 00 07 bne 2003b04 <malloc+0x54>
2003aec: 03 00 80 73 sethi %hi(0x201cc00), %g1
!malloc_is_system_state_OK() )
2003af0: 7f ff ff 92 call 2003938 <malloc_is_system_state_OK>
2003af4: 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()) &&
2003af8: 80 8a 20 ff btst 0xff, %o0
2003afc: 02 80 00 19 be 2003b60 <malloc+0xb0> <== NEVER TAKEN
2003b00: 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 );
2003b04: d0 00 63 18 ld [ %g1 + 0x318 ], %o0 ! 201cf18 <RTEMS_Malloc_Heap>
2003b08: 92 10 00 1d mov %i5, %o1
2003b0c: 94 10 20 00 clr %o2
2003b10: 40 00 16 7c call 2009500 <_Protected_heap_Allocate_aligned_with_boundary>
2003b14: 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 ) {
2003b18: b0 92 20 00 orcc %o0, 0, %i0
2003b1c: 12 80 00 13 bne 2003b68 <malloc+0xb8>
2003b20: 03 00 80 75 sethi %hi(0x201d400), %g1
if (rtems_malloc_sbrk_helpers)
2003b24: 03 00 80 75 sethi %hi(0x201d400), %g1
2003b28: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 201d6f0 <rtems_malloc_sbrk_helpers>
2003b2c: 80 a0 60 00 cmp %g1, 0
2003b30: 02 80 00 08 be 2003b50 <malloc+0xa0>
2003b34: 01 00 00 00 nop
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
2003b38: c2 00 60 04 ld [ %g1 + 4 ], %g1
2003b3c: 9f c0 40 00 call %g1
2003b40: 90 10 00 1d mov %i5, %o0
if ( !return_this ) {
2003b44: b0 92 20 00 orcc %o0, 0, %i0
2003b48: 12 80 00 08 bne 2003b68 <malloc+0xb8>
2003b4c: 03 00 80 75 sethi %hi(0x201d400), %g1
errno = ENOMEM;
2003b50: 40 00 2f 49 call 200f874 <__errno>
2003b54: b0 10 20 00 clr %i0
2003b58: 82 10 20 0c mov 0xc, %g1
2003b5c: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
2003b60: 81 c7 e0 08 ret
2003b64: 81 e8 00 00 restore
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
2003b68: c2 00 62 ec ld [ %g1 + 0x2ec ], %g1
2003b6c: 80 a0 60 00 cmp %g1, 0
2003b70: 02 80 00 04 be 2003b80 <malloc+0xd0>
2003b74: 90 10 00 18 mov %i0, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
2003b78: 9f c0 40 00 call %g1
2003b7c: 92 10 00 1d mov %i5, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
2003b80: 03 00 80 75 sethi %hi(0x201d400), %g1
2003b84: c2 00 62 f4 ld [ %g1 + 0x2f4 ], %g1 ! 201d6f4 <rtems_malloc_statistics_helpers>
2003b88: 80 a0 60 00 cmp %g1, 0
2003b8c: 02 80 00 05 be 2003ba0 <malloc+0xf0>
2003b90: 01 00 00 00 nop
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
2003b94: c2 00 60 04 ld [ %g1 + 4 ], %g1
2003b98: 9f c0 40 00 call %g1
2003b9c: 90 10 00 18 mov %i0, %o0
return return_this;
}
2003ba0: 81 c7 e0 08 ret
2003ba4: 81 e8 00 00 restore
02003b34 <malloc_sbrk_extend_and_allocate>:
}
static void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
2003b34: 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;
2003b38: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003b3c: fa 00 62 38 ld [ %g1 + 0x238 ], %i5 ! 201de38 <RTEMS_Malloc_Sbrk_amount>
if ( sbrk_amount == 0 )
2003b40: 80 a7 60 00 cmp %i5, 0
2003b44: 02 80 00 22 be 2003bcc <malloc_sbrk_extend_and_allocate+0x98><== NEVER TAKEN
2003b48: b2 10 00 18 mov %i0, %i1
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
2003b4c: 92 10 00 1d mov %i5, %o1
2003b50: 40 00 53 d5 call 2018aa4 <.udiv>
2003b54: 90 06 00 1d add %i0, %i5, %o0
2003b58: 40 00 53 99 call 20189bc <.umul>
2003b5c: 92 10 00 1d mov %i5, %o1
starting_address = (void *) sbrk(the_size);
2003b60: 7f ff f6 2e call 2001418 <sbrk>
2003b64: ba 10 00 08 mov %o0, %i5
if ( starting_address == (void*) -1 )
2003b68: 80 a2 3f ff cmp %o0, -1
2003b6c: 02 80 00 18 be 2003bcc <malloc_sbrk_extend_and_allocate+0x98>
2003b70: 92 10 00 08 mov %o0, %o1
return (void *) 0;
if ( !_Protected_heap_Extend(
2003b74: 39 00 80 74 sethi %hi(0x201d000), %i4
2003b78: d0 07 21 08 ld [ %i4 + 0x108 ], %o0 ! 201d108 <RTEMS_Malloc_Heap>
2003b7c: 40 00 16 4f call 20094b8 <_Protected_heap_Extend>
2003b80: 94 10 00 1d mov %i5, %o2
2003b84: 80 8a 20 ff btst 0xff, %o0
2003b88: 12 80 00 0a bne 2003bb0 <malloc_sbrk_extend_and_allocate+0x7c>
2003b8c: 03 00 80 77 sethi %hi(0x201dc00), %g1
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
2003b90: 7f ff f6 22 call 2001418 <sbrk>
2003b94: 90 20 00 1d neg %i5, %o0
errno = ENOMEM;
2003b98: 40 00 2f db call 200fb04 <__errno>
2003b9c: b0 10 20 00 clr %i0
2003ba0: 82 10 20 0c mov 0xc, %g1
2003ba4: c2 22 00 00 st %g1, [ %o0 ]
2003ba8: 81 c7 e0 08 ret
2003bac: 81 e8 00 00 restore
2003bb0: f0 07 21 08 ld [ %i4 + 0x108 ], %i0
return (void *) 0;
}
MSBUMP(space_available, the_size);
2003bb4: c4 00 62 08 ld [ %g1 + 0x208 ], %g2
2003bb8: b4 10 20 00 clr %i2
2003bbc: ba 07 40 02 add %i5, %g2, %i5
2003bc0: fa 20 62 08 st %i5, [ %g1 + 0x208 ]
2003bc4: 40 00 16 2f call 2009480 <_Protected_heap_Allocate_aligned_with_boundary>
2003bc8: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
2003bcc: b0 10 20 00 clr %i0
2003bd0: 81 c7 e0 08 ret
2003bd4: 81 e8 00 00 restore
02003bd8 <malloc_sbrk_initialize>:
static void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
2003bd8: 9d e3 bf a0 save %sp, -96, %sp
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
2003bdc: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003be0: f2 20 62 38 st %i1, [ %g1 + 0x238 ] ! 201de38 <RTEMS_Malloc_Sbrk_amount>
* 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) {
2003be4: 80 a6 20 00 cmp %i0, 0
2003be8: 12 80 00 0e bne 2003c20 <malloc_sbrk_initialize+0x48>
2003bec: 90 10 00 19 mov %i1, %o0
uaddress = (uintptr_t)sbrk(length);
2003bf0: 7f ff f6 0a call 2001418 <sbrk>
2003bf4: 01 00 00 00 nop
if (uaddress == (uintptr_t) -1) {
2003bf8: 80 a2 3f ff cmp %o0, -1
2003bfc: 12 80 00 04 bne 2003c0c <malloc_sbrk_initialize+0x34> <== NEVER TAKEN
2003c00: 80 8a 20 07 btst 7, %o0
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
2003c04: 40 00 10 ec call 2007fb4 <rtems_fatal_error_occurred>
2003c08: 90 10 20 1a mov 0x1a, %o0
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
2003c0c: 22 80 00 05 be,a 2003c20 <malloc_sbrk_initialize+0x48> <== NOT EXECUTED
2003c10: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
2003c14: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
2003c18: 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;
2003c1c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
return starting_address;
}
2003c20: 81 c7 e0 08 ret
2003c24: 81 e8 00 00 restore
0200e9b4 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
200e9b4: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
200e9b8: fa 06 20 24 ld [ %i0 + 0x24 ], %i5
*/
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
200e9bc: 92 10 00 19 mov %i1, %o1
* 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 )
200e9c0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
200e9c4: 80 a0 40 19 cmp %g1, %i1
200e9c8: 06 80 00 09 bl 200e9ec <memfile_ftruncate+0x38> <== NEVER TAKEN
200e9cc: 94 10 00 1a mov %i2, %o2
200e9d0: 80 a0 40 19 cmp %g1, %i1
200e9d4: 32 80 00 0a bne,a 200e9fc <memfile_ftruncate+0x48> <== NEVER TAKEN
200e9d8: d2 27 60 50 st %o1, [ %i5 + 0x50 ] <== NOT EXECUTED
200e9dc: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
200e9e0: 80 a0 40 1a cmp %g1, %i2
200e9e4: 3a 80 00 06 bcc,a 200e9fc <memfile_ftruncate+0x48>
200e9e8: d2 27 60 50 st %o1, [ %i5 + 0x50 ]
return IMFS_memfile_extend( the_jnode, length );
200e9ec: 7f ff fe ff call 200e5e8 <IMFS_memfile_extend>
200e9f0: 90 10 00 1d mov %i5, %o0
200e9f4: 81 c7 e0 08 ret
200e9f8: 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;
200e9fc: d4 27 60 54 st %o2, [ %i5 + 0x54 ]
iop->size = the_jnode->info.file.size;
200ea00: d2 26 20 08 st %o1, [ %i0 + 8 ]
200ea04: d4 26 20 0c st %o2, [ %i0 + 0xc ]
IMFS_update_atime( the_jnode );
200ea08: 90 07 bf f8 add %fp, -8, %o0
200ea0c: 7f ff d3 6b call 20037b8 <gettimeofday>
200ea10: 92 10 20 00 clr %o1
200ea14: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ea18: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return 0;
}
200ea1c: 81 c7 e0 08 ret
200ea20: 91 e8 20 00 restore %g0, 0, %o0
0200ea24 <memfile_lseek>:
off_t memfile_lseek(
rtems_libio_t *iop,
off_t offset,
int whence
)
{
200ea24: 9d e3 bf a0 save %sp, -96, %sp
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
200ea28: fa 06 20 24 ld [ %i0 + 0x24 ], %i5
200ea2c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE) {
200ea30: c2 00 40 00 ld [ %g1 ], %g1
200ea34: 80 a0 60 05 cmp %g1, 5
200ea38: 32 80 00 11 bne,a 200ea7c <memfile_lseek+0x58>
200ea3c: c4 1e 20 10 ldd [ %i0 + 0x10 ], %g2
if (iop->offset > the_jnode->info.linearfile.size)
200ea40: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
200ea44: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
200ea48: 80 a0 c0 01 cmp %g3, %g1
200ea4c: 14 80 00 09 bg 200ea70 <memfile_lseek+0x4c> <== NEVER TAKEN
200ea50: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
200ea54: 80 a0 c0 01 cmp %g3, %g1
200ea58: 32 80 00 19 bne,a 200eabc <memfile_lseek+0x98> <== NEVER TAKEN
200ea5c: f0 1e 20 10 ldd [ %i0 + 0x10 ], %i0 <== NOT EXECUTED
200ea60: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
200ea64: 80 a0 c0 02 cmp %g3, %g2
200ea68: 28 80 00 15 bleu,a 200eabc <memfile_lseek+0x98> <== ALWAYS TAKEN
200ea6c: f0 1e 20 10 ldd [ %i0 + 0x10 ], %i0
iop->offset = the_jnode->info.linearfile.size;
200ea70: c2 26 20 10 st %g1, [ %i0 + 0x10 ] <== NOT EXECUTED
200ea74: 10 80 00 11 b 200eab8 <memfile_lseek+0x94> <== NOT EXECUTED
200ea78: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
200ea7c: 90 10 00 1d mov %i5, %o0
200ea80: 92 10 00 02 mov %g2, %o1
200ea84: 7f ff fe d9 call 200e5e8 <IMFS_memfile_extend>
200ea88: 94 10 00 03 mov %g3, %o2
200ea8c: 80 a2 20 00 cmp %o0, 0
200ea90: 22 80 00 09 be,a 200eab4 <memfile_lseek+0x90>
200ea94: c4 1f 60 50 ldd [ %i5 + 0x50 ], %g2
rtems_set_errno_and_return_minus_one( ENOSPC );
200ea98: 40 00 03 77 call 200f874 <__errno>
200ea9c: 31 3f ff ff sethi %hi(0xfffffc00), %i0
200eaa0: 82 10 20 1c mov 0x1c, %g1
200eaa4: c2 22 00 00 st %g1, [ %o0 ]
200eaa8: b0 16 23 ff or %i0, 0x3ff, %i0
200eaac: 81 c7 e0 08 ret
200eab0: 93 e8 00 18 restore %g0, %i0, %o1
iop->size = the_jnode->info.file.size;
200eab4: c4 3e 20 08 std %g2, [ %i0 + 8 ]
}
return iop->offset;
200eab8: f0 1e 20 10 ldd [ %i0 + 0x10 ], %i0
}
200eabc: 81 c7 e0 08 ret
200eac0: 81 e8 00 00 restore
0200e910 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
200e910: 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 | LIBIO_FLAGS_APPEND))
200e914: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
200e918: b8 10 00 18 mov %i0, %i4
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
200e91c: 80 88 62 04 btst 0x204, %g1
200e920: 02 80 00 1b be 200e98c <memfile_open+0x7c>
200e924: fa 06 20 24 ld [ %i0 + 0x24 ], %i5
200e928: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
200e92c: c2 00 40 00 ld [ %g1 ], %g1
200e930: 80 a0 60 05 cmp %g1, 5
200e934: 32 80 00 17 bne,a 200e990 <memfile_open+0x80> <== ALWAYS TAKEN
200e938: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
uint32_t count = the_jnode->info.linearfile.size;
200e93c: d8 07 60 54 ld [ %i5 + 0x54 ], %o4 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
200e940: d6 07 60 58 ld [ %i5 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
200e944: 03 00 80 6f sethi %hi(0x201bc00), %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
200e948: c0 27 60 50 clr [ %i5 + 0x50 ] <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (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;
200e94c: 82 10 60 3c or %g1, 0x3c, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
200e950: c0 27 60 54 clr [ %i5 + 0x54 ] <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (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;
200e954: c2 27 60 4c st %g1, [ %i5 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
200e958: c0 27 60 58 clr [ %i5 + 0x58 ] <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
200e95c: c0 27 60 5c clr [ %i5 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
200e960: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
200e964: 02 80 00 0a be 200e98c <memfile_open+0x7c> <== NOT EXECUTED
200e968: c0 27 60 60 clr [ %i5 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
200e96c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200e970: 92 10 20 00 clr %o1 <== NOT EXECUTED
200e974: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e978: 7f ff ff 73 call 200e744 <IMFS_memfile_write> <== NOT EXECUTED
200e97c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200e980: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
200e984: 02 80 00 0a be 200e9ac <memfile_open+0x9c> <== NOT EXECUTED
200e988: 01 00 00 00 nop <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
200e98c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
200e990: 80 88 62 00 btst 0x200, %g1
200e994: 02 80 00 04 be 200e9a4 <memfile_open+0x94>
200e998: c4 1f 60 50 ldd [ %i5 + 0x50 ], %g2
iop->offset = the_jnode->info.file.size;
200e99c: c4 3f 20 10 std %g2, [ %i4 + 0x10 ]
iop->size = the_jnode->info.file.size;
200e9a0: c4 1f 60 50 ldd [ %i5 + 0x50 ], %g2
return 0;
200e9a4: b0 10 20 00 clr %i0
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
200e9a8: c4 3f 20 08 std %g2, [ %i4 + 8 ]
return 0;
}
200e9ac: 81 c7 e0 08 ret
200e9b0: 81 e8 00 00 restore
02003ce4 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2003ce4: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
if (
2003ce8: 80 a6 e0 01 cmp %i3, 1
2003cec: 18 80 00 b5 bgu 2003fc0 <mount+0x2dc>
2003cf0: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
2003cf4: 40 00 21 81 call 200c2f8 <rtems_filesystem_get_mount_handler>
2003cf8: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
2003cfc: a0 92 20 00 orcc %o0, 0, %l0
2003d00: 02 80 00 ac be 2003fb0 <mount+0x2cc>
2003d04: a4 96 60 00 orcc %i1, 0, %l2
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2003d08: 12 80 00 04 bne 2003d18 <mount+0x34>
2003d0c: 01 00 00 00 nop
2003d10: 25 00 80 6e sethi %hi(0x201b800), %l2
2003d14: a4 14 a0 48 or %l2, 0x48, %l2 ! 201b848 <rtems_status_assoc+0x1a0>
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2003d18: 40 00 34 6f call 2010ed4 <strlen>
2003d1c: 90 10 00 1a mov %i2, %o0
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003d20: a2 10 20 00 clr %l1
2003d24: 80 a6 20 00 cmp %i0, 0
2003d28: 02 80 00 05 be 2003d3c <mount+0x58>
2003d2c: ac 10 00 08 mov %o0, %l6
2003d30: 40 00 34 69 call 2010ed4 <strlen>
2003d34: 90 10 00 18 mov %i0, %o0
2003d38: a2 02 20 01 add %o0, 1, %l1
size_t target_size = strlen( target ) + 1;
2003d3c: 40 00 34 66 call 2010ed4 <strlen>
2003d40: 90 10 00 12 mov %l2, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003d44: 92 05 a0 8d add %l6, 0x8d, %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;
2003d48: aa 02 20 01 add %o0, 1, %l5
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003d4c: 92 02 40 11 add %o1, %l1, %o1
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2003d50: 90 10 20 01 mov 1, %o0
2003d54: 7f ff fd c1 call 2003458 <calloc>
2003d58: 92 02 40 15 add %o1, %l5, %o1
if ( mt_entry != NULL ) {
2003d5c: ba 92 20 00 orcc %o0, 0, %i5
2003d60: 02 80 00 9e be 2003fd8 <mount+0x2f4> <== NEVER TAKEN
2003d64: a6 07 60 8c add %i5, 0x8c, %l3
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 );
2003d68: 92 10 00 1a mov %i2, %o1
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;
2003d6c: ac 05 a0 01 inc %l6
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 );
2003d70: 90 10 00 13 mov %l3, %o0
2003d74: 40 00 31 1c call 20101e4 <memcpy>
2003d78: 94 10 00 16 mov %l6, %o2
mt_entry->type = str;
str += filesystemtype_size;
2003d7c: b4 04 c0 16 add %l3, %l6, %i2
memcpy( str, source_or_null, source_size );
2003d80: 92 10 00 18 mov %i0, %o1
2003d84: 94 10 00 11 mov %l1, %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;
2003d88: e6 27 60 5c st %l3, [ %i5 + 0x5c ]
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
2003d8c: 40 00 31 16 call 20101e4 <memcpy>
2003d90: 90 10 00 1a mov %i2, %o0
mt_entry->dev = str;
str += source_size;
2003d94: a2 06 80 11 add %i2, %l1, %l1
memcpy( str, target, target_size );
2003d98: 92 10 00 12 mov %l2, %o1
2003d9c: 94 10 00 15 mov %l5, %o2
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
2003da0: f4 27 60 60 st %i2, [ %i5 + 0x60 ]
str += source_size;
memcpy( str, target, target_size );
2003da4: 40 00 31 10 call 20101e4 <memcpy>
2003da8: 90 10 00 11 mov %l1, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
2003dac: 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 =
2003db0: a8 07 60 64 add %i5, 0x64, %l4
memcpy( str, target, target_size );
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
2003db4: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
2003db8: 94 10 20 30 mov 0x30, %o2
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
2003dbc: e2 27 60 58 st %l1, [ %i5 + 0x58 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
2003dc0: e8 27 60 18 st %l4, [ %i5 + 0x18 ]
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
2003dc4: 90 07 60 28 add %i5, 0x28, %o0
2003dc8: 13 00 80 6e sethi %hi(0x201b800), %o1
2003dcc: 40 00 31 06 call 20101e4 <memcpy>
2003dd0: 92 12 60 4c or %o1, 0x4c, %o1 ! 201b84c <rtems_filesystem_default_pathconf>
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
2003dd4: 82 10 20 01 mov 1, %g1
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize( the_chain, starting_address, number_nodes, node_size );
2003dd8: 90 07 60 08 add %i5, 8, %o0
2003ddc: c2 27 60 80 st %g1, [ %i5 + 0x80 ]
2003de0: 92 10 00 14 mov %l4, %o1
2003de4: 94 10 20 01 mov 1, %o2
2003de8: 96 10 20 28 mov 0x28, %o3
2003dec: 40 00 11 58 call 200834c <_Chain_Initialize>
2003df0: fa 27 60 7c st %i5, [ %i5 + 0x7c ]
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
rv = (*fsmount_me_h)( mt_entry, data );
2003df4: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2003df8: f6 2f 60 1d stb %i3, [ %i5 + 0x1d ]
rv = (*fsmount_me_h)( mt_entry, data );
2003dfc: 9f c4 00 00 call %l0
2003e00: 92 10 00 1c mov %i4, %o1
if ( rv == 0 ) {
2003e04: b0 92 20 00 orcc %o0, 0, %i0
2003e08: 12 80 00 66 bne 2003fa0 <mount+0x2bc>
2003e0c: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
2003e10: 02 80 00 36 be 2003ee8 <mount+0x204>
2003e14: 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 =
2003e18: 94 10 20 1f mov 0x1f, %o2
2003e1c: 40 00 03 40 call 2004b1c <rtems_filesystem_eval_path_start>
2003e20: 90 07 bf a8 add %fp, -88, %o0
static inline bool rtems_filesystem_location_is_root(
const rtems_filesystem_location_info_t *loc
)
{
return (*loc->ops->are_nodes_equal_h)(
2003e24: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
loc,
&loc->mt_entry->mt_fs_root->location
2003e28: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
static inline bool rtems_filesystem_location_is_root(
const rtems_filesystem_location_info_t *loc
)
{
return (*loc->ops->are_nodes_equal_h)(
2003e2c: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
2003e30: 9f c0 40 00 call %g1
2003e34: d2 00 a0 18 ld [ %g2 + 0x18 ], %o1
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_root( currentloc ) ) {
2003e38: 80 8a 20 ff btst 0xff, %o0
2003e3c: 12 80 00 20 bne 2003ebc <mount+0x1d8>
2003e40: 92 07 bf c0 add %fp, -64, %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(
2003e44: 40 00 03 f0 call 2004e04 <rtems_filesystem_location_copy_and_detach>
2003e48: 90 07 bf e4 add %fp, -28, %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 );
2003e4c: 40 00 04 66 call 2004fe4 <rtems_filesystem_location_transform_to_global>
2003e50: 90 07 bf e4 add %fp, -28, %o0
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.ops->mount_h)( mt_entry );
2003e54: 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;
2003e58: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
rv = (*mt_point_node->location.ops->mount_h)( mt_entry );
2003e5c: c2 00 60 30 ld [ %g1 + 0x30 ], %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 );
2003e60: b8 10 00 08 mov %o0, %i4
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.ops->mount_h)( mt_entry );
2003e64: 9f c0 40 00 call %g1
2003e68: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
2003e6c: b0 92 20 00 orcc %o0, 0, %i0
2003e70: 12 80 00 10 bne 2003eb0 <mount+0x1cc>
2003e74: 01 00 00 00 nop
rtems_filesystem_mt_lock();
2003e78: 7f ff ff 94 call 2003cc8 <rtems_filesystem_mt_lock>
2003e7c: 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;
2003e80: 03 00 80 74 sethi %hi(0x201d000), %g1
2003e84: 82 10 60 24 or %g1, 0x24, %g1 ! 201d024 <rtems_filesystem_mount_table>
2003e88: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2003e8c: 86 00 60 04 add %g1, 4, %g3
tail->previous = the_node;
2003e90: fa 20 60 08 st %i5, [ %g1 + 8 ]
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2003e94: 03 00 80 76 sethi %hi(0x201d800), %g1
2003e98: d0 00 62 a0 ld [ %g1 + 0x2a0 ], %o0 ! 201daa0 <rtems_libio_semaphore>
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
2003e9c: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
old_last->next = the_node;
2003ea0: fa 20 80 00 st %i5, [ %g2 ]
2003ea4: 40 00 0e bf call 20079a0 <rtems_semaphore_release>
2003ea8: c4 27 60 04 st %g2, [ %i5 + 4 ]
2003eac: 30 80 00 08 b,a 2003ecc <mount+0x1e8>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
2003eb0: 40 00 03 fa call 2004e98 <rtems_filesystem_global_location_release>
2003eb4: 90 10 00 1c mov %i4, %o0
2003eb8: 30 80 00 05 b,a 2003ecc <mount+0x1e8>
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
2003ebc: 90 07 bf a8 add %fp, -88, %o0
2003ec0: 92 10 20 10 mov 0x10, %o1
2003ec4: 40 00 02 63 call 2004850 <rtems_filesystem_eval_path_error>
2003ec8: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003ecc: 40 00 03 1a call 2004b34 <rtems_filesystem_eval_path_cleanup>
2003ed0: 90 07 bf a8 add %fp, -88, %o0
rv = register_subordinate_file_system( mt_entry, target );
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
2003ed4: 80 a6 20 00 cmp %i0, 0
2003ed8: 02 80 00 3e be 2003fd0 <mount+0x2ec>
2003edc: 01 00 00 00 nop
(*mt_entry->mt_fs_root->location.ops->fsunmount_me_h)( mt_entry );
2003ee0: 10 80 00 2c b 2003f90 <mount+0x2ac>
2003ee4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
int rv = 0;
rtems_filesystem_mt_lock();
2003ee8: 7f ff ff 78 call 2003cc8 <rtems_filesystem_mt_lock>
2003eec: 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;
2003ef0: 05 00 80 74 sethi %hi(0x201d000), %g2
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
2003ef4: c6 00 a0 24 ld [ %g2 + 0x24 ], %g3 ! 201d024 <rtems_filesystem_mount_table>
2003ef8: 82 10 a0 24 or %g2, 0x24, %g1
2003efc: 84 00 60 04 add %g1, 4, %g2
2003f00: 80 a0 c0 02 cmp %g3, %g2
2003f04: 12 80 00 08 bne 2003f24 <mount+0x240> <== NEVER TAKEN
2003f08: 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;
2003f0c: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2003f10: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
2003f14: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
2003f18: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
2003f1c: 10 80 00 06 b 2003f34 <mount+0x250>
2003f20: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
2003f24: 40 00 2e 54 call 200f874 <__errno> <== NOT EXECUTED
2003f28: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003f2c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003f30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2003f34: 03 00 80 76 sethi %hi(0x201d800), %g1
2003f38: 40 00 0e 9a call 20079a0 <rtems_semaphore_release>
2003f3c: d0 00 62 a0 ld [ %g1 + 0x2a0 ], %o0 ! 201daa0 <rtems_libio_semaphore>
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
2003f40: 80 a6 20 00 cmp %i0, 0
2003f44: 32 80 00 13 bne,a 2003f90 <mount+0x2ac> <== NEVER TAKEN
2003f48: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
2003f4c: ba 07 60 18 add %i5, 0x18, %i5
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
2003f50: 40 00 03 f2 call 2004f18 <rtems_filesystem_global_location_obtain>
2003f54: 90 10 00 1d mov %i5, %o0
2003f58: 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 =
2003f5c: 40 00 03 ef call 2004f18 <rtems_filesystem_global_location_obtain>
2003f60: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2003f64: 3b 00 80 74 sethi %hi(0x201d000), %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 =
2003f68: b8 10 00 08 mov %o0, %i4
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2003f6c: d0 07 60 44 ld [ %i5 + 0x44 ], %o0
2003f70: 92 10 00 1b mov %i3, %o1
2003f74: 40 00 03 e0 call 2004ef4 <rtems_filesystem_global_location_assign>
2003f78: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
2003f7c: d0 07 60 44 ld [ %i5 + 0x44 ], %o0
2003f80: 40 00 03 dd call 2004ef4 <rtems_filesystem_global_location_assign>
2003f84: 92 10 00 1c mov %i4, %o1
2003f88: 81 c7 e0 08 ret
2003f8c: 81 e8 00 00 restore
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->mt_fs_root->location.ops->fsunmount_me_h)( mt_entry );
2003f90: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2003f94: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
2003f98: 9f c0 40 00 call %g1
2003f9c: 90 10 00 1d mov %i5, %o0
}
}
if ( rv != 0 ) {
free( mt_entry );
2003fa0: 7f ff fd dc call 2003710 <free>
2003fa4: 90 10 00 1d mov %i5, %o0
2003fa8: 81 c7 e0 08 ret
2003fac: 81 e8 00 00 restore
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = EINVAL;
2003fb0: 40 00 2e 31 call 200f874 <__errno>
2003fb4: 01 00 00 00 nop
2003fb8: 10 80 00 0b b 2003fe4 <mount+0x300>
2003fbc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
rv = -1;
}
} else {
errno = EINVAL;
2003fc0: 40 00 2e 2d call 200f874 <__errno>
2003fc4: b0 10 3f ff mov -1, %i0
2003fc8: 82 10 20 16 mov 0x16, %g1
2003fcc: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2003fd0: 81 c7 e0 08 ret
2003fd4: 81 e8 00 00 restore
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
2003fd8: 40 00 2e 27 call 200f874 <__errno> <== NOT EXECUTED
2003fdc: 01 00 00 00 nop <== NOT EXECUTED
2003fe0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2003fe4: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
2003fe8: 81 c7 e0 08 ret
2003fec: 91 e8 3f ff restore %g0, -1, %o0
02008bbc <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2008bbc: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
2008bc0: 90 96 60 00 orcc %i1, 0, %o0
2008bc4: 02 80 00 09 be 2008be8 <mount_and_make_target_path+0x2c>
2008bc8: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
2008bcc: 40 00 02 ef call 2009788 <rtems_mkdir>
2008bd0: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
2008bd4: 80 a2 20 00 cmp %o0, 0
2008bd8: 12 80 00 09 bne 2008bfc <mount_and_make_target_path+0x40> <== NEVER TAKEN
2008bdc: 01 00 00 00 nop
rv = mount(
2008be0: 40 00 00 10 call 2008c20 <mount>
2008be4: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
2008be8: 40 00 5e 60 call 2020568 <__errno>
2008bec: 01 00 00 00 nop
2008bf0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2008bf4: c2 22 00 00 st %g1, [ %o0 ]
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
2008bf8: 90 10 3f ff mov -1, %o0
} else {
errno = EINVAL;
}
return rv;
}
2008bfc: 81 c7 e0 08 ret
2008c00: 91 e8 00 08 restore %g0, %o0, %o0
02033e30 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
2033e30: 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;
2033e34: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2033e38: 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;
2033e3c: e0 00 60 20 ld [ %g1 + 0x20 ], %l0
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2033e40: 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);
2033e44: 94 10 20 20 mov 0x20, %o2
2033e48: c2 27 bf f0 st %g1, [ %fp + -16 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2033e4c: c2 27 bf f4 st %g1, [ %fp + -12 ]
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;
2033e50: e2 06 20 08 ld [ %i0 + 8 ], %l1
fat_file_fd_t *fat_fd = NULL;
2033e54: c0 27 bf f8 clr [ %fp + -8 ]
time_t time_ret = 0;
uint16_t time_val = 0;
2033e58: c0 37 bf fc clrh [ %fp + -4 ]
uint16_t date = 0;
2033e5c: c0 37 bf fe clrh [ %fp + -2 ]
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
2033e60: c0 27 bf e8 clr [ %fp + -24 ]
dir_pos->sname.ofs = 0;
2033e64: c0 27 bf ec clr [ %fp + -20 ]
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2033e68: 40 00 45 5b call 20453d4 <memset>
2033e6c: 90 07 bf a8 add %fp, -88, %o0
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
2033e70: 90 07 bf 68 add %fp, -152, %o0
2033e74: 92 10 20 00 clr %o1
2033e78: 40 00 45 57 call 20453d4 <memset>
2033e7c: 94 10 20 40 mov 0x40, %o2
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
2033e80: 80 a6 e1 04 cmp %i3, 0x104
2033e84: 04 80 00 06 ble 2033e9c <msdos_creat_node+0x6c> <== ALWAYS TAKEN
2033e88: b8 10 00 18 mov %i0, %i4
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
2033e8c: 40 00 37 85 call 2041ca0 <__errno> <== NOT EXECUTED
2033e90: 01 00 00 00 nop <== NOT EXECUTED
2033e94: 10 80 00 0d b 2033ec8 <msdos_creat_node+0x98> <== NOT EXECUTED
2033e98: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
}
name_type = msdos_long_to_short (name, name_len,
2033e9c: 90 10 00 1a mov %i2, %o0
2033ea0: 92 10 00 1b mov %i3, %o1
2033ea4: 94 07 bf a8 add %fp, -88, %o2
2033ea8: 40 00 01 39 call 203438c <msdos_long_to_short>
2033eac: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
2033eb0: a4 92 20 00 orcc %o0, 0, %l2
2033eb4: 32 80 00 08 bne,a 2033ed4 <msdos_creat_node+0xa4> <== ALWAYS TAKEN
2033eb8: c0 2f bf b4 clrb [ %fp + -76 ]
rtems_set_errno_and_return_minus_one(EINVAL);
2033ebc: 40 00 37 79 call 2041ca0 <__errno> <== NOT EXECUTED
2033ec0: 01 00 00 00 nop <== NOT EXECUTED
2033ec4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2033ec8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2033ecc: 81 c7 e0 08 ret <== NOT EXECUTED
2033ed0: 91 e8 3f ff restore %g0, -1, %o0 <== 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);
2033ed4: 90 10 20 00 clr %o0
2033ed8: 40 00 6a 84 call 204e8e8 <time>
2033edc: b0 10 3f ff mov -1, %i0
if ( time_ret == -1 )
2033ee0: 80 a2 3f ff cmp %o0, -1
2033ee4: 02 80 00 b6 be 20341bc <msdos_creat_node+0x38c> <== NEVER TAKEN
2033ee8: 92 07 bf fe add %fp, -2, %o1
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
2033eec: 40 00 2f 49 call 203fc10 <msdos_date_unix2dos>
2033ef0: 94 07 bf fc add %fp, -4, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
2033ef4: c2 17 bf fc lduh [ %fp + -4 ], %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2033ef8: c6 17 bf fe lduh [ %fp + -2 ], %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);
2033efc: 83 28 60 10 sll %g1, 0x10, %g1
2033f00: 85 30 60 08 srl %g1, 8, %g2
2033f04: 83 30 60 18 srl %g1, 0x18, %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2033f08: 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);
2033f0c: 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;
2033f10: c0 27 bf c4 clr [ %fp + -60 ]
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);
2033f14: 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);
2033f18: c4 37 bf b6 sth %g2, [ %fp + -74 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2033f1c: 87 30 e0 18 srl %g3, 0x18, %g3
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
2033f20: c4 37 bf be sth %g2, [ %fp + -66 ]
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);
2033f24: 82 10 40 03 or %g1, %g3, %g1
2033f28: c2 37 bf b8 sth %g1, [ %fp + -72 ]
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
2033f2c: c2 37 bf c0 sth %g1, [ %fp + -64 ]
*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) {
2033f30: 80 a6 60 00 cmp %i1, 0
2033f34: 12 80 00 05 bne 2033f48 <msdos_creat_node+0x118>
2033f38: c2 37 bf ba sth %g1, [ %fp + -70 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
2033f3c: c2 0f bf b3 ldub [ %fp + -77 ], %g1
2033f40: 10 80 00 30 b 2034000 <msdos_creat_node+0x1d0>
2033f44: 82 10 60 10 or %g1, 0x10, %g1
}
else if (type == MSDOS_HARD_LINK) {
2033f48: 80 a6 60 02 cmp %i1, 2
2033f4c: 12 80 00 2c bne 2033ffc <msdos_creat_node+0x1cc> <== ALWAYS TAKEN
2033f50: c2 0f bf b3 ldub [ %fp + -77 ], %g1
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
2033f54: d0 07 20 18 ld [ %i4 + 0x18 ], %o0 <== NOT EXECUTED
2033f58: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2033f5c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2033f60: 12 80 00 08 bne 2033f80 <msdos_creat_node+0x150> <== NOT EXECUTED
2033f64: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
2033f68: c6 08 60 0a ldub [ %g1 + 0xa ], %g3 <== NOT EXECUTED
2033f6c: 80 88 e0 03 btst 3, %g3 <== NOT EXECUTED
2033f70: 22 80 00 05 be,a 2033f84 <msdos_creat_node+0x154> <== NOT EXECUTED
2033f74: c6 08 60 05 ldub [ %g1 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2033f78: 10 80 00 07 b 2033f94 <msdos_creat_node+0x164> <== NOT EXECUTED
2033f7c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2033f80: c6 08 60 05 ldub [ %g1 + 5 ], %g3 <== NOT EXECUTED
2033f84: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 <== NOT EXECUTED
2033f88: 84 00 bf fe add %g2, -2, %g2 <== NOT EXECUTED
2033f8c: 85 28 80 03 sll %g2, %g3, %g2 <== NOT EXECUTED
2033f90: 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);
2033f94: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
2033f98: d2 0c 20 02 ldub [ %l0 + 2 ], %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2033f9c: d4 14 00 00 lduh [ %l0 ], %o2 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2033fa0: 93 30 40 09 srl %g1, %o1, %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2033fa4: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
2033fa8: 92 00 80 09 add %g2, %o1, %o1 <== NOT EXECUTED
2033fac: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
2033fb0: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
2033fb4: 98 07 bf c8 add %fp, -56, %o4 <== NOT EXECUTED
2033fb8: 7f ff c7 9c call 2025e28 <_fat_block_read> <== NOT EXECUTED
2033fbc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
2033fc0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2033fc4: 06 80 00 7e bl 20341bc <msdos_creat_node+0x38c> <== NOT EXECUTED
2033fc8: c4 0f bf d5 ldub [ %fp + -43 ], %g2 <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
2033fcc: c2 0f bf d3 ldub [ %fp + -45 ], %g1 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
2033fd0: c4 2f bf b5 stb %g2, [ %fp + -75 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
2033fd4: c4 17 bf d6 lduh [ %fp + -42 ], %g2 <== NOT EXECUTED
2033fd8: c4 37 bf b6 sth %g2, [ %fp + -74 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
2033fdc: c4 17 bf d8 lduh [ %fp + -40 ], %g2 <== NOT EXECUTED
2033fe0: c4 37 bf b8 sth %g2, [ %fp + -72 ] <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
2033fe4: c4 07 bf e4 ld [ %fp + -28 ], %g2 <== NOT EXECUTED
2033fe8: c4 27 bf c4 st %g2, [ %fp + -60 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
2033fec: c4 17 bf e2 lduh [ %fp + -30 ], %g2 <== NOT EXECUTED
2033ff0: c4 37 bf c2 sth %g2, [ %fp + -62 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
2033ff4: c4 17 bf dc lduh [ %fp + -36 ], %g2 <== NOT EXECUTED
2033ff8: c4 37 bf bc sth %g2, [ %fp + -68 ] <== NOT EXECUTED
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
2033ffc: 82 10 60 20 or %g1, 0x20, %g1
2034000: c2 2f bf b3 stb %g1, [ %fp + -77 ]
/*
* 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);
2034004: ba 07 bf a8 add %fp, -88, %i5
/*
* 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,
2034008: 90 10 00 1c mov %i4, %o0
203400c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
2034010: 92 10 20 01 mov 1, %o1
2034014: 94 10 00 1a mov %i2, %o2
2034018: 96 10 00 1b mov %i3, %o3
203401c: 98 10 00 12 mov %l2, %o4
2034020: 40 00 05 f8 call 2035800 <msdos_get_name_node>
2034024: 9a 07 bf e8 add %fp, -24, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
2034028: b0 92 20 00 orcc %o0, 0, %i0
203402c: 12 80 00 64 bne 20341bc <msdos_creat_node+0x38c> <== NEVER TAKEN
2034030: 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)
2034034: 12 80 00 62 bne 20341bc <msdos_creat_node+0x38c>
2034038: 92 07 bf e8 add %fp, -24, %o1
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
203403c: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
2034040: 7f ff c3 af call 2024efc <fat_file_open>
2034044: 94 07 bf f8 add %fp, -8, %o2
if (rc != RC_OK)
2034048: b0 92 20 00 orcc %o0, 0, %i0
203404c: 32 80 00 63 bne,a 20341d8 <msdos_creat_node+0x3a8> <== NEVER TAKEN
2034050: d0 07 20 18 ld [ %i4 + 0x18 ], %o0 <== NOT EXECUTED
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
2034054: f6 07 bf f8 ld [ %fp + -8 ], %i3
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2034058: 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,
203405c: 92 10 00 1d mov %i5, %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;
2034060: c2 26 e0 14 st %g1, [ %i3 + 0x14 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2034064: 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;
2034068: c0 26 e0 18 clr [ %i3 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
203406c: c0 26 e0 10 clr [ %i3 + 0x10 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2034070: 40 00 44 4d call 20451a4 <memcpy>
2034074: 90 07 bf 68 add %fp, -152, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
2034078: 92 10 00 1d mov %i5, %o1
203407c: 94 10 20 20 mov 0x20, %o2
2034080: 40 00 44 49 call 20451a4 <memcpy>
2034084: 90 07 bf 88 add %fp, -120, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
2034088: 03 00 81 9b sethi %hi(0x2066c00), %g1
203408c: d2 00 60 4c ld [ %g1 + 0x4c ], %o1 ! 2066c4c <MSDOS_DOT_NAME>
2034090: 94 10 20 0b mov 0xb, %o2
2034094: 40 00 44 44 call 20451a4 <memcpy>
2034098: 90 07 bf 68 add %fp, -152, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
203409c: 03 00 81 9b sethi %hi(0x2066c00), %g1
20340a0: d2 00 60 48 ld [ %g1 + 0x48 ], %o1 ! 2066c48 <MSDOS_DOTDOT_NAME>
20340a4: 90 07 bf 88 add %fp, -120, %o0
20340a8: 40 00 44 3f call 20451a4 <memcpy>
20340ac: 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)) &&
20340b0: c2 04 60 20 ld [ %l1 + 0x20 ], %g1
20340b4: 80 a0 60 01 cmp %g1, 1
20340b8: 32 80 00 0d bne,a 20340ec <msdos_creat_node+0x2bc>
20340bc: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
20340c0: c2 04 60 24 ld [ %l1 + 0x24 ], %g1
20340c4: 80 a0 60 00 cmp %g1, 0
20340c8: 32 80 00 09 bne,a 20340ec <msdos_creat_node+0x2bc> <== NEVER TAKEN
20340cc: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
20340d0: c2 0c 20 0a ldub [ %l0 + 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)) &&
20340d4: 80 88 60 04 btst 4, %g1
20340d8: 22 80 00 05 be,a 20340ec <msdos_creat_node+0x2bc> <== ALWAYS TAKEN
20340dc: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
20340e0: c0 37 bf a2 clrh [ %fp + -94 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
20340e4: 10 80 00 0d b 2034118 <msdos_creat_node+0x2e8> <== NOT EXECUTED
20340e8: c0 37 bf 9c clrh [ %fp + -100 ] <== NOT EXECUTED
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
20340ec: 85 28 60 10 sll %g1, 0x10, %g2
20340f0: 87 30 a0 08 srl %g2, 8, %g3
*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)) =
20340f4: 85 30 a0 18 srl %g2, 0x18, %g2
20340f8: 84 10 c0 02 or %g3, %g2, %g2
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));
20340fc: 83 30 60 10 srl %g1, 0x10, %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)) =
2034100: c4 37 bf a2 sth %g2, [ %fp + -94 ]
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));
2034104: 83 28 60 10 sll %g1, 0x10, %g1
2034108: 85 30 60 08 srl %g1, 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)) =
203410c: 83 30 60 18 srl %g1, 0x18, %g1
2034110: 82 10 80 01 or %g2, %g1, %g1
2034114: c2 37 bf 9c sth %g1, [ %fp + -100 ]
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
2034118: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
203411c: 92 10 00 1b mov %i3, %o1
2034120: 94 10 20 00 clr %o2
2034124: 96 10 20 40 mov 0x40, %o3
2034128: 7f ff c5 5f call 20256a4 <fat_file_write>
203412c: 98 07 bf 68 add %fp, -152, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
2034130: 80 a2 20 00 cmp %o0, 0
2034134: 06 80 00 24 bl 20341c4 <msdos_creat_node+0x394> <== NEVER TAKEN
2034138: d2 07 bf f8 ld [ %fp + -8 ], %o1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
203413c: c2 14 20 06 lduh [ %l0 + 6 ], %g1
2034140: 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(parent_loc->mt_entry, fat_fd, 0,
2034144: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
2034148: 82 00 80 01 add %g2, %g1, %g1
203414c: 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));
2034150: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
2034154: 94 10 20 00 clr %o2
/* 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));
2034158: 85 28 60 10 sll %g1, 0x10, %g2
203415c: 87 30 a0 08 srl %g2, 8, %g3
/* 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)) =
2034160: 85 30 a0 18 srl %g2, 0x18, %g2
2034164: 84 10 c0 02 or %g3, %g2, %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));
2034168: 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)) =
203416c: c4 37 bf 82 sth %g2, [ %fp + -126 ]
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));
2034170: 83 28 60 10 sll %g1, 0x10, %g1
2034174: 85 30 60 08 srl %g1, 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)) =
2034178: 83 30 60 18 srl %g1, 0x18, %g1
203417c: 82 10 80 01 or %g2, %g1, %g1
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
2034180: 96 10 20 20 mov 0x20, %o3
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)) =
2034184: c2 37 bf 7c sth %g1, [ %fp + -132 ]
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
2034188: 7f ff c5 47 call 20256a4 <fat_file_write>
203418c: 98 07 bf 68 add %fp, -152, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
2034190: 80 a2 20 00 cmp %o0, 0
2034194: 06 80 00 0d bl 20341c8 <msdos_creat_node+0x398> <== NEVER TAKEN
2034198: b0 10 3f ff mov -1, %i0
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);
203419c: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
20341a0: 40 00 01 4d call 20346d4 <msdos_set_first_cluster_num>
20341a4: d2 07 bf f8 ld [ %fp + -8 ], %o1
if (rc != RC_OK)
20341a8: b0 92 20 00 orcc %o0, 0, %i0
20341ac: 12 80 00 08 bne 20341cc <msdos_creat_node+0x39c> <== NEVER TAKEN
20341b0: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
20341b4: 7f ff c4 5d call 2025328 <fat_file_close>
20341b8: d2 07 bf f8 ld [ %fp + -8 ], %o1
20341bc: 81 c7 e0 08 ret
20341c0: 81 e8 00 00 restore
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
{
rc = -1;
20341c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
}
return RC_OK;
error:
fat_file_close(parent_loc->mt_entry, fat_fd);
20341c8: d0 07 20 18 ld [ %i4 + 0x18 ], %o0 <== NOT EXECUTED
20341cc: 7f ff c4 57 call 2025328 <fat_file_close> <== NOT EXECUTED
20341d0: d2 07 bf f8 ld [ %fp + -8 ], %o1 <== 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);
20341d4: d0 07 20 18 ld [ %i4 + 0x18 ], %o0 <== NOT EXECUTED
20341d8: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
20341dc: 40 00 01 86 call 20347f4 <msdos_set_first_char4file_name> <== NOT EXECUTED
20341e0: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
return rc;
}
20341e4: 81 c7 e0 08 ret <== NOT EXECUTED
20341e8: 81 e8 00 00 restore <== NOT EXECUTED
0203fd58 <msdos_date_dos2unix>:
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
{
203fd58: 9d e3 bf a0 save %sp, -96, %sp
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;
203fd5c: 85 36 60 0b srl %i1, 0xb, %g2
203fd60: 84 08 a0 1f and %g2, 0x1f, %g2
203fd64: 87 28 a0 03 sll %g2, 3, %g3
203fd68: 83 28 a0 07 sll %g2, 7, %g1
203fd6c: 82 20 40 03 sub %g1, %g3, %g1
203fd70: 85 28 60 04 sll %g1, 4, %g2
203fd74: 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
203fd78: 82 0e 67 e0 and %i1, 0x7e0, %g1
203fd7c: 87 30 60 04 srl %g1, 4, %g3
203fd80: 82 20 40 03 sub %g1, %g3, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
203fd84: 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)
203fd88: b2 0e 60 1f and %i1, 0x1f, %i1
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
203fd8c: b2 00 40 19 add %g1, %i1, %i1
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
203fd90: 03 00 81 bb sethi %hi(0x206ec00), %g1
203fd94: c4 10 61 5a lduh [ %g1 + 0x15a ], %g2 ! 206ed5a <lastdosdate>
203fd98: 80 a0 80 18 cmp %g2, %i0
203fd9c: 02 80 00 33 be 203fe68 <msdos_date_dos2unix+0x110>
203fda0: b3 2e 60 01 sll %i1, 1, %i1
lastdosdate = dd;
203fda4: f0 30 61 5a sth %i0, [ %g1 + 0x15a ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
203fda8: 89 36 20 09 srl %i0, 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;
203fdac: 82 10 20 00 clr %g1
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
203fdb0: 88 09 20 7f and %g4, 0x7f, %g4
for (y = 0; y < year; y++)
203fdb4: 10 80 00 07 b 203fdd0 <msdos_date_dos2unix+0x78>
203fdb8: 84 10 20 00 clr %g2
days += y & 0x03 ? 365 : 366;
203fdbc: 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++)
203fdc0: 84 00 a0 01 inc %g2
days += y & 0x03 ? 365 : 366;
203fdc4: 86 60 3f ff subx %g0, -1, %g3
203fdc8: 86 00 e1 6d add %g3, 0x16d, %g3
203fdcc: 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++)
203fdd0: 80 a0 80 04 cmp %g2, %g4
203fdd4: 12 bf ff fa bne 203fdbc <msdos_date_dos2unix+0x64>
203fdd8: 86 08 a0 03 and %g2, 3, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
203fddc: 09 00 81 ae sethi %hi(0x206b800), %g4
203fde0: 80 a0 e0 00 cmp %g3, 0
203fde4: 02 80 00 04 be 203fdf4 <msdos_date_dos2unix+0x9c> <== ALWAYS TAKEN
203fde8: 88 11 21 40 or %g4, 0x140, %g4
203fdec: 09 00 81 ae sethi %hi(0x206b800), %g4 <== NOT EXECUTED
203fdf0: 88 11 21 28 or %g4, 0x128, %g4 ! 206b928 <regyear> <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
203fdf4: 86 0e 21 e0 and %i0, 0x1e0, %g3
203fdf8: 87 30 e0 05 srl %g3, 5, %g3
if (month == 0) {
203fdfc: 80 a0 e0 00 cmp %g3, 0
203fe00: 22 80 00 02 be,a 203fe08 <msdos_date_dos2unix+0xb0> <== NEVER TAKEN
203fe04: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
203fe08: 84 10 20 00 clr %g2
203fe0c: 10 80 00 05 b 203fe20 <msdos_date_dos2unix+0xc8>
203fe10: 86 00 ff ff add %g3, -1, %g3
days += months[m];
203fe14: de 11 00 0f lduh [ %g4 + %o7 ], %o7 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
203fe18: 84 00 a0 01 inc %g2 <== NOT EXECUTED
days += months[m];
203fe1c: 82 00 40 0f add %g1, %o7, %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++)
203fe20: 80 a0 80 03 cmp %g2, %g3
203fe24: 0a bf ff fc bcs 203fe14 <msdos_date_dos2unix+0xbc> <== NEVER TAKEN
203fe28: 9f 28 a0 01 sll %g2, 1, %o7
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
203fe2c: b0 0e 20 1f and %i0, 0x1f, %i0
203fe30: b0 06 3f ff add %i0, -1, %i0
203fe34: 82 06 00 01 add %i0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
203fe38: 85 28 60 07 sll %g1, 7, %g2
203fe3c: 83 28 60 09 sll %g1, 9, %g1
203fe40: 82 20 40 02 sub %g1, %g2, %g1
203fe44: 85 28 60 04 sll %g1, 4, %g2
203fe48: 82 20 80 01 sub %g2, %g1, %g1
203fe4c: 85 28 60 04 sll %g1, 4, %g2
203fe50: 82 20 80 01 sub %g2, %g1, %g1
203fe54: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
203fe58: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_END+0x108ea600>
203fe5c: 82 00 40 02 add %g1, %g2, %g1
203fe60: 05 00 81 bb sethi %hi(0x206ec00), %g2
203fe64: c2 20 a1 5c st %g1, [ %g2 + 0x15c ] ! 206ed5c <lastseconds>
}
return seconds + lastseconds;
203fe68: 03 00 81 bb sethi %hi(0x206ec00), %g1
203fe6c: c4 00 61 5c ld [ %g1 + 0x15c ], %g2 ! 206ed5c <lastseconds>
}
203fe70: 81 c7 e0 08 ret
203fe74: 91 ee 40 02 restore %i1, %g2, %o0
0203fc10 <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)
{
203fc10: 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) {
203fc14: 03 00 81 bb sethi %hi(0x206ec00), %g1
203fc18: c4 00 61 4c ld [ %g1 + 0x14c ], %g2 ! 206ed4c <lasttime>
203fc1c: 80 a0 80 18 cmp %g2, %i0
203fc20: 02 80 00 46 be 203fd38 <msdos_date_unix2dos+0x128>
203fc24: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
203fc28: f0 20 61 4c st %i0, [ %g1 + 0x14c ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
203fc2c: 40 00 6e 09 call 205b450 <.udiv>
203fc30: 90 10 00 18 mov %i0, %o0
203fc34: 40 00 6e b3 call 205b700 <.urem>
203fc38: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
203fc3c: 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)
203fc40: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
203fc44: 40 00 6e 03 call 205b450 <.udiv>
203fc48: 90 10 00 18 mov %i0, %o0
203fc4c: 40 00 6e ad call 205b700 <.urem>
203fc50: 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)
203fc54: 91 2a 20 0b sll %o0, 0xb, %o0
203fc58: 92 10 20 3c mov 0x3c, %o1
203fc5c: ba 07 40 08 add %i5, %o0, %i5
203fc60: 40 00 6e a8 call 205b700 <.urem>
203fc64: 90 10 00 18 mov %i0, %o0
203fc68: 03 00 81 bb sethi %hi(0x206ec00), %g1
203fc6c: 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);
203fc70: 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)
203fc74: 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);
203fc78: 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)
203fc7c: fa 30 61 50 sth %i5, [ %g1 + 0x150 ]
/*
* 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);
203fc80: 40 00 6d f4 call 205b450 <.udiv>
203fc84: 90 10 00 18 mov %i0, %o0
if (days != lastday) {
203fc88: 03 00 81 bb sethi %hi(0x206ec00), %g1
203fc8c: c4 00 61 54 ld [ %g1 + 0x154 ], %g2 ! 206ed54 <lastday>
203fc90: 80 a2 00 02 cmp %o0, %g2
203fc94: 22 80 00 2a be,a 203fd3c <msdos_date_unix2dos+0x12c>
203fc98: 03 00 81 bb sethi %hi(0x206ec00), %g1
lastday = days;
203fc9c: d0 20 61 54 st %o0, [ %g1 + 0x154 ] ! 206ed54 <lastday>
for (year = 1970;; year++) {
203fca0: 82 10 27 b2 mov 0x7b2, %g1
inc = year & 0x03 ? 365 : 366;
203fca4: 84 08 60 03 and %g1, 3, %g2
203fca8: 80 a0 00 02 cmp %g0, %g2
203fcac: 86 60 3f ff subx %g0, -1, %g3
203fcb0: 86 00 e1 6d add %g3, 0x16d, %g3
if (days < inc)
203fcb4: 80 a2 00 03 cmp %o0, %g3
203fcb8: 2a 80 00 05 bcs,a 203fccc <msdos_date_unix2dos+0xbc>
203fcbc: 07 00 81 ae sethi %hi(0x206b800), %g3
break;
days -= inc;
203fcc0: 90 22 00 03 sub %o0, %g3, %o0
}
203fcc4: 10 bf ff f8 b 203fca4 <msdos_date_unix2dos+0x94>
203fcc8: 82 00 60 01 inc %g1
months = year & 0x03 ? regyear : leapyear;
203fccc: 80 a0 a0 00 cmp %g2, 0
203fcd0: 02 80 00 04 be 203fce0 <msdos_date_unix2dos+0xd0> <== ALWAYS TAKEN
203fcd4: 86 10 e1 40 or %g3, 0x140, %g3
203fcd8: 07 00 81 ae sethi %hi(0x206b800), %g3 <== NOT EXECUTED
203fcdc: 86 10 e1 28 or %g3, 0x128, %g3 ! 206b928 <regyear> <== NOT EXECUTED
for (month = 0; month < 12; month++) {
203fce0: 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,
203fce4: 89 28 a0 01 sll %g2, 1, %g4
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
if (days < months[month])
203fce8: c8 10 c0 04 lduh [ %g3 + %g4 ], %g4
203fcec: 80 a2 00 04 cmp %o0, %g4
203fcf0: 2a 80 00 07 bcs,a 203fd0c <msdos_date_unix2dos+0xfc> <== ALWAYS TAKEN
203fcf4: 90 02 20 01 inc %o0
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
203fcf8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
203fcfc: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
203fd00: 12 bf ff f9 bne 203fce4 <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
203fd04: 90 22 00 04 sub %o0, %g4, %o0 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
203fd08: 90 02 20 01 inc %o0 <== NOT EXECUTED
203fd0c: 84 00 a0 01 inc %g2
203fd10: 07 00 81 bb sethi %hi(0x206ec00), %g3
203fd14: 85 28 a0 05 sll %g2, 5, %g2
203fd18: 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)
203fd1c: 80 a0 67 bc cmp %g1, 0x7bc
203fd20: 08 80 00 06 bleu 203fd38 <msdos_date_unix2dos+0x128> <== NEVER TAKEN
203fd24: d0 30 e1 58 sth %o0, [ %g3 + 0x158 ]
lastddate += (year - 1980) <<
203fd28: 82 00 78 44 add %g1, -1980, %g1
203fd2c: 83 28 60 09 sll %g1, 9, %g1
203fd30: 90 02 00 01 add %o0, %g1, %o0
203fd34: d0 30 e1 58 sth %o0, [ %g3 + 0x158 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
203fd38: 03 00 81 bb sethi %hi(0x206ec00), %g1
203fd3c: c2 10 61 50 lduh [ %g1 + 0x150 ], %g1 ! 206ed50 <lastdtime>
203fd40: c2 36 80 00 sth %g1, [ %i2 ]
*ddp = lastddate;
203fd44: 03 00 81 bb sethi %hi(0x206ec00), %g1
203fd48: c2 10 61 58 lduh [ %g1 + 0x158 ], %g1 ! 206ed58 <lastddate>
203fd4c: c2 36 40 00 sth %g1, [ %i1 ]
}
203fd50: 81 c7 e0 08 ret
203fd54: 81 e8 00 00 restore
0204008c <msdos_dir_close>:
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
204008c: 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;
2040090: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040094: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
int
msdos_dir_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040098: fa 00 60 20 ld [ %g1 + 0x20 ], %i5
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
204009c: 92 10 20 00 clr %o1
20400a0: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
20400a4: 7f ff 34 26 call 200d13c <rtems_semaphore_obtain>
20400a8: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20400ac: 80 a2 20 00 cmp %o0, 0
20400b0: 22 80 00 08 be,a 20400d0 <msdos_dir_close+0x44> <== ALWAYS TAKEN
20400b4: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
rtems_set_errno_and_return_minus_one( EIO );
20400b8: 40 00 06 fa call 2041ca0 <__errno> <== NOT EXECUTED
20400bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20400c0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20400c4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20400c8: 81 c7 e0 08 ret <== NOT EXECUTED
20400cc: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
20400d0: 7f ff 94 96 call 2025328 <fat_file_close>
20400d4: 92 10 00 1c mov %i4, %o1
if (rc != RC_OK)
20400d8: b0 92 20 00 orcc %o0, 0, %i0
20400dc: 02 80 00 06 be 20400f4 <msdos_dir_close+0x68> <== ALWAYS TAKEN
20400e0: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
{
rtems_semaphore_release(fs_info->vol_sema);
20400e4: 7f ff 34 60 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
20400e8: 01 00 00 00 nop <== NOT EXECUTED
return rc;
20400ec: 81 c7 e0 08 ret <== NOT EXECUTED
20400f0: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_semaphore_release(fs_info->vol_sema);
20400f4: 7f ff 34 5c call 200d264 <rtems_semaphore_release>
20400f8: 01 00 00 00 nop
return RC_OK;
}
20400fc: 81 c7 e0 08 ret
2040100: 81 e8 00 00 restore
02034918 <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
)
{
2034918: 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,
203491c: 21 00 81 9b sethi %hi(0x2066c00), %l0
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2034920: fa 06 20 20 ld [ %i0 + 0x20 ], %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)),
2034924: 37 00 81 9b sethi %hi(0x2066c00), %i3
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;
2034928: 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;
203492c: b8 10 20 00 clr %i4
*/
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,
2034930: a0 14 20 08 or %l0, 8, %l0
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
2034934: 10 80 00 33 b 2034a00 <msdos_dir_is_empty+0xe8>
2034938: b6 16 e0 18 or %i3, 0x18, %i3
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
203493c: 24 80 00 2a ble,a 20349e4 <msdos_dir_is_empty+0xcc> <== NEVER TAKEN
2034940: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
2034944: c2 17 40 00 lduh [ %i5 ], %g1
2034948: 80 a2 00 01 cmp %o0, %g1
203494c: 02 80 00 28 be 20349ec <msdos_dir_is_empty+0xd4> <== ALWAYS TAKEN
2034950: a2 10 20 00 clr %l1
2034954: 11 00 81 9a sethi %hi(0x2066800), %o0 <== NOT EXECUTED
2034958: 15 00 81 9b sethi %hi(0x2066c00), %o2 <== NOT EXECUTED
203495c: 17 00 81 9a sethi %hi(0x2066800), %o3 <== NOT EXECUTED
2034960: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
2034964: 92 10 23 62 mov 0x362, %o1 <== NOT EXECUTED
2034968: 94 12 a0 50 or %o2, 0x50, %o2 <== NOT EXECUTED
203496c: 7f ff ca 4a call 2027294 <__assert_func> <== NOT EXECUTED
2034970: 96 12 e3 e8 or %o3, 0x3e8, %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)) ==
2034974: e6 08 40 11 ldub [ %g1 + %l1 ], %l3
2034978: 80 a4 e0 e5 cmp %l3, 0xe5
203497c: 02 80 00 14 be 20349cc <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
2034980: a4 00 40 11 add %g1, %l1, %l2
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
2034984: c2 0c a0 0b ldub [ %l2 + 0xb ], %g1
2034988: 82 08 60 3f and %g1, 0x3f, %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) ||
203498c: 80 a0 60 0f cmp %g1, 0xf
2034990: 02 80 00 0f be 20349cc <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
2034994: 90 10 00 12 mov %l2, %o0
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
2034998: 92 10 00 10 mov %l0, %o1
203499c: 40 00 51 4f call 2048ed8 <strncmp>
20349a0: 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) ||
20349a4: 80 a2 20 00 cmp %o0, 0
20349a8: 22 80 00 12 be,a 20349f0 <msdos_dir_is_empty+0xd8>
20349ac: a2 04 60 20 add %l1, 0x20, %l1
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
20349b0: 90 10 00 12 mov %l2, %o0
20349b4: 92 10 00 1b mov %i3, %o1
20349b8: 40 00 51 48 call 2048ed8 <strncmp>
20349bc: 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) ||
20349c0: 80 a2 20 00 cmp %o0, 0
20349c4: 12 80 00 04 bne 20349d4 <msdos_dir_is_empty+0xbc>
20349c8: 80 a4 e0 00 cmp %l3, 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)
20349cc: 10 80 00 09 b 20349f0 <msdos_dir_is_empty+0xd8>
20349d0: a2 04 60 20 add %l1, 0x20, %l1
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
20349d4: 12 80 00 04 bne 20349e4 <msdos_dir_is_empty+0xcc>
20349d8: b0 10 20 00 clr %i0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
20349dc: 82 10 20 01 mov 1, %g1
20349e0: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
20349e4: 81 c7 e0 08 ret
20349e8: 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;
20349ec: a8 10 00 08 mov %o0, %l4
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
20349f0: 80 a4 40 14 cmp %l1, %l4
20349f4: 2a bf ff e0 bcs,a 2034974 <msdos_dir_is_empty+0x5c> <== ALWAYS TAKEN
20349f8: c2 07 60 94 ld [ %i5 + 0x94 ], %g1
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
20349fc: b8 07 20 01 inc %i4 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
2034a00: e2 17 40 00 lduh [ %i5 ], %l1
2034a04: 90 10 00 1c mov %i4, %o0
2034a08: 7f ff 38 ed call 2002dbc <.umul>
2034a0c: 92 10 00 11 mov %l1, %o1
2034a10: d8 07 60 94 ld [ %i5 + 0x94 ], %o4
2034a14: 94 10 00 08 mov %o0, %o2
2034a18: 92 10 00 19 mov %i1, %o1
2034a1c: 90 10 00 18 mov %i0, %o0
2034a20: 7f ff c1 8f call 202505c <fat_file_read>
2034a24: 96 10 00 11 mov %l1, %o3
2034a28: 80 a2 20 00 cmp %o0, 0
2034a2c: 32 bf ff c4 bne,a 203493c <msdos_dir_is_empty+0x24> <== ALWAYS TAKEN
2034a30: 80 a2 20 1f cmp %o0, 0x1f
*/
return RC_OK;
}
j++;
}
*ret_val = true;
2034a34: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2034a38: c2 2e 80 00 stb %g1, [ %i2 ] <== NOT EXECUTED
2034a3c: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
}
2034a40: 81 c7 e0 08 ret <== NOT EXECUTED
2034a44: 81 e8 00 00 restore <== NOT EXECUTED
02040624 <msdos_dir_lseek>:
* RC_OK on success, or -1 if error occured (errno
* set apropriately).
*/
off_t
msdos_dir_lseek(rtems_libio_t *iop, off_t offset, int whence)
{
2040624: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (iop->offset >= 0 && iop->offset <= iop->size) {
2040628: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
204062c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2040630: 06 80 00 0c bl 2040660 <msdos_dir_lseek+0x3c> <== NOT EXECUTED
2040634: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 <== NOT EXECUTED
2040638: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED
204063c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2040640: 06 80 00 08 bl 2040660 <msdos_dir_lseek+0x3c> <== NOT EXECUTED
2040644: 01 00 00 00 nop <== NOT EXECUTED
2040648: 32 80 00 0d bne,a 204067c <msdos_dir_lseek+0x58> <== NOT EXECUTED
204064c: b0 10 20 00 clr %i0 ! 0 <PROM_START> <== NOT EXECUTED
2040650: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
2040654: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2040658: 3a 80 00 09 bcc,a 204067c <msdos_dir_lseek+0x58> <== NOT EXECUTED
204065c: b0 10 20 00 clr %i0 <== NOT EXECUTED
return 0;
} else {
rtems_set_errno_and_return_minus_one(EINVAL);
2040660: 40 00 05 90 call 2041ca0 <__errno> <== NOT EXECUTED
2040664: 31 3f ff ff sethi %hi(0xfffffc00), %i0 <== NOT EXECUTED
2040668: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
204066c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040670: b0 16 23 ff or %i0, 0x3ff, %i0 <== NOT EXECUTED
2040674: 81 c7 e0 08 ret <== NOT EXECUTED
2040678: 93 e8 00 18 restore %g0, %i0, %o1 <== NOT EXECUTED
}
}
204067c: 81 c7 e0 08 ret <== NOT EXECUTED
2040680: 93 e8 20 00 restore %g0, 0, %o1 <== NOT EXECUTED
0204000c <msdos_dir_open>:
* set offset field of file control block to zero.
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, int oflag,
mode_t mode)
{
204000c: 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;
2040010: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040014: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
msdos_dir_open(rtems_libio_t *iop, const char *pathname, int oflag,
mode_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040018: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
204001c: 92 10 20 00 clr %o1
2040020: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
2040024: 94 10 20 00 clr %o2
2040028: 7f ff 34 45 call 200d13c <rtems_semaphore_obtain>
204002c: ba 10 00 18 mov %i0, %i5
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040030: 80 a2 20 00 cmp %o0, 0
2040034: 02 80 00 08 be 2040054 <msdos_dir_open+0x48> <== ALWAYS TAKEN
2040038: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EIO );
204003c: 40 00 07 19 call 2041ca0 <__errno> <== NOT EXECUTED
2040040: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2040044: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040048: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
204004c: 81 c7 e0 08 ret <== NOT EXECUTED
2040050: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
2040054: 7f ff 93 fd call 2025048 <fat_file_reopen>
2040058: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
204005c: b0 92 20 00 orcc %o0, 0, %i0
2040060: 02 80 00 06 be 2040078 <msdos_dir_open+0x6c> <== ALWAYS TAKEN
2040064: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
{
rtems_semaphore_release(fs_info->vol_sema);
2040068: 7f ff 34 7f call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
204006c: 01 00 00 00 nop <== NOT EXECUTED
return rc;
2040070: 81 c7 e0 08 ret <== NOT EXECUTED
2040074: 81 e8 00 00 restore <== NOT EXECUTED
}
iop->offset = 0;
2040078: c0 27 60 10 clr [ %i5 + 0x10 ]
rtems_semaphore_release(fs_info->vol_sema);
204007c: 7f ff 34 7a call 200d264 <rtems_semaphore_release>
2040080: c0 27 60 14 clr [ %i5 + 0x14 ]
return RC_OK;
}
2040084: 81 c7 e0 08 ret
2040088: 81 e8 00 00 restore
02040104 <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)
{
2040104: 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;
2040108: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
204010c: e0 06 20 24 ld [ %i0 + 0x24 ], %l0 <== 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;
2040110: f8 00 60 20 ld [ %g1 + 0x20 ], %i4 <== 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 :
2040114: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== 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)
{
2040118: 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;
204011c: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
uint32_t start = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
2040120: c0 27 bf fc clr [ %fp + -4 ] <== 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)
{
2040124: ba 10 00 18 mov %i0, %i5 <== 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 :
2040128: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
204012c: 12 80 00 0c bne 204015c <msdos_dir_read+0x58> <== NOT EXECUTED
2040130: f0 1e 20 10 ldd [ %i0 + 0x10 ], %i0 <== 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) &&
2040134: c2 04 20 24 ld [ %l0 + 0x24 ], %g1 <== NOT EXECUTED
2040138: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
204013c: 32 80 00 09 bne,a 2040160 <msdos_dir_read+0x5c> <== NOT EXECUTED
2040140: ec 17 20 06 lduh [ %i4 + 6 ], %l6 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
2040144: c2 0f 20 0a ldub [ %i4 + 0xa ], %g1 <== 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) &&
2040148: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
204014c: 22 80 00 05 be,a 2040160 <msdos_dir_read+0x5c> <== NOT EXECUTED
2040150: ec 17 20 06 lduh [ %i4 + 6 ], %l6 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
2040154: 10 80 00 03 b 2040160 <msdos_dir_read+0x5c> <== NOT EXECUTED
2040158: ec 04 20 18 ld [ %l0 + 0x18 ], %l6 <== NOT EXECUTED
204015c: ec 17 20 06 lduh [ %i4 + 6 ], %l6 <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040160: d0 07 20 90 ld [ %i4 + 0x90 ], %o0 <== NOT EXECUTED
2040164: 92 10 20 00 clr %o1 <== NOT EXECUTED
2040168: 7f ff 33 f5 call 200d13c <rtems_semaphore_obtain> <== NOT EXECUTED
204016c: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040170: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2040174: 12 80 00 20 bne 20401f4 <msdos_dir_read+0xf0> <== NOT EXECUTED
2040178: 92 10 00 19 mov %i1, %o1 <== 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);
204017c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2040180: 96 10 21 18 mov 0x118, %o3 <== NOT EXECUTED
2040184: 40 00 6e 94 call 205bbd4 <__divdi3> <== NOT EXECUTED
2040188: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
204018c: 90 10 00 1a mov %i2, %o0 <== 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);
2040190: a8 10 00 09 mov %o1, %l4 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
2040194: 40 00 6c af call 205b450 <.udiv> <== NOT EXECUTED
2040198: 92 10 21 18 mov 0x118, %o1 <== NOT EXECUTED
204019c: a4 10 20 00 clr %l2 <== NOT EXECUTED
20401a0: a7 2a 20 03 sll %o0, 3, %l3 <== NOT EXECUTED
20401a4: b6 10 20 00 clr %i3 <== NOT EXECUTED
20401a8: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
20401ac: aa 10 20 00 clr %l5 <== NOT EXECUTED
20401b0: a6 04 c0 08 add %l3, %o0, %l3 <== NOT EXECUTED
20401b4: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
20401b8: 83 2c e0 03 sll %l3, 3, %g1 <== NOT EXECUTED
20401bc: a2 10 20 00 clr %l1 <== NOT EXECUTED
20401c0: a6 20 40 13 sub %g1, %l3, %l3 <== NOT EXECUTED
20401c4: 10 80 01 01 b 20405c8 <msdos_dir_read+0x4c4> <== NOT EXECUTED
20401c8: b2 10 00 1c mov %i4, %i1 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
20401cc: d8 06 60 94 ld [ %i1 + 0x94 ], %o4 <== NOT EXECUTED
20401d0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20401d4: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
20401d8: 7f ff 93 a1 call 202505c <fat_file_read> <== NOT EXECUTED
20401dc: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
20401e0: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
20401e4: 14 80 00 f4 bg 20405b4 <msdos_dir_read+0x4b0> <== NOT EXECUTED
20401e8: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
20401ec: 7f ff 34 1e call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
20401f0: d0 06 60 90 ld [ %i1 + 0x90 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
20401f4: 40 00 06 ab call 2041ca0 <__errno> <== NOT EXECUTED
20401f8: 01 00 00 00 nop <== NOT EXECUTED
20401fc: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2040200: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040204: 10 80 00 f7 b 20405e0 <msdos_dir_read+0x4dc> <== NOT EXECUTED
2040208: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
204020c: b0 00 40 1c add %g1, %i4, %i0 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
2040210: c2 08 40 1c ldub [ %g1 + %i4 ], %g1 <== NOT EXECUTED
2040214: 84 88 60 ff andcc %g1, 0xff, %g2 <== NOT EXECUTED
2040218: 02 80 00 ef be 20405d4 <msdos_dir_read+0x4d0> <== NOT EXECUTED
204021c: 01 00 00 00 nop <== 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)
2040220: 80 a0 a0 e5 cmp %g2, 0xe5 <== NOT EXECUTED
2040224: 22 80 00 e5 be,a 20405b8 <msdos_dir_read+0x4b4> <== NOT EXECUTED
2040228: 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) &&
204022c: c4 0e 20 0b ldub [ %i0 + 0xb ], %g2 <== NOT EXECUTED
2040230: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED
2040234: 02 80 00 05 be 2040248 <msdos_dir_read+0x144> <== NOT EXECUTED
2040238: 84 08 a0 3f and %g2, 0x3f, %g2 <== NOT EXECUTED
204023c: 80 a0 a0 0f cmp %g2, 0xf <== NOT EXECUTED
2040240: 32 80 00 de bne,a 20405b8 <msdos_dir_read+0x4b4> <== NOT EXECUTED
2040244: 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) ==
2040248: 80 a0 a0 0f cmp %g2, 0xf <== NOT EXECUTED
204024c: 12 80 00 3d bne 2040340 <msdos_dir_read+0x23c> <== NOT EXECUTED
2040250: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
2040254: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
2040258: 32 80 00 0f bne,a 2040294 <msdos_dir_read+0x190> <== NOT EXECUTED
204025c: c2 0e 00 00 ldub [ %i0 ], %g1 <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
2040260: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
2040264: 80 88 60 40 btst 0x40, %g1 <== NOT EXECUTED
2040268: 22 80 00 d4 be,a 20405b8 <msdos_dir_read+0x4b4> <== NOT EXECUTED
204026c: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
2040270: b4 07 00 12 add %i4, %l2, %i2 <== 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) &
2040274: b6 08 60 3f and %g1, 0x3f, %i3 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
2040278: b5 36 a0 05 srl %i2, 5, %i2 <== 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);
204027c: ea 0e 20 0d ldub [ %i0 + 0xd ], %l5 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
2040280: 90 07 be e4 add %fp, -284, %o0 <== NOT EXECUTED
2040284: 92 10 20 00 clr %o1 <== NOT EXECUTED
2040288: 40 00 14 53 call 20453d4 <memset> <== NOT EXECUTED
204028c: 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) &
2040290: c2 0e 00 00 ldub [ %i0 ], %g1 <== NOT EXECUTED
2040294: 82 08 60 3f and %g1, 0x3f, %g1 <== NOT EXECUTED
2040298: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
204029c: 32 80 00 c4 bne,a 20405ac <msdos_dir_read+0x4a8> <== NOT EXECUTED
20402a0: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
20402a4: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1 <== NOT EXECUTED
20402a8: 84 0d 60 ff and %l5, 0xff, %g2 <== NOT EXECUTED
20402ac: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20402b0: 32 80 00 bf bne,a 20405ac <msdos_dir_read+0x4a8> <== NOT EXECUTED
20402b4: b4 10 3f ff mov -1, %i2 <== 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--;
20402b8: b6 06 ff ff add %i3, -1, %i3 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
20402bc: 83 2e e0 02 sll %i3, 2, %g1 <== NOT EXECUTED
20402c0: 85 2e e0 04 sll %i3, 4, %g2 <== 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;
20402c4: b0 06 20 01 inc %i0 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
20402c8: 84 20 80 01 sub %g2, %g1, %g2 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
20402cc: 82 10 20 00 clr %g1 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
20402d0: 84 00 80 1b add %g2, %i3, %g2 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
20402d4: 80 a0 a0 fe cmp %g2, 0xfe <== NOT EXECUTED
20402d8: 18 80 00 af bgu 2040594 <msdos_dir_read+0x490> <== NOT EXECUTED
20402dc: 9e 07 be d0 add %fp, -304, %o7 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
20402e0: c8 0e 00 00 ldub [ %i0 ], %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)
20402e4: 86 03 c0 02 add %o7, %g2, %g3 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
20402e8: c8 28 e0 14 stb %g4, [ %g3 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
20402ec: c6 4e 00 00 ldsb [ %i0 ], %g3 <== NOT EXECUTED
20402f0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
20402f4: 02 80 00 a8 be 2040594 <msdos_dir_read+0x490> <== NOT EXECUTED
20402f8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
break;
switch (q)
20402fc: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
2040300: 02 80 00 06 be 2040318 <msdos_dir_read+0x214> <== NOT EXECUTED
2040304: 80 a0 60 0a cmp %g1, 0xa <== NOT EXECUTED
2040308: 32 80 00 08 bne,a 2040328 <msdos_dir_read+0x224> <== NOT EXECUTED
204030c: b0 06 20 02 add %i0, 2, %i0 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
2040310: 10 80 00 04 b 2040320 <msdos_dir_read+0x21c> <== NOT EXECUTED
2040314: b0 06 20 04 add %i0, 4, %i0 <== NOT EXECUTED
switch (q)
{
case 4:
p += 5;
break;
2040318: 10 80 00 04 b 2040328 <msdos_dir_read+0x224> <== NOT EXECUTED
204031c: b0 06 20 05 add %i0, 5, %i0 <== NOT EXECUTED
case 10:
p += 4;
break;
2040320: 10 80 00 03 b 204032c <msdos_dir_read+0x228> <== NOT EXECUTED
2040324: 82 00 60 01 inc %g1 <== 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++)
2040328: 82 00 60 01 inc %g1 <== NOT EXECUTED
204032c: 80 a0 60 0d cmp %g1, 0xd <== NOT EXECUTED
2040330: 32 bf ff ea bne,a 20402d8 <msdos_dir_read+0x1d4> <== NOT EXECUTED
2040334: 80 a0 a0 fe cmp %g2, 0xfe <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
2040338: 10 80 00 98 b 2040598 <msdos_dir_read+0x494> <== NOT EXECUTED
204033c: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
2040340: 22 80 00 04 be,a 2040350 <msdos_dir_read+0x24c> <== NOT EXECUTED
2040344: d0 07 60 34 ld [ %i5 + 0x34 ], %o0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
2040348: 10 80 00 98 b 20405a8 <msdos_dir_read+0x4a4> <== NOT EXECUTED
204034c: a8 05 3f ff add %l4, -1, %l4 <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
2040350: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2040354: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2040358: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
204035c: 7f ff 94 21 call 20253e0 <fat_file_ioctl> <== NOT EXECUTED
2040360: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
2040364: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2040368: 12 80 00 86 bne 2040580 <msdos_dir_read+0x47c> <== NOT EXECUTED
204036c: 82 10 00 08 mov %o0, %g1 <== 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;
2040370: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
2040374: d0 07 60 34 ld [ %i5 + 0x34 ], %o0 <== NOT EXECUTED
2040378: c2 27 bf f0 st %g1, [ %fp + -16 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
204037c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
2040380: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
dir_pos.sname.ofs = i;
2040384: f8 27 bf ec st %i4, [ %fp + -20 ] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
2040388: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
204038c: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
2040390: 7f ff 92 db call 2024efc <fat_file_open> <== NOT EXECUTED
2040394: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
if (rc != RC_OK)
2040398: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
204039c: 12 80 00 79 bne 2040580 <msdos_dir_read+0x47c> <== NOT EXECUTED
20403a0: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
20403a4: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== 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);
20403a8: 84 10 21 18 mov 0x118, %g2 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
20403ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1 <== 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;
20403b0: c0 27 be d8 clr [ %fp + -296 ] <== NOT EXECUTED
20403b4: e2 27 be dc st %l1, [ %fp + -292 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
20403b8: c4 37 be e0 sth %g2, [ %fp + -288 ] <== 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)
20403bc: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
20403c0: 02 80 00 1d be 2040434 <msdos_dir_read+0x330> <== NOT EXECUTED
20403c4: c2 27 be d0 st %g1, [ %fp + -304 ] <== NOT EXECUTED
20403c8: 82 10 20 00 clr %g1 <== NOT EXECUTED
20403cc: 84 10 20 00 clr %g2 <== 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;
20403d0: c8 0e 00 01 ldub [ %i0 + %g1 ], %g4 <== NOT EXECUTED
20403d4: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED
20403d8: 86 08 a0 01 and %g2, 1, %g3 <== NOT EXECUTED
20403dc: 80 a0 00 03 cmp %g0, %g3 <== NOT EXECUTED
20403e0: 85 30 a0 01 srl %g2, 1, %g2 <== NOT EXECUTED
20403e4: 86 40 3f ff addx %g0, -1, %g3 <== NOT EXECUTED
20403e8: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED
20403ec: 86 08 e0 80 and %g3, 0x80, %g3 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
20403f0: 82 00 60 01 inc %g1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
20403f4: 86 00 ff 80 add %g3, -128, %g3 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
20403f8: 80 a0 60 0b cmp %g1, 0xb <== NOT EXECUTED
20403fc: 12 bf ff f5 bne 20403d0 <msdos_dir_read+0x2cc> <== NOT EXECUTED
2040400: 84 00 80 03 add %g2, %g3, %g2 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
2040404: 84 18 80 15 xor %g2, %l5, %g2 <== NOT EXECUTED
2040408: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
204040c: 12 80 00 0b bne 2040438 <msdos_dir_read+0x334> <== NOT EXECUTED
2040410: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED
2040414: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
2040418: 12 80 00 09 bne 204043c <msdos_dir_read+0x338> <== NOT EXECUTED
204041c: 84 06 00 01 add %i0, %g1, %g2 <== NOT EXECUTED
2040420: 30 80 00 72 b,a 20405e8 <msdos_dir_read+0x4e4> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
2040424: 32 80 00 06 bne,a 204043c <msdos_dir_read+0x338> <== NOT EXECUTED
2040428: 84 06 00 01 add %i0, %g1, %g2 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
204042c: 10 80 00 09 b 2040450 <msdos_dir_read+0x34c> <== NOT EXECUTED
2040430: 07 00 81 ae sethi %hi(0x206b800), %g3 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
2040434: 82 10 20 08 mov 8, %g1 <== 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)
2040438: 84 06 00 01 add %i0, %g1, %g2 <== 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) &&
204043c: c4 48 bf ff ldsb [ %g2 + -1 ], %g2 <== NOT EXECUTED
2040440: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
2040444: 22 bf ff f8 be,a 2040424 <msdos_dir_read+0x320> <== NOT EXECUTED
2040448: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
204044c: 07 00 81 ae sethi %hi(0x206b800), %g3 <== NOT EXECUTED
2040450: 84 10 20 00 clr %g2 <== NOT EXECUTED
2040454: 10 80 00 0c b 2040484 <msdos_dir_read+0x380> <== NOT EXECUTED
2040458: c8 00 e1 58 ld [ %g3 + 0x158 ], %g4 <== NOT EXECUTED
204045c: b4 01 00 03 add %g4, %g3, %i2 <== NOT EXECUTED
2040460: f4 0e a0 01 ldub [ %i2 + 1 ], %i2 <== NOT EXECUTED
2040464: b4 0e a0 03 and %i2, 3, %i2 <== NOT EXECUTED
2040468: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
204046c: 22 80 00 02 be,a 2040474 <msdos_dir_read+0x370> <== NOT EXECUTED
2040470: 86 00 e0 20 add %g3, 0x20, %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)
2040474: 9e 07 be d0 add %fp, -304, %o7 <== NOT EXECUTED
2040478: b4 03 c0 02 add %o7, %g2, %i2 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
204047c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2040480: c6 2e a0 14 stb %g3, [ %i2 + 0x14 ] <== 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)
2040484: 86 20 40 02 sub %g1, %g2, %g3 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
2040488: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
204048c: 34 bf ff f4 bg,a 204045c <msdos_dir_read+0x358> <== NOT EXECUTED
2040490: c6 0e 00 02 ldub [ %i0 + %g2 ], %g3 <== 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) &&
2040494: c4 4e 20 0a ldsb [ %i0 + 0xa ], %g2 <== 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)
2040498: 86 38 00 01 xnor %g0, %g1, %g3 <== NOT EXECUTED
204049c: b4 07 be d0 add %fp, -304, %i2 <== NOT EXECUTED
20404a0: 87 38 e0 1f sra %g3, 0x1f, %g3 <== 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) &&
20404a4: 80 a0 a0 20 cmp %g2, 0x20 <== 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)
20404a8: 86 08 40 03 and %g1, %g3, %g3 <== NOT EXECUTED
20404ac: 88 06 80 03 add %i2, %g3, %g4 <== 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) &&
20404b0: 12 80 00 52 bne 20405f8 <msdos_dir_read+0x4f4> <== NOT EXECUTED
20404b4: 88 01 20 14 add %g4, 0x14, %g4 <== NOT EXECUTED
20404b8: c4 4e 20 09 ldsb [ %i0 + 9 ], %g2 <== NOT EXECUTED
20404bc: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
20404c0: 12 80 00 4f bne 20405fc <msdos_dir_read+0x4f8> <== NOT EXECUTED
20404c4: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED
20404c8: c4 4e 20 08 ldsb [ %i0 + 8 ], %g2 <== NOT EXECUTED
20404cc: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
20404d0: 22 80 00 18 be,a 2040530 <msdos_dir_read+0x42c> <== NOT EXECUTED
20404d4: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
20404d8: 10 80 00 49 b 20405fc <msdos_dir_read+0x4f8> <== NOT EXECUTED
20404dc: 84 10 20 01 mov 1, %g2 <== 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++));
20404e0: f4 0e a0 08 ldub [ %i2 + 8 ], %i2 <== NOT EXECUTED
20404e4: 98 03 c0 1a add %o7, %i2, %o4 <== NOT EXECUTED
20404e8: d8 0b 20 01 ldub [ %o4 + 1 ], %o4 <== NOT EXECUTED
20404ec: 98 0b 20 03 and %o4, 3, %o4 <== NOT EXECUTED
20404f0: 80 a3 20 01 cmp %o4, 1 <== NOT EXECUTED
20404f4: 22 80 00 02 be,a 20404fc <msdos_dir_read+0x3f8> <== NOT EXECUTED
20404f8: b4 06 a0 20 add %i2, 0x20, %i2 <== 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)
20404fc: 98 01 00 03 add %g4, %g3, %o4 <== 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++));
2040500: 86 00 e0 01 inc %g3 <== NOT EXECUTED
2040504: f4 2b 20 01 stb %i2, [ %o4 + 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)
2040508: b4 20 80 03 sub %g2, %g3, %i2 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
204050c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2040510: 14 bf ff f4 bg 20404e0 <msdos_dir_read+0x3dc> <== NOT EXECUTED
2040514: b4 06 00 03 add %i0, %g3, %i2 <== 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)
2040518: 86 38 00 02 xnor %g0, %g2, %g3 <== NOT EXECUTED
204051c: 87 38 e0 1f sra %g3, 0x1f, %g3 <== NOT EXECUTED
2040520: 84 08 80 03 and %g2, %g3, %g2 <== NOT EXECUTED
2040524: 88 03 40 02 add %o5, %g2, %g4 <== NOT EXECUTED
2040528: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
204052c: 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(
2040530: c2 37 be e2 sth %g1, [ %fp + -286 ] <== NOT EXECUTED
2040534: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
2040538: c2 07 a0 48 ld [ %fp + 0x48 ], %g1 <== NOT EXECUTED
204053c: 92 07 be d0 add %fp, -304, %o1 <== NOT EXECUTED
2040540: 90 00 40 11 add %g1, %l1, %o0 <== NOT EXECUTED
2040544: 40 00 13 18 call 20451a4 <memcpy> <== NOT EXECUTED
2040548: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
204054c: c4 1f 60 10 ldd [ %i5 + 0x10 ], %g2 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
2040550: d0 07 60 34 ld [ %i5 + 0x34 ], %o0 <== NOT EXECUTED
2040554: d2 07 bf f8 ld [ %fp + -8 ], %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);
2040558: 86 80 e1 18 addcc %g3, 0x118, %g3 <== NOT EXECUTED
204055c: 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(iop->pathinfo.mt_entry, tmp_fat_fd);
2040560: 7f ff 93 72 call 2025328 <fat_file_close> <== NOT EXECUTED
2040564: c4 3f 60 10 std %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
if (rc != RC_OK)
2040568: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
204056c: 12 80 00 04 bne 204057c <msdos_dir_read+0x478> <== NOT EXECUTED
2040570: a2 04 61 18 add %l1, 0x118, %l1 <== NOT EXECUTED
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
2040574: 10 80 00 08 b 2040594 <msdos_dir_read+0x490> <== NOT EXECUTED
2040578: a6 04 fe e8 add %l3, -280, %l3 <== NOT EXECUTED
204057c: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
2040580: d0 06 60 90 ld [ %i1 + 0x90 ], %o0 <== NOT EXECUTED
2040584: 7f ff 33 38 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040588: c2 27 be cc st %g1, [ %fp + -308 ] <== NOT EXECUTED
return rc;
204058c: 10 80 00 15 b 20405e0 <msdos_dir_read+0x4dc> <== NOT EXECUTED
2040590: c2 07 be cc ld [ %fp + -308 ], %g1 <== NOT EXECUTED
}
}
if (count <= 0)
2040594: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
2040598: 32 80 00 08 bne,a 20405b8 <msdos_dir_read+0x4b4> <== NOT EXECUTED
204059c: b8 07 20 20 add %i4, 0x20, %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)
20405a0: 10 80 00 0a b 20405c8 <msdos_dir_read+0x4c4> <== NOT EXECUTED
20405a4: a4 04 80 16 add %l2, %l6, %l2 <== 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;
20405a8: b4 10 3f ff mov -1, %i2 <== 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)
20405ac: 10 80 00 03 b 20405b8 <msdos_dir_read+0x4b4> <== NOT EXECUTED
20405b0: 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(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
20405b4: 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)
20405b8: 80 a7 00 17 cmp %i4, %l7 <== NOT EXECUTED
20405bc: 2a bf ff 14 bcs,a 204020c <msdos_dir_read+0x108> <== NOT EXECUTED
20405c0: c2 06 60 94 ld [ %i1 + 0x94 ], %g1 <== NOT EXECUTED
20405c4: a4 04 80 16 add %l2, %l6, %l2 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
20405c8: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
20405cc: 32 bf ff 00 bne,a 20401cc <msdos_dir_read+0xc8> <== NOT EXECUTED
20405d0: d0 07 60 34 ld [ %i5 + 0x34 ], %o0 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
20405d4: 7f ff 33 24 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
20405d8: d0 06 60 90 ld [ %i1 + 0x90 ], %o0 <== NOT EXECUTED
return cmpltd;
20405dc: 82 10 00 11 mov %l1, %g1 <== NOT EXECUTED
}
20405e0: 81 c7 e0 08 ret <== NOT EXECUTED
20405e4: 91 e8 00 01 restore %g0, %g1, %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);
20405e8: 40 00 21 cb call 2048d14 <strlen> <== NOT EXECUTED
20405ec: 90 07 be e4 add %fp, -284, %o0 <== NOT EXECUTED
20405f0: 10 bf ff d2 b 2040538 <msdos_dir_read+0x434> <== NOT EXECUTED
20405f4: d0 37 be e2 sth %o0, [ %fp + -286 ] <== NOT EXECUTED
20405f8: 84 10 20 03 mov 3, %g2 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
20405fc: 86 07 80 03 add %fp, %g3, %g3 <== NOT EXECUTED
2040600: 9e 10 20 2e mov 0x2e, %o7 <== NOT EXECUTED
2040604: de 28 fe e4 stb %o7, [ %g3 + -284 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
2040608: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
204060c: 35 00 81 ae sethi %hi(0x206b800), %i2 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
2040610: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
2040614: 9a 01 20 01 add %g4, 1, %o5 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
2040618: de 06 a1 58 ld [ %i2 + 0x158 ], %o7 <== NOT EXECUTED
204061c: 10 bf ff bb b 2040508 <msdos_dir_read+0x404> <== NOT EXECUTED
2040620: 86 10 20 00 clr %g3 <== NOT EXECUTED
02040684 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
2040684: 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;
2040688: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
204068c: 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;
2040690: fa 00 60 20 ld [ %g1 + 0x20 ], %i5
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040694: 92 10 20 00 clr %o1
2040698: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
204069c: 7f ff 32 a8 call 200d13c <rtems_semaphore_obtain>
20406a0: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20406a4: 80 a2 20 00 cmp %o0, 0
20406a8: 22 80 00 08 be,a 20406c8 <msdos_dir_stat+0x44> <== ALWAYS TAKEN
20406ac: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
20406b0: 40 00 05 7c call 2041ca0 <__errno> <== NOT EXECUTED
20406b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20406b8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20406bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20406c0: 81 c7 e0 08 ret <== NOT EXECUTED
20406c4: 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);
20406c8: 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);
20406cc: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
20406d0: 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);
20406d4: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
20406d8: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
20406dc: 03 00 00 10 sethi %hi(0x4000), %g1
20406e0: 82 10 61 ff or %g1, 0x1ff, %g1 ! 41ff <PROM_START+0x41ff>
20406e4: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
20406e8: 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;
20406ec: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
20406f0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
20406f4: 83 30 60 09 srl %g1, 9, %g1
20406f8: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
20406fc: 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;
2040700: 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;
2040704: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
2040708: 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;
204070c: 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;
2040710: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
2040714: 7f ff 32 d4 call 200d264 <rtems_semaphore_release>
2040718: b0 10 20 00 clr %i0
return RC_OK;
}
204071c: 81 c7 e0 08 ret
2040720: 81 e8 00 00 restore
02040724 <msdos_dir_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
2040724: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040728: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
int
msdos_dir_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
204072c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040730: fa 00 60 20 ld [ %g1 + 0x20 ], %i5 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040734: 92 10 20 00 clr %o1 <== NOT EXECUTED
2040738: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
204073c: 7f ff 32 80 call 200d13c <rtems_semaphore_obtain> <== NOT EXECUTED
2040740: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040744: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2040748: 22 80 00 08 be,a 2040768 <msdos_dir_sync+0x44> <== NOT EXECUTED
204074c: d0 06 20 34 ld [ %i0 + 0x34 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
2040750: 40 00 05 54 call 2041ca0 <__errno> <== NOT EXECUTED
2040754: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040758: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
204075c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040760: 81 c7 e0 08 ret <== NOT EXECUTED
2040764: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
2040768: 7f ff 94 65 call 20258fc <fat_file_datasync> <== NOT EXECUTED
204076c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2040770: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
2040774: 7f ff 32 bc call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040778: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
return rc;
}
204077c: 81 c7 e0 08 ret <== NOT EXECUTED
2040780: 81 e8 00 00 restore <== NOT EXECUTED
02034200 <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
2034200: 9d e3 bf a0 save %sp, -96, %sp
2034204: ba 10 00 18 mov %i0, %i5
2034208: 92 10 00 1a mov %i2, %o1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
203420c: 80 a6 e0 01 cmp %i3, 1
2034210: 12 80 00 22 bne 2034298 <msdos_eval_token+0x98>
2034214: 94 10 00 1b mov %i3, %o2
2034218: c2 4e 80 00 ldsb [ %i2 ], %g1
203421c: 80 a0 60 2e cmp %g1, 0x2e
2034220: 12 80 00 1e bne 2034298 <msdos_eval_token+0x98>
2034224: 01 00 00 00 nop
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
2034228: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
rtems_filesystem_eval_path_clear_token(ctx);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
203422c: 81 c7 e0 08 ret
2034230: 91 e8 20 00 restore %g0, 0, %o0
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
2034234: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
2034238: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
203423c: c0 27 60 0c clr [ %i5 + 0xc ]
2034240: 80 a0 a0 00 cmp %g2, 0
2034244: 12 80 00 04 bne 2034254 <msdos_eval_token+0x54>
2034248: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
loc->handlers = fs_info->directory_handlers;
203424c: 10 80 00 03 b 2034258 <msdos_eval_token+0x58>
2034250: c2 00 60 88 ld [ %g1 + 0x88 ], %g1
else
loc->handlers = fs_info->file_handlers;
2034254: c2 00 60 8c ld [ %g1 + 0x8c ], %g1
2034258: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
203425c: c2 07 60 04 ld [ %i5 + 4 ], %g1
2034260: 80 a0 00 01 cmp %g0, %g1
2034264: b0 60 3f ff subx %g0, -1, %i0
2034268: 81 c7 e0 08 ret
203426c: 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) {
2034270: 82 10 61 01 or %g1, 0x101, %g1
2034274: 80 a2 00 01 cmp %o0, %g1
2034278: 02 bf ff fc be 2034268 <msdos_eval_token+0x68> <== ALWAYS TAKEN
203427c: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
2034280: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2034284: 92 10 20 00 clr %o1 <== NOT EXECUTED
2034288: 7f ff 57 32 call 2009f50 <rtems_filesystem_eval_path_error><== NOT EXECUTED
203428c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return status;
}
2034290: 81 c7 e0 08 ret <== NOT EXECUTED
2034294: 81 e8 00 00 restore <== NOT EXECUTED
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);
2034298: 40 00 05 9a call 2035900 <msdos_find_name>
203429c: 90 07 60 18 add %i5, 0x18, %o0
if (rc == RC_OK) {
20342a0: 80 a2 20 00 cmp %o0, 0
20342a4: 22 bf ff e4 be,a 2034234 <msdos_eval_token+0x34>
20342a8: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
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) {
20342ac: 10 bf ff f1 b 2034270 <msdos_eval_token+0x70>
20342b0: 03 00 00 1f sethi %hi(0x7c00), %g1
0204081c <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)
{
204081c: 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;
2040820: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040824: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
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;
2040828: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
204082c: 92 10 20 00 clr %o1
2040830: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
2040834: 94 10 20 00 clr %o2
2040838: 7f ff 32 41 call 200d13c <rtems_semaphore_obtain>
204083c: ba 10 00 18 mov %i0, %i5
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040840: 80 a2 20 00 cmp %o0, 0
2040844: 22 80 00 08 be,a 2040864 <msdos_file_close+0x48> <== ALWAYS TAKEN
2040848: c2 0e e0 30 ldub [ %i3 + 0x30 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
204084c: 40 00 05 15 call 2041ca0 <__errno> <== NOT EXECUTED
2040850: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040854: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040858: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
204085c: 81 c7 e0 08 ret <== NOT EXECUTED
2040860: 81 e8 00 00 restore <== NOT EXECUTED
/*
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
2040864: 80 88 60 01 btst 1, %g1
2040868: 32 80 00 13 bne,a 20408b4 <msdos_file_close+0x98> <== NEVER TAKEN
204086c: d0 07 60 34 ld [ %i5 + 0x34 ], %o0 <== NOT EXECUTED
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
2040870: 10 80 00 18 b 20408d0 <msdos_file_close+0xb4>
2040874: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
2040878: 7f ff cf c6 call 2034790 <msdos_set_file_size>
204087c: 92 10 00 1b mov %i3, %o1
if (rc != RC_OK)
2040880: b0 92 20 00 orcc %o0, 0, %i0
2040884: 12 80 00 08 bne 20408a4 <msdos_file_close+0x88> <== NEVER TAKEN
2040888: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
204088c: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
2040890: 7f ff cf 57 call 20345ec <msdos_set_dir_wrt_time_and_date>
2040894: 92 10 00 1b mov %i3, %o1
if (rc != RC_OK)
2040898: b0 92 20 00 orcc %o0, 0, %i0
204089c: 22 80 00 06 be,a 20408b4 <msdos_file_close+0x98> <== ALWAYS TAKEN
20408a0: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
{
rtems_semaphore_release(fs_info->vol_sema);
20408a4: 7f ff 32 70 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
20408a8: d0 07 20 90 ld [ %i4 + 0x90 ], %o0 <== NOT EXECUTED
return rc;
20408ac: 81 c7 e0 08 ret <== NOT EXECUTED
20408b0: 81 e8 00 00 restore <== NOT EXECUTED
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
20408b4: 7f ff 92 9d call 2025328 <fat_file_close>
20408b8: 92 10 00 1b mov %i3, %o1
20408bc: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
20408c0: 7f ff 32 69 call 200d264 <rtems_semaphore_release>
20408c4: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
return rc;
}
20408c8: 81 c7 e0 08 ret
20408cc: 81 e8 00 00 restore
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
20408d0: 7f ff cf 81 call 20346d4 <msdos_set_first_cluster_num>
20408d4: 92 10 00 1b mov %i3, %o1
if (rc != RC_OK)
20408d8: b0 92 20 00 orcc %o0, 0, %i0
20408dc: 22 bf ff e7 be,a 2040878 <msdos_file_close+0x5c> <== ALWAYS TAKEN
20408e0: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
20408e4: 30 bf ff f0 b,a 20408a4 <msdos_file_close+0x88> <== NOT EXECUTED
02040d5c <msdos_file_datasync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
2040d5c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040d60: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040d64: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040d68: fa 00 60 20 ld [ %g1 + 0x20 ], %i5 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040d6c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2040d70: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
2040d74: 7f ff 30 f2 call 200d13c <rtems_semaphore_obtain> <== NOT EXECUTED
2040d78: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040d7c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2040d80: 22 80 00 08 be,a 2040da0 <msdos_file_datasync+0x44> <== NOT EXECUTED
2040d84: d0 06 20 34 ld [ %i0 + 0x34 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
2040d88: 40 00 03 c6 call 2041ca0 <__errno> <== NOT EXECUTED
2040d8c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040d90: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040d94: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040d98: 81 c7 e0 08 ret <== NOT EXECUTED
2040d9c: 81 e8 00 00 restore <== NOT EXECUTED
/* synchronize file data */
fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
2040da0: 7f ff 92 d7 call 20258fc <fat_file_datasync> <== NOT EXECUTED
2040da4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
2040da8: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
2040dac: 7f ff 31 2e call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040db0: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
}
2040db4: 81 c7 e0 08 ret <== NOT EXECUTED
2040db8: 81 e8 00 00 restore <== NOT EXECUTED
02040b98 <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)
{
2040b98: 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;
2040b9c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040ba0: f8 06 20 24 ld [ %i0 + 0x24 ], %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;
2040ba4: f6 00 60 20 ld [ %g1 + 0x20 ], %i3
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
2040ba8: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
2040bac: 82 10 20 00 clr %g1
2040bb0: 80 a0 40 19 cmp %g1, %i1
2040bb4: 14 80 00 07 bg 2040bd0 <msdos_file_ftruncate+0x38> <== NEVER TAKEN
2040bb8: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
2040bbc: 80 a0 40 19 cmp %g1, %i1
2040bc0: 12 80 00 26 bne 2040c58 <msdos_file_ftruncate+0xc0> <== NEVER TAKEN
2040bc4: 80 a0 80 1a cmp %g2, %i2
2040bc8: 08 80 00 24 bleu 2040c58 <msdos_file_ftruncate+0xc0>
2040bcc: 01 00 00 00 nop
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040bd0: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0
2040bd4: 92 10 20 00 clr %o1
2040bd8: 7f ff 31 59 call 200d13c <rtems_semaphore_obtain>
2040bdc: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040be0: 80 a2 20 00 cmp %o0, 0
2040be4: 22 80 00 08 be,a 2040c04 <msdos_file_ftruncate+0x6c> <== ALWAYS TAKEN
2040be8: d0 07 60 34 ld [ %i5 + 0x34 ], %o0
rtems_set_errno_and_return_minus_one(EIO);
2040bec: 40 00 04 2d call 2041ca0 <__errno> <== NOT EXECUTED
2040bf0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040bf4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040bf8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040bfc: 81 c7 e0 08 ret <== NOT EXECUTED
2040c00: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
2040c04: 92 10 00 1c mov %i4, %o1
2040c08: 7f ff 91 84 call 2025218 <fat_file_truncate>
2040c0c: 94 10 00 1a mov %i2, %o2
if (rc != RC_OK)
2040c10: b0 92 20 00 orcc %o0, 0, %i0
2040c14: 12 80 00 0d bne 2040c48 <msdos_file_ftruncate+0xb0> <== NEVER TAKEN
2040c18: 01 00 00 00 nop
/*
* fat_file_truncate do nothing if new length >= fat-file size, so update
* file size only if length < fat-file size
*/
if (length < fat_fd->fat_file_size)
2040c1c: 80 a6 00 19 cmp %i0, %i1
2040c20: 14 80 00 07 bg 2040c3c <msdos_file_ftruncate+0xa4> <== NEVER TAKEN
2040c24: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
2040c28: 80 a6 00 19 cmp %i0, %i1
2040c2c: 12 80 00 07 bne 2040c48 <msdos_file_ftruncate+0xb0> <== NEVER TAKEN
2040c30: 80 a0 40 1a cmp %g1, %i2
2040c34: 08 80 00 05 bleu 2040c48 <msdos_file_ftruncate+0xb0> <== NEVER TAKEN
2040c38: 01 00 00 00 nop
iop->size = fat_fd->fat_file_size = length;
2040c3c: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
2040c40: c0 27 60 08 clr [ %i5 + 8 ]
2040c44: f4 27 60 0c st %i2, [ %i5 + 0xc ]
rtems_semaphore_release(fs_info->vol_sema);
2040c48: 7f ff 31 87 call 200d264 <rtems_semaphore_release>
2040c4c: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0
return RC_OK;
2040c50: 81 c7 e0 08 ret
2040c54: 81 e8 00 00 restore
}
2040c58: 81 c7 e0 08 ret
2040c5c: 91 e8 20 00 restore %g0, 0, %o0
02040a20 <msdos_file_lseek>:
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
off_t
msdos_file_lseek(rtems_libio_t *iop, off_t offset, int whence)
{
2040a20: 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;
2040a24: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
2040a28: c0 27 bf fc clr [ %fp + -4 ]
off_t
msdos_file_lseek(rtems_libio_t *iop, off_t offset, int whence)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040a2c: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
if (iop->offset < 0 || iop->offset > UINT32_MAX) {
2040a30: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
2040a34: 80 a0 60 00 cmp %g1, 0
2040a38: 12 80 00 0a bne 2040a60 <msdos_file_lseek+0x40>
2040a3c: fa 06 20 24 ld [ %i0 + 0x24 ], %i5
rtems_set_errno_and_return_minus_one(EINVAL);
}
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040a40: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
2040a44: 92 10 20 00 clr %o1
2040a48: 7f ff 31 bd call 200d13c <rtems_semaphore_obtain>
2040a4c: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040a50: 80 a2 20 00 cmp %o0, 0
2040a54: 22 80 00 0e be,a 2040a8c <msdos_file_lseek+0x6c> <== ALWAYS TAKEN
2040a58: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
2040a5c: 30 80 00 05 b,a 2040a70 <msdos_file_lseek+0x50> <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
if (iop->offset < 0 || iop->offset > UINT32_MAX) {
rtems_set_errno_and_return_minus_one(EINVAL);
2040a60: 40 00 04 90 call 2041ca0 <__errno>
2040a64: 31 3f ff ff sethi %hi(0xfffffc00), %i0
2040a68: 10 80 00 05 b 2040a7c <msdos_file_lseek+0x5c>
2040a6c: 82 10 20 16 mov 0x16, %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);
2040a70: 40 00 04 8c call 2041ca0 <__errno> <== NOT EXECUTED
2040a74: 31 3f ff ff sethi %hi(0xfffffc00), %i0 <== NOT EXECUTED
2040a78: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040a7c: c2 22 00 00 st %g1, [ %o0 ]
2040a80: b0 16 23 ff or %i0, 0x3ff, %i0
2040a84: 81 c7 e0 08 ret
2040a88: 93 e8 00 18 restore %g0, %i0, %o1
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
2040a8c: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
2040a90: 92 10 00 1d mov %i5, %o1
2040a94: 7f ff 92 88 call 20254b4 <fat_file_extend>
2040a98: 96 07 bf fc add %fp, -4, %o3
&real_size);
if (rc != RC_OK)
2040a9c: b6 92 20 00 orcc %o0, 0, %i3
2040aa0: 02 80 00 07 be 2040abc <msdos_file_lseek+0x9c> <== ALWAYS TAKEN
2040aa4: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
{
rtems_semaphore_release(fs_info->vol_sema);
2040aa8: 7f ff 31 ef call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040aac: b2 10 00 1b mov %i3, %i1 <== NOT EXECUTED
return rc;
2040ab0: b1 3e e0 1f sra %i3, 0x1f, %i0 <== NOT EXECUTED
2040ab4: 81 c7 e0 08 ret <== NOT EXECUTED
2040ab8: 81 e8 00 00 restore <== NOT EXECUTED
}
if (real_size > fat_fd->fat_file_size)
2040abc: c2 07 bf fc ld [ %fp + -4 ], %g1
2040ac0: c4 07 60 18 ld [ %i5 + 0x18 ], %g2
2040ac4: 80 a0 40 02 cmp %g1, %g2
2040ac8: 28 80 00 06 bleu,a 2040ae0 <msdos_file_lseek+0xc0> <== ALWAYS TAKEN
2040acc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
fat_fd->fat_file_size = iop->offset = real_size;
2040ad0: c0 26 20 10 clr [ %i0 + 0x10 ] <== NOT EXECUTED
2040ad4: c2 26 20 14 st %g1, [ %i0 + 0x14 ] <== NOT EXECUTED
2040ad8: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
2040adc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
2040ae0: c0 26 20 08 clr [ %i0 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
2040ae4: 7f ff 31 e0 call 200d264 <rtems_semaphore_release>
2040ae8: c2 26 20 0c st %g1, [ %i0 + 0xc ]
return iop->offset;
2040aec: f0 1e 20 10 ldd [ %i0 + 0x10 ], %i0
}
2040af0: 81 c7 e0 08 ret
2040af4: 81 e8 00 00 restore
02040784 <msdos_file_open>:
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, int oflag,
mode_t mode)
{
2040784: 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;
2040788: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
204078c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
msdos_file_open(rtems_libio_t *iop, const char *pathname, int oflag,
mode_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040790: f6 00 60 20 ld [ %g1 + 0x20 ], %i3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040794: 92 10 20 00 clr %o1
2040798: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0
204079c: 94 10 20 00 clr %o2
20407a0: 7f ff 32 67 call 200d13c <rtems_semaphore_obtain>
20407a4: ba 10 00 18 mov %i0, %i5
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20407a8: 80 a2 20 00 cmp %o0, 0
20407ac: 02 80 00 08 be 20407cc <msdos_file_open+0x48> <== ALWAYS TAKEN
20407b0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
20407b4: 40 00 05 3b call 2041ca0 <__errno> <== NOT EXECUTED
20407b8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
20407bc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20407c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20407c4: 81 c7 e0 08 ret <== NOT EXECUTED
20407c8: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
20407cc: 7f ff 92 1f call 2025048 <fat_file_reopen>
20407d0: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
20407d4: b0 92 20 00 orcc %o0, 0, %i0
20407d8: 02 80 00 06 be 20407f0 <msdos_file_open+0x6c> <== ALWAYS TAKEN
20407dc: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0
{
rtems_semaphore_release(fs_info->vol_sema);
20407e0: 7f ff 32 a1 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
20407e4: 01 00 00 00 nop <== NOT EXECUTED
return rc;
20407e8: 81 c7 e0 08 ret <== NOT EXECUTED
20407ec: 81 e8 00 00 restore <== NOT EXECUTED
}
if (iop->flags & LIBIO_FLAGS_APPEND)
20407f0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
20407f4: 80 88 62 00 btst 0x200, %g1
20407f8: 02 80 00 04 be 2040808 <msdos_file_open+0x84>
20407fc: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
iop->offset = fat_fd->fat_file_size;
2040800: c0 27 60 10 clr [ %i5 + 0x10 ]
2040804: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
iop->size = fat_fd->fat_file_size;
2040808: c0 27 60 08 clr [ %i5 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
204080c: 7f ff 32 96 call 200d264 <rtems_semaphore_release>
2040810: c2 27 60 0c st %g1, [ %i5 + 0xc ]
return RC_OK;
}
2040814: 81 c7 e0 08 ret
2040818: 81 e8 00 00 restore
020408e8 <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)
{
20408e8: 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;
20408ec: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
20408f0: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
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;
20408f4: fa 00 60 20 ld [ %g1 + 0x20 ], %i5
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
20408f8: 92 10 20 00 clr %o1
20408fc: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2040900: 7f ff 32 0f call 200d13c <rtems_semaphore_obtain>
2040904: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040908: 80 a2 20 00 cmp %o0, 0
204090c: 22 80 00 08 be,a 204092c <msdos_file_read+0x44> <== ALWAYS TAKEN
2040910: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
rtems_set_errno_and_return_minus_one(EIO);
2040914: 40 00 04 e3 call 2041ca0 <__errno> <== NOT EXECUTED
2040918: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
204091c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040920: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040924: 81 c7 e0 08 ret <== NOT EXECUTED
2040928: 81 e8 00 00 restore <== NOT EXECUTED
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
204092c: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
2040930: 92 10 00 1c mov %i4, %o1
2040934: 96 10 00 1a mov %i2, %o3
2040938: 7f ff 91 c9 call 202505c <fat_file_read>
204093c: 98 10 00 19 mov %i1, %o4
2040940: b0 10 00 08 mov %o0, %i0
buffer);
rtems_semaphore_release(fs_info->vol_sema);
2040944: 7f ff 32 48 call 200d264 <rtems_semaphore_release>
2040948: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
return ret;
}
204094c: 81 c7 e0 08 ret
2040950: 81 e8 00 00 restore
02040af8 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
2040af8: 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;
2040afc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
2040b00: 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;
2040b04: fa 00 60 20 ld [ %g1 + 0x20 ], %i5
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040b08: 92 10 20 00 clr %o1
2040b0c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2040b10: 7f ff 31 8b call 200d13c <rtems_semaphore_obtain>
2040b14: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040b18: 80 a2 20 00 cmp %o0, 0
2040b1c: 22 80 00 08 be,a 2040b3c <msdos_file_stat+0x44> <== ALWAYS TAKEN
2040b20: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
2040b24: 40 00 04 5f call 2041ca0 <__errno> <== NOT EXECUTED
2040b28: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040b2c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040b30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040b34: 81 c7 e0 08 ret <== NOT EXECUTED
2040b38: 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);
2040b3c: 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);
2040b40: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
2040b44: 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);
2040b48: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
2040b4c: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
2040b50: 03 00 00 20 sethi %hi(0x8000), %g1
2040b54: 82 10 61 ff or %g1, 0x1ff, %g1 ! 81ff <PROM_START+0x81ff>
2040b58: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
2040b5c: 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;
2040b60: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
2040b64: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
2040b68: 83 30 60 09 srl %g1, 9, %g1
2040b6c: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
2040b70: 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;
2040b74: 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;
2040b78: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
2040b7c: 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;
2040b80: 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;
2040b84: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
2040b88: 7f ff 31 b7 call 200d264 <rtems_semaphore_release>
2040b8c: b0 10 20 00 clr %i0
return RC_OK;
}
2040b90: 81 c7 e0 08 ret
2040b94: 81 e8 00 00 restore
02040c60 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
2040c60: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040c64: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
int
msdos_file_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040c68: f6 06 20 24 ld [ %i0 + 0x24 ], %i3 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040c6c: fa 00 60 20 ld [ %g1 + 0x20 ], %i5 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040c70: 92 10 20 00 clr %o1 <== NOT EXECUTED
2040c74: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
2040c78: 94 10 20 00 clr %o2 <== NOT EXECUTED
2040c7c: 7f ff 31 30 call 200d13c <rtems_semaphore_obtain> <== NOT EXECUTED
2040c80: b8 10 00 18 mov %i0, %i4 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040c84: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2040c88: 22 80 00 08 be,a 2040ca8 <msdos_file_sync+0x48> <== NOT EXECUTED
2040c8c: d0 06 20 34 ld [ %i0 + 0x34 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
2040c90: 40 00 04 04 call 2041ca0 <__errno> <== NOT EXECUTED
2040c94: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040c98: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040c9c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040ca0: 81 c7 e0 08 ret <== NOT EXECUTED
2040ca4: 81 e8 00 00 restore <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
2040ca8: 7f ff 93 15 call 20258fc <fat_file_datasync> <== NOT EXECUTED
2040cac: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
if (rc != RC_OK)
2040cb0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2040cb4: 22 80 00 06 be,a 2040ccc <msdos_file_sync+0x6c> <== NOT EXECUTED
2040cb8: c2 0e e0 30 ldub [ %i3 + 0x30 ], %g1 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
2040cbc: 7f ff 31 6a call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040cc0: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
return rc;
2040cc4: 81 c7 e0 08 ret <== NOT EXECUTED
2040cc8: 81 e8 00 00 restore <== NOT EXECUTED
/*
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
2040ccc: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2040cd0: 12 80 00 18 bne 2040d30 <msdos_file_sync+0xd0> <== NOT EXECUTED
2040cd4: 01 00 00 00 nop <== NOT EXECUTED
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
2040cd8: 10 80 00 1a b 2040d40 <msdos_file_sync+0xe0> <== NOT EXECUTED
2040cdc: d0 07 20 34 ld [ %i4 + 0x34 ], %o0 <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
2040ce0: 7f ff ce ac call 2034790 <msdos_set_file_size> <== NOT EXECUTED
2040ce4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
if (rc != RC_OK)
2040ce8: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2040cec: 22 80 00 07 be,a 2040d08 <msdos_file_sync+0xa8> <== NOT EXECUTED
2040cf0: d0 07 20 34 ld [ %i4 + 0x34 ], %o0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
2040cf4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
2040cf8: 7f ff 31 5b call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040cfc: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
2040d00: 81 c7 e0 08 ret <== NOT EXECUTED
2040d04: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
2040d08: 7f ff ce 39 call 20345ec <msdos_set_dir_wrt_time_and_date><== NOT EXECUTED
2040d0c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
if (rc != RC_OK)
2040d10: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2040d14: 02 80 00 07 be 2040d30 <msdos_file_sync+0xd0> <== NOT EXECUTED
2040d18: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
2040d1c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
2040d20: 7f ff 31 51 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040d24: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
return rc;
2040d28: 81 c7 e0 08 ret <== NOT EXECUTED
2040d2c: 81 e8 00 00 restore <== NOT EXECUTED
}
}
rtems_semaphore_release(fs_info->vol_sema);
2040d30: 7f ff 31 4d call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2040d34: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
return RC_OK;
}
2040d38: 81 c7 e0 08 ret <== NOT EXECUTED
2040d3c: 81 e8 00 00 restore <== NOT EXECUTED
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
2040d40: 7f ff ce 65 call 20346d4 <msdos_set_first_cluster_num> <== NOT EXECUTED
2040d44: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
if (rc != RC_OK)
2040d48: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2040d4c: 22 bf ff e5 be,a 2040ce0 <msdos_file_sync+0x80> <== NOT EXECUTED
2040d50: d0 07 20 34 ld [ %i4 + 0x34 ], %o0 <== NOT EXECUTED
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
2040d54: 10 bf ff e9 b 2040cf8 <msdos_file_sync+0x98> <== NOT EXECUTED
2040d58: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
02040954 <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)
{
2040954: 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;
2040958: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
204095c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
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;
2040960: f6 00 60 20 ld [ %g1 + 0x20 ], %i3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040964: 92 10 20 00 clr %o1
2040968: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0
204096c: 94 10 20 00 clr %o2
2040970: 7f ff 31 f3 call 200d13c <rtems_semaphore_obtain>
2040974: ba 10 00 18 mov %i0, %i5
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040978: 80 a2 20 00 cmp %o0, 0
204097c: 22 80 00 08 be,a 204099c <msdos_file_write+0x48> <== ALWAYS TAKEN
2040980: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
rtems_set_errno_and_return_minus_one(EIO);
2040984: 40 00 04 c7 call 2041ca0 <__errno> <== NOT EXECUTED
2040988: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
204098c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040990: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040994: 81 c7 e0 08 ret <== NOT EXECUTED
2040998: 81 e8 00 00 restore <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
204099c: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
20409a0: 92 10 00 1c mov %i4, %o1
20409a4: 96 10 00 1a mov %i2, %o3
20409a8: 7f ff 93 3f call 20256a4 <fat_file_write>
20409ac: 98 10 00 19 mov %i1, %o4
buffer);
if (ret < 0)
20409b0: b0 92 20 00 orcc %o0, 0, %i0
20409b4: 36 80 00 06 bge,a 20409cc <msdos_file_write+0x78> <== ALWAYS TAKEN
20409b8: d8 1f 60 10 ldd [ %i5 + 0x10 ], %o4
{
rtems_semaphore_release(fs_info->vol_sema);
20409bc: 7f ff 32 2a call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
20409c0: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0 <== NOT EXECUTED
return -1;
20409c4: 81 c7 e0 08 ret <== NOT EXECUTED
20409c8: 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
*/
if (iop->offset + ret > fat_fd->fat_file_size)
20409cc: 85 3e 20 1f sra %i0, 0x1f, %g2
20409d0: 86 83 40 18 addcc %o5, %i0, %g3
20409d4: 84 43 00 02 addx %o4, %g2, %g2
20409d8: 80 a0 a0 00 cmp %g2, 0
20409dc: 14 80 00 08 bg 20409fc <msdos_file_write+0xa8> <== NEVER TAKEN
20409e0: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
20409e4: 80 a0 a0 00 cmp %g2, 0
20409e8: 32 80 00 09 bne,a 2040a0c <msdos_file_write+0xb8> <== NEVER TAKEN
20409ec: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0 <== NOT EXECUTED
20409f0: 80 a0 c0 01 cmp %g3, %g1
20409f4: 28 80 00 06 bleu,a 2040a0c <msdos_file_write+0xb8>
20409f8: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0
fat_fd->fat_file_size = iop->offset + ret;
20409fc: 82 06 00 0d add %i0, %o5, %g1
2040a00: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
iop->size = fat_fd->fat_file_size;
2040a04: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
rtems_semaphore_release(fs_info->vol_sema);
2040a08: d0 06 e0 90 ld [ %i3 + 0x90 ], %o0
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset + ret;
iop->size = fat_fd->fat_file_size;
2040a0c: c0 27 60 08 clr [ %i5 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
2040a10: 7f ff 32 15 call 200d264 <rtems_semaphore_release>
2040a14: c2 27 60 0c st %g1, [ %i5 + 0xc ]
return ret;
}
2040a18: 81 c7 e0 08 ret
2040a1c: 81 e8 00 00 restore
0203fe78 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
203fe78: 82 10 20 00 clr %g1
dn[i] = ' ';
203fe7c: 84 10 20 20 mov 0x20, %g2
203fe80: 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++)
203fe84: 82 00 60 01 inc %g1
203fe88: 80 a0 60 0b cmp %g1, 0xb
203fe8c: 32 bf ff fe bne,a 203fe84 <msdos_filename_unix2dos+0xc>
203fe90: 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) {
203fe94: c2 4a 00 00 ldsb [ %o0 ], %g1
203fe98: 82 18 60 2e xor %g1, 0x2e, %g1
203fe9c: 80 a0 00 01 cmp %g0, %g1
203fea0: 82 60 3f ff subx %g0, -1, %g1
203fea4: 80 a2 60 01 cmp %o1, 1
203fea8: 12 80 00 06 bne 203fec0 <msdos_filename_unix2dos+0x48>
203feac: 80 a0 60 00 cmp %g1, 0
203feb0: 02 80 00 04 be 203fec0 <msdos_filename_unix2dos+0x48> <== ALWAYS TAKEN
203feb4: 82 10 20 2e mov 0x2e, %g1
dn[0] = '.';
return 0;
203feb8: 10 80 00 53 b 2040004 <msdos_filename_unix2dos+0x18c> <== NOT EXECUTED
203febc: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
203fec0: 02 80 00 0e be 203fef8 <msdos_filename_unix2dos+0x80> <== ALWAYS TAKEN
203fec4: 80 a2 60 00 cmp %o1, 0
203fec8: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
203fecc: 12 80 00 0b bne 203fef8 <msdos_filename_unix2dos+0x80> <== NOT EXECUTED
203fed0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
203fed4: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
203fed8: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
203fedc: 12 80 00 07 bne 203fef8 <msdos_filename_unix2dos+0x80> <== NOT EXECUTED
203fee0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
dn[0] = '.';
203fee4: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
203fee8: 10 80 00 47 b 2040004 <msdos_filename_unix2dos+0x18c> <== NOT EXECUTED
203feec: 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--;
203fef0: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
203fef4: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
203fef8: 32 80 00 05 bne,a 203ff0c <msdos_filename_unix2dos+0x94> <== ALWAYS TAKEN
203fefc: 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++)
203ff00: 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)
203ff04: 10 80 00 0f b 203ff40 <msdos_filename_unix2dos+0xc8>
203ff08: 07 00 81 a5 sethi %hi(0x2069400), %g3
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
203ff0c: 80 a0 60 2e cmp %g1, 0x2e
203ff10: 22 bf ff f8 be,a 203fef0 <msdos_filename_unix2dos+0x78> <== NEVER TAKEN
203ff14: 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++)
203ff18: 10 bf ff fb b 203ff04 <msdos_filename_unix2dos+0x8c>
203ff1c: 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)
203ff20: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
203ff24: 80 88 a0 ff btst 0xff, %g2
203ff28: 02 80 00 1b be 203ff94 <msdos_filename_unix2dos+0x11c>
203ff2c: 80 a2 60 00 cmp %o1, 0
break;
dn[i] = msdos_map[c];
203ff30: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
un++;
203ff34: 90 02 20 01 inc %o0
unlen--;
203ff38: 92 02 7f ff add %o1, -1, %o1
* 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++) {
203ff3c: 82 00 60 01 inc %g1
203ff40: 80 a2 60 00 cmp %o1, 0
203ff44: 02 80 00 13 be 203ff90 <msdos_filename_unix2dos+0x118>
203ff48: 80 a0 60 07 cmp %g1, 7
203ff4c: 04 80 00 03 ble 203ff58 <msdos_filename_unix2dos+0xe0>
203ff50: 84 10 20 01 mov 1, %g2
203ff54: 84 10 20 00 clr %g2
203ff58: 80 88 a0 ff btst 0xff, %g2
203ff5c: 02 80 00 0e be 203ff94 <msdos_filename_unix2dos+0x11c>
203ff60: 80 a2 60 00 cmp %o1, 0
203ff64: c4 0a 00 00 ldub [ %o0 ], %g2
203ff68: 80 a0 a0 00 cmp %g2, 0
203ff6c: 02 80 00 09 be 203ff90 <msdos_filename_unix2dos+0x118> <== NEVER TAKEN
203ff70: 80 a0 a0 2e cmp %g2, 0x2e
203ff74: 12 bf ff eb bne 203ff20 <msdos_filename_unix2dos+0xa8>
203ff78: 88 10 e3 e8 or %g3, 0x3e8, %g4
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
203ff7c: 10 80 00 06 b 203ff94 <msdos_filename_unix2dos+0x11c>
203ff80: 80 a2 60 00 cmp %o1, 0
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
203ff84: 80 a0 60 2e cmp %g1, 0x2e
203ff88: 02 80 00 09 be 203ffac <msdos_filename_unix2dos+0x134>
203ff8c: 92 02 7f ff add %o1, -1, %o1
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
203ff90: 80 a2 60 00 cmp %o1, 0
203ff94: 02 80 00 07 be 203ffb0 <msdos_filename_unix2dos+0x138>
203ff98: 82 10 20 08 mov 8, %g1
203ff9c: c2 0a 00 00 ldub [ %o0 ], %g1
203ffa0: 80 a0 60 00 cmp %g1, 0
203ffa4: 32 bf ff f8 bne,a 203ff84 <msdos_filename_unix2dos+0x10c><== ALWAYS TAKEN
203ffa8: 90 02 20 01 inc %o0
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
203ffac: 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)
203ffb0: 10 80 00 08 b 203ffd0 <msdos_filename_unix2dos+0x158>
203ffb4: 07 00 81 a5 sethi %hi(0x2069400), %g3
203ffb8: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
203ffbc: 80 88 a0 ff btst 0xff, %g2
203ffc0: 02 80 00 11 be 2040004 <msdos_filename_unix2dos+0x18c> <== ALWAYS TAKEN
203ffc4: 92 02 7f ff add %o1, -1, %o1
break;
dn[i] = msdos_map[c];
203ffc8: c4 2a 80 01 stb %g2, [ %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++) {
203ffcc: 82 00 60 01 inc %g1 <== NOT EXECUTED
203ffd0: 80 a2 60 00 cmp %o1, 0
203ffd4: 02 80 00 0c be 2040004 <msdos_filename_unix2dos+0x18c>
203ffd8: 80 a0 60 0a cmp %g1, 0xa
203ffdc: 04 80 00 03 ble 203ffe8 <msdos_filename_unix2dos+0x170> <== ALWAYS TAKEN
203ffe0: 84 10 20 01 mov 1, %g2
203ffe4: 84 10 20 00 clr %g2 <== NOT EXECUTED
203ffe8: 80 88 a0 ff btst 0xff, %g2
203ffec: 02 80 00 06 be 2040004 <msdos_filename_unix2dos+0x18c> <== NEVER TAKEN
203fff0: 84 02 00 01 add %o0, %g1, %g2
203fff4: c4 08 bf f8 ldub [ %g2 + -8 ], %g2
203fff8: 80 a0 a0 00 cmp %g2, 0
203fffc: 12 bf ff ef bne 203ffb8 <msdos_filename_unix2dos+0x140> <== ALWAYS TAKEN
2040000: 88 10 e3 e8 or %g3, 0x3e8, %g4
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
2040004: 81 c3 e0 08 retl
2040008: 90 10 20 00 clr %o0
02035900 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
2035900: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
2035904: c2 06 20 18 ld [ %i0 + 0x18 ], %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);
2035908: b8 07 bf c8 add %fp, -56, %i4
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
203590c: f6 00 60 20 ld [ %g1 + 0x20 ], %i3
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);
2035910: 92 10 20 00 clr %o1
2035914: 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;
2035918: c0 27 bf fc clr [ %fp + -4 ]
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);
203591c: 40 00 3e ae call 20453d4 <memset>
2035920: 90 10 00 1c mov %i4, %o0
name_type = msdos_long_to_short (name,
2035924: 92 10 00 1a mov %i2, %o1
2035928: 94 10 00 1c mov %i4, %o2
203592c: 96 10 20 0b mov 0xb, %o3
2035930: 7f ff fa 97 call 203438c <msdos_long_to_short>
2035934: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
2035938: ba 10 00 18 mov %i0, %i5
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,
203593c: 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,
2035940: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2035944: 90 10 00 18 mov %i0, %o0
2035948: 92 10 20 00 clr %o1
203594c: 94 10 00 19 mov %i1, %o2
2035950: 96 10 00 1a mov %i2, %o3
2035954: 7f ff ff ab call 2035800 <msdos_get_name_node>
2035958: 9a 07 bf ec add %fp, -20, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
203595c: b0 92 20 00 orcc %o0, 0, %i0
2035960: 12 80 00 68 bne 2035b00 <msdos_find_name+0x200>
2035964: 01 00 00 00 nop
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
2035968: c2 0f 20 0b ldub [ %i4 + 0xb ], %g1
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
203596c: 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) ||
2035970: 80 88 60 08 btst 8, %g1
2035974: 12 80 00 60 bne 2035af4 <msdos_find_name+0x1f4> <== NEVER TAKEN
2035978: b0 16 21 01 or %i0, 0x101, %i0
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
203597c: 82 08 60 3f and %g1, 0x3f, %g1
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) ||
2035980: 80 a0 60 0f cmp %g1, 0xf
2035984: 02 80 00 5c be 2035af4 <msdos_find_name+0x1f4> <== NEVER TAKEN
2035988: 92 07 bf ec add %fp, -20, %o1
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
203598c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
2035990: 7f ff bd 5b call 2024efc <fat_file_open>
2035994: 94 07 bf fc add %fp, -4, %o2
if (rc != RC_OK)
2035998: b0 92 20 00 orcc %o0, 0, %i0
203599c: 12 80 00 56 bne 2035af4 <msdos_find_name+0x1f4> <== NEVER TAKEN
20359a0: f4 07 bf fc ld [ %fp + -4 ], %i2
return rc;
fat_fd->dir_pos = dir_pos;
20359a4: 92 07 bf ec add %fp, -20, %o1
20359a8: 90 06 a0 20 add %i2, 0x20, %o0
20359ac: 40 00 3d fe call 20451a4 <memcpy>
20359b0: 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)
20359b4: c2 06 a0 08 ld [ %i2 + 8 ], %g1
20359b8: 80 a0 60 01 cmp %g1, 1
20359bc: 32 80 00 46 bne,a 2035ad4 <msdos_find_name+0x1d4>
20359c0: d2 07 60 08 ld [ %i5 + 8 ], %o1
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
20359c4: c4 17 20 14 lduh [ %i4 + 0x14 ], %g2
20359c8: c2 17 20 1a lduh [ %i4 + 0x1a ], %g1
20359cc: 85 28 a0 10 sll %g2, 0x10, %g2
20359d0: 89 30 a0 18 srl %g2, 0x18, %g4
20359d4: 87 30 a0 08 srl %g2, 8, %g3
20359d8: 83 28 60 10 sll %g1, 0x10, %g1
20359dc: 05 00 00 3f sethi %hi(0xfc00), %g2
20359e0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
20359e4: 86 08 c0 02 and %g3, %g2, %g3
20359e8: 86 11 00 03 or %g4, %g3, %g3
20359ec: 89 30 60 18 srl %g1, 0x18, %g4
20359f0: 87 28 e0 10 sll %g3, 0x10, %g3
20359f4: 83 30 60 08 srl %g1, 8, %g1
20359f8: 82 08 40 02 and %g1, %g2, %g1
20359fc: 82 11 00 01 or %g4, %g1, %g1
2035a00: 82 10 c0 01 or %g3, %g1, %g1
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
2035a04: c6 17 20 18 lduh [ %i4 + 0x18 ], %g3
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
2035a08: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
2035a0c: c2 17 20 16 lduh [ %i4 + 0x16 ], %g1
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
2035a10: 87 28 e0 10 sll %g3, 0x10, %g3
2035a14: 83 28 60 10 sll %g1, 0x10, %g1
2035a18: 91 30 e0 18 srl %g3, 0x18, %o0
2035a1c: 93 30 60 18 srl %g1, 0x18, %o1
2035a20: 87 30 e0 08 srl %g3, 8, %g3
2035a24: 83 30 60 08 srl %g1, 8, %g1
2035a28: 86 08 c0 02 and %g3, %g2, %g3
2035a2c: 82 08 40 02 and %g1, %g2, %g1
2035a30: 90 12 00 03 or %o0, %g3, %o0
2035a34: 40 00 28 c9 call 203fd58 <msdos_date_dos2unix>
2035a38: 92 12 40 01 or %o1, %g1, %o1
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2035a3c: c2 0f 20 0b ldub [ %i4 + 0xb ], %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));
2035a40: d0 26 a0 40 st %o0, [ %i2 + 0x40 ]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2035a44: 80 88 60 10 btst 0x10, %g1
2035a48: 02 80 00 0e be 2035a80 <msdos_find_name+0x180>
2035a4c: f4 07 bf fc ld [ %fp + -4 ], %i2
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
2035a50: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2035a54: 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;
2035a58: c0 26 a0 10 clr [ %i2 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2035a5c: c2 26 a0 14 st %g1, [ %i2 + 0x14 ]
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
2035a60: 7f ff bf e3 call 20259ec <fat_file_size>
2035a64: 92 10 00 1a mov %i2, %o1
if (rc != RC_OK)
2035a68: b0 92 20 00 orcc %o0, 0, %i0
2035a6c: 02 80 00 0d be 2035aa0 <msdos_find_name+0x1a0> <== ALWAYS TAKEN
2035a70: c2 07 bf fc ld [ %fp + -4 ], %g1
{
fat_file_close(parent_loc->mt_entry, fat_fd);
2035a74: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
2035a78: 10 80 00 1d b 2035aec <msdos_find_name+0x1ec> <== NOT EXECUTED
2035a7c: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
2035a80: 7f ff fa 28 call 2034320 <CPU_swap_u32>
2035a84: d0 07 20 1c ld [ %i4 + 0x1c ], %o0
fat_fd->fat_file_type = FAT_FILE;
2035a88: 82 10 20 04 mov 4, %g1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
2035a8c: d0 26 a0 18 st %o0, [ %i2 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
2035a90: c2 26 a0 10 st %g1, [ %i2 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
2035a94: 82 10 3f ff mov -1, %g1
2035a98: c2 26 a0 14 st %g1, [ %i2 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
2035a9c: c2 07 bf fc ld [ %fp + -4 ], %g1
fat_fd->map.disk_cln = fat_fd->cln;
2035aa0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
if ((fat_fd->fat_file_size != 0) &&
2035aa4: 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;
2035aa8: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
2035aac: 80 a0 e0 00 cmp %g3, 0
2035ab0: 02 80 00 06 be 2035ac8 <msdos_find_name+0x1c8>
2035ab4: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
2035ab8: c8 16 e0 06 lduh [ %i3 + 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) &&
2035abc: 80 a0 c0 04 cmp %g3, %g4
2035ac0: 28 80 00 04 bleu,a 2035ad0 <msdos_find_name+0x1d0> <== ALWAYS TAKEN
2035ac4: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2035ac8: 84 10 3f ff mov -1, %g2
2035acc: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
2035ad0: d2 07 60 08 ld [ %i5 + 8 ], %o1
2035ad4: 7f ff be 15 call 2025328 <fat_file_close>
2035ad8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
if (rc != RC_OK)
2035adc: b0 92 20 00 orcc %o0, 0, %i0
2035ae0: 02 80 00 07 be 2035afc <msdos_find_name+0x1fc> <== ALWAYS TAKEN
2035ae4: d2 07 bf fc ld [ %fp + -4 ], %o1
{
fat_file_close(parent_loc->mt_entry, fat_fd);
2035ae8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
2035aec: 7f ff be 0f call 2025328 <fat_file_close> <== NOT EXECUTED
2035af0: 01 00 00 00 nop <== NOT EXECUTED
return rc;
2035af4: 81 c7 e0 08 ret <== NOT EXECUTED
2035af8: 81 e8 00 00 restore <== NOT EXECUTED
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
2035afc: d2 27 60 08 st %o1, [ %i5 + 8 ]
return rc;
}
2035b00: 81 c7 e0 08 ret
2035b04: 81 e8 00 00 restore
02034a48 <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
)
{
2034a48: 9d e3 bf 68 save %sp, -152, %sp
2034a4c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2034a50: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2034a54: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
2034a58: 82 10 00 1a mov %i2, %g1
2034a5c: a0 10 00 18 mov %i0, %l0
2034a60: f6 07 a0 5c ld [ %fp + 0x5c ], %i3
2034a64: f4 07 a0 60 ld [ %fp + 0x60 ], %i2
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
2034a68: 80 a7 20 00 cmp %i4, 0
2034a6c: 14 80 00 0a bg 2034a94 <msdos_find_name_in_fat_file+0x4c> <== ALWAYS TAKEN
2034a70: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
2034a74: 11 00 81 9a sethi %hi(0x2066800), %o0 <== NOT EXECUTED
2034a78: 15 00 81 9b sethi %hi(0x2066c00), %o2 <== NOT EXECUTED
2034a7c: 17 00 81 9b sethi %hi(0x2066c00), %o3 <== NOT EXECUTED
2034a80: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
2034a84: 92 10 23 c6 mov 0x3c6, %o1 <== NOT EXECUTED
2034a88: 94 12 a0 68 or %o2, 0x68, %o2 <== NOT EXECUTED
2034a8c: 10 80 00 45 b 2034ba0 <msdos_find_name_in_fat_file+0x158> <== NOT EXECUTED
2034a90: 96 12 e0 28 or %o3, 0x28, %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;
2034a94: 84 10 3f ff mov -1, %g2
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
2034a98: c0 26 c0 00 clr [ %i3 ]
dir_pos->sname.ofs = 0;
2034a9c: c0 26 e0 04 clr [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2034aa0: c4 26 e0 08 st %g2, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2034aa4: c4 26 e0 0c st %g2, [ %i3 + 0xc ]
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2034aa8: c4 27 bf f8 st %g2, [ %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))
2034aac: 80 a0 60 00 cmp %g1, 0
2034ab0: 02 80 00 06 be 2034ac8 <msdos_find_name_in_fat_file+0x80>
2034ab4: c4 27 bf f4 st %g2, [ %fp + -12 ]
2034ab8: c4 07 a0 58 ld [ %fp + 0x58 ], %g2
2034abc: 80 a0 a0 01 cmp %g2, 1
2034ac0: 02 80 00 09 be 2034ae4 <msdos_find_name_in_fat_file+0x9c>
2034ac4: b8 10 20 00 clr %i4
lfn_entries = 0;
else
lfn_entries =
2034ac8: c8 07 a0 54 ld [ %fp + 0x54 ], %g4
2034acc: c2 27 bf d4 st %g1, [ %fp + -44 ]
2034ad0: 90 01 20 0c add %g4, 0xc, %o0
2034ad4: 40 00 9a 61 call 205b458 <.div>
2034ad8: 92 10 20 0d mov 0xd, %o1
2034adc: c2 07 bf d4 ld [ %fp + -44 ], %g1
2034ae0: b8 10 00 08 mov %o0, %i4
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
2034ae4: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2034ae8: 80 a0 a0 01 cmp %g2, 1
2034aec: 32 80 00 0b bne,a 2034b18 <msdos_find_name_in_fat_file+0xd0>
2034af0: fa 14 60 06 lduh [ %l1 + 6 ], %i5
2034af4: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
2034af8: 80 a0 a0 00 cmp %g2, 0
2034afc: 32 80 00 07 bne,a 2034b18 <msdos_find_name_in_fat_file+0xd0><== NEVER TAKEN
2034b00: fa 14 60 06 lduh [ %l1 + 6 ], %i5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2034b04: c4 0c 60 0a ldub [ %l1 + 0xa ], %g2
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) &&
2034b08: 80 88 a0 03 btst 3, %g2
2034b0c: 22 80 00 03 be,a 2034b18 <msdos_find_name_in_fat_file+0xd0><== NEVER TAKEN
2034b10: fa 14 60 06 lduh [ %l1 + 6 ], %i5 <== NOT EXECUTED
2034b14: fa 06 60 18 ld [ %i1 + 0x18 ], %i5
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;
2034b18: a6 10 20 00 clr %l3
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
2034b1c: 88 10 20 00 clr %g4
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;
2034b20: 9a 10 20 00 clr %o5
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;
2034b24: 84 10 20 00 clr %g2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2034b28: 96 07 20 01 add %i4, 1, %o3
2034b2c: e6 27 bf e0 st %l3, [ %fp + -32 ]
2034b30: ac 10 00 10 mov %l0, %l6
2034b34: a4 10 00 19 mov %i1, %l2
2034b38: f6 27 bf dc st %i3, [ %fp + -36 ]
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;
2034b3c: c0 2f bf e8 clrb [ %fp + -24 ]
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;
2034b40: aa 10 20 00 clr %l5
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;
2034b44: a8 10 20 00 clr %l4
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;
2034b48: b0 10 20 00 clr %i0
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
2034b4c: ae 10 20 00 clr %l7
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
2034b50: 86 10 3f ff mov -1, %g3
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2034b54: d6 27 bf d8 st %o3, [ %fp + -40 ]
2034b58: a0 10 00 04 mov %g4, %l0
2034b5c: b2 10 00 0d mov %o5, %i1
2034b60: a6 10 00 01 mov %g1, %l3
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
2034b64: 10 80 00 f1 b 2034f28 <msdos_find_name_in_fat_file+0x4e0>
2034b68: b6 10 00 02 mov %g2, %i3
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)
2034b6c: 80 a2 20 1f cmp %o0, 0x1f
2034b70: 04 80 02 00 ble 2035370 <msdos_find_name_in_fat_file+0x928><== NEVER TAKEN
2034b74: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
2034b78: 80 a2 00 1d cmp %o0, %i5
2034b7c: 02 80 00 0b be 2034ba8 <msdos_find_name_in_fat_file+0x160><== ALWAYS TAKEN
2034b80: 84 10 20 00 clr %g2
2034b84: 11 00 81 9a sethi %hi(0x2066800), %o0 <== NOT EXECUTED
2034b88: 15 00 81 9b sethi %hi(0x2066c00), %o2 <== NOT EXECUTED
2034b8c: 17 00 81 9b sethi %hi(0x2066c00), %o3 <== NOT EXECUTED
2034b90: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
2034b94: 92 10 23 f6 mov 0x3f6, %o1 <== NOT EXECUTED
2034b98: 94 12 a0 68 or %o2, 0x68, %o2 <== NOT EXECUTED
2034b9c: 96 12 e0 38 or %o3, 0x38, %o3 <== NOT EXECUTED
2034ba0: 7f ff c9 bd call 2027294 <__assert_func> <== NOT EXECUTED
2034ba4: 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;
2034ba8: c8 04 60 94 ld [ %l1 + 0x94 ], %g4
* 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)
2034bac: 80 a5 60 00 cmp %l5, 0
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
2034bb0: 82 01 00 02 add %g4, %g2, %g1
* 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)
2034bb4: 12 80 00 04 bne 2034bc4 <msdos_find_name_in_fat_file+0x17c>
2034bb8: c8 09 00 02 ldub [ %g4 + %g2 ], %g4
2034bbc: a8 10 00 02 mov %g2, %l4
2034bc0: ee 27 bf e0 st %l7, [ %fp + -32 ]
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
2034bc4: 9e 89 20 ff andcc %g4, 0xff, %o7
2034bc8: 12 80 00 14 bne 2034c18 <msdos_find_name_in_fat_file+0x1d0>
2034bcc: 80 a3 e0 e5 cmp %o7, 0xe5
2034bd0: 82 10 00 13 mov %l3, %g1
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
2034bd4: 31 00 00 1f sethi %hi(0x7c00), %i0
2034bd8: a0 10 00 16 mov %l6, %l0
2034bdc: b2 10 00 12 mov %l2, %i1
2034be0: e6 07 bf e0 ld [ %fp + -32 ], %l3
2034be4: f6 07 bf dc ld [ %fp + -36 ], %i3
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
2034be8: 80 a0 60 00 cmp %g1, 0
2034bec: 02 80 00 c3 be 2034ef8 <msdos_find_name_in_fat_file+0x4b0>
2034bf0: b0 16 21 01 or %i0, 0x101, %i0
* 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)
2034bf4: c2 0f bf e8 ldub [ %fp + -24 ], %g1
2034bf8: 80 88 60 ff btst 0xff, %g1
2034bfc: 32 80 00 df bne,a 2034f78 <msdos_find_name_in_fat_file+0x530>
2034c00: c4 07 a0 58 ld [ %fp + 0x58 ], %g2
(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;
2034c04: 83 37 60 05 srl %i5, 5, %g1
* 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);
2034c08: a5 30 a0 05 srl %g2, 5, %l2
2034c0c: aa 05 40 01 add %l5, %g1, %l5
* 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 +=
2034c10: 10 80 00 d9 b 2034f74 <msdos_find_name_in_fat_file+0x52c>
2034c14: aa 25 40 12 sub %l5, %l2, %l5
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
2034c18: 12 80 00 0b bne 2034c44 <msdos_find_name_in_fat_file+0x1fc>
2034c1c: 80 a4 e0 00 cmp %l3, 0
{
if (create_node)
2034c20: 22 80 00 bd be,a 2034f14 <msdos_find_name_in_fat_file+0x4cc>
2034c24: 84 00 a0 20 add %g2, 0x20, %g2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2034c28: c8 07 bf d8 ld [ %fp + -40 ], %g4
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
2034c2c: aa 05 60 01 inc %l5
if (empty_space_count == (lfn_entries + 1))
2034c30: 80 a5 40 04 cmp %l5, %g4
2034c34: 32 80 00 b8 bne,a 2034f14 <msdos_find_name_in_fat_file+0x4cc>
2034c38: 84 00 a0 20 add %g2, 0x20, %g2
empty_space_found = true;
2034c3c: 10 80 00 b4 b 2034f0c <msdos_find_name_in_fat_file+0x4c4>
2034c40: 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)
2034c44: 02 80 00 08 be 2034c64 <msdos_find_name_in_fat_file+0x21c>
2034c48: de 08 60 0b ldub [ %g1 + 0xb ], %o7
2034c4c: d6 0f bf e8 ldub [ %fp + -24 ], %o3
2034c50: 80 8a e0 ff btst 0xff, %o3
2034c54: 12 80 00 04 bne 2034c64 <msdos_find_name_in_fat_file+0x21c><== NEVER TAKEN
2034c58: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
2034c5c: aa 10 20 00 clr %l5 ! 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;
2034c60: a8 10 20 00 clr %l4
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
2034c64: 9e 0b e0 3f and %o7, 0x3f, %o7
2034c68: 80 a3 e0 0f cmp %o7, 0xf
2034c6c: 12 80 00 54 bne 2034dbc <msdos_find_name_in_fat_file+0x374>
2034c70: 80 8e e0 ff btst 0xff, %i3
#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)
2034c74: de 07 bf f4 ld [ %fp + -12 ], %o7
2034c78: 80 a3 ff ff cmp %o7, -1
2034c7c: 32 80 00 0f bne,a 2034cb8 <msdos_find_name_in_fat_file+0x270>
2034c80: c8 08 40 00 ldub [ %g1 ], %g4
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
2034c84: 88 09 20 ff and %g4, 0xff, %g4
2034c88: 80 89 20 40 btst 0x40, %g4
2034c8c: 02 80 00 a1 be 2034f10 <msdos_find_name_in_fat_file+0x4c8>
2034c90: b6 10 20 00 clr %i3
* 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) &
2034c94: 88 09 20 3f and %g4, 0x3f, %g4
2034c98: 80 a7 00 04 cmp %i4, %g4
2034c9c: 32 80 00 9e bne,a 2034f14 <msdos_find_name_in_fat_file+0x4cc>
2034ca0: 84 00 a0 20 add %g2, 0x20, %g2
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
2034ca4: f2 08 60 0d ldub [ %g1 + 0xd ], %i1
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
2034ca8: ee 27 bf f4 st %l7, [ %fp + -12 ]
lfn_start.ofs = dir_entry;
2034cac: c4 27 bf f8 st %g2, [ %fp + -8 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
2034cb0: b0 10 00 1c mov %i4, %i0
* 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) &
2034cb4: c8 08 40 00 ldub [ %g1 ], %g4
2034cb8: 88 09 20 3f and %g4, 0x3f, %g4
2034cbc: 80 a6 00 04 cmp %i0, %g4
2034cc0: 32 80 00 94 bne,a 2034f10 <msdos_find_name_in_fat_file+0x4c8><== NEVER TAKEN
2034cc4: c6 27 bf f4 st %g3, [ %fp + -12 ] <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
2034cc8: c8 08 60 0d ldub [ %g1 + 0xd ], %g4
2034ccc: 9e 0e 60 ff and %i1, 0xff, %o7
2034cd0: 80 a3 c0 04 cmp %o7, %g4
2034cd4: 02 80 00 04 be 2034ce4 <msdos_find_name_in_fat_file+0x29c><== ALWAYS TAKEN
2034cd8: 9e 06 3f ff add %i0, -1, %o7
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
2034cdc: 10 80 00 8d b 2034f10 <msdos_find_name_in_fat_file+0x4c8> <== NOT EXECUTED
2034ce0: c6 27 bf f4 st %g3, [ %fp + -12 ] <== NOT EXECUTED
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2034ce4: 89 2b e0 02 sll %o7, 2, %g4
2034ce8: b7 2b e0 04 sll %o7, 4, %i3
p = entry + 1;
2034cec: 82 00 60 01 inc %g1
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2034cf0: b6 26 c0 04 sub %i3, %g4, %i3
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++)
2034cf4: 88 10 20 00 clr %g4
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2034cf8: b6 06 c0 0f add %i3, %o7, %i3
{
#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')
2034cfc: da 48 40 00 ldsb [ %g1 ], %o5
2034d00: 80 a3 60 00 cmp %o5, 0
2034d04: 12 80 00 0c bne 2034d34 <msdos_find_name_in_fat_file+0x2ec>
2034d08: d6 07 a0 54 ld [ %fp + 0x54 ], %o3
/*
* 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) &&
2034d0c: 80 a6 00 1c cmp %i0, %i4
2034d10: 32 80 00 23 bne,a 2034d9c <msdos_find_name_in_fat_file+0x354><== NEVER TAKEN
2034d14: b6 10 20 00 clr %i3 <== NOT EXECUTED
2034d18: c2 07 a0 54 ld [ %fp + 0x54 ], %g1
((o + i) != name_len))
2034d1c: 88 06 c0 04 add %i3, %g4, %g4
/*
* 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) &&
2034d20: 80 a1 00 01 cmp %g4, %g1
2034d24: 32 80 00 1d bne,a 2034d98 <msdos_find_name_in_fat_file+0x350><== NEVER TAKEN
2034d28: c6 27 bf f4 st %g3, [ %fp + -12 ] <== NOT EXECUTED
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
2034d2c: 10 80 00 1c b 2034d9c <msdos_find_name_in_fat_file+0x354>
2034d30: b6 10 20 00 clr %i3
* 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(
2034d34: 98 01 00 1b add %g4, %i3, %o4
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
2034d38: 80 a3 00 0b cmp %o4, %o3
2034d3c: 16 80 00 07 bge 2034d58 <msdos_find_name_in_fat_file+0x310>
2034d40: d6 07 a0 50 ld [ %fp + 0x50 ], %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(
2034d44: 98 02 c0 1b add %o3, %i3, %o4
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
2034d48: d8 4b 00 04 ldsb [ %o4 + %g4 ], %o4
2034d4c: 80 a3 40 0c cmp %o5, %o4
2034d50: 02 80 00 04 be 2034d60 <msdos_find_name_in_fat_file+0x318>
2034d54: 80 a1 20 04 cmp %g4, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
2034d58: 10 80 00 10 b 2034d98 <msdos_find_name_in_fat_file+0x350>
2034d5c: c6 27 bf f4 st %g3, [ %fp + -12 ]
}
switch (i)
2034d60: 02 80 00 06 be 2034d78 <msdos_find_name_in_fat_file+0x330>
2034d64: 80 a1 20 0a cmp %g4, 0xa
2034d68: 32 80 00 08 bne,a 2034d88 <msdos_find_name_in_fat_file+0x340>
2034d6c: 82 00 60 02 add %g1, 2, %g1
{
case 4:
p += 5;
break;
case 10:
p += 4;
2034d70: 10 80 00 04 b 2034d80 <msdos_find_name_in_fat_file+0x338>
2034d74: 82 00 60 04 add %g1, 4, %g1
switch (i)
{
case 4:
p += 5;
break;
2034d78: 10 80 00 04 b 2034d88 <msdos_find_name_in_fat_file+0x340>
2034d7c: 82 00 60 05 add %g1, 5, %g1
case 10:
p += 4;
break;
2034d80: 10 80 00 03 b 2034d8c <msdos_find_name_in_fat_file+0x344>
2034d84: 88 01 20 01 inc %g4
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++)
2034d88: 88 01 20 01 inc %g4
2034d8c: 80 a1 20 0d cmp %g4, 0xd
2034d90: 32 bf ff dc bne,a 2034d00 <msdos_find_name_in_fat_file+0x2b8>
2034d94: da 48 40 00 ldsb [ %g1 ], %o5
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
2034d98: b6 10 20 00 clr %i3
2034d9c: 80 a3 e0 00 cmp %o7, 0
2034da0: 12 80 00 5c bne 2034f10 <msdos_find_name_in_fat_file+0x4c8>
2034da4: b0 10 00 0f mov %o7, %i0
* 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(
2034da8: c2 07 bf f4 ld [ %fp + -12 ], %g1
2034dac: 82 38 00 01 xnor %g0, %g1, %g1
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
2034db0: 80 a0 00 01 cmp %g0, %g1
2034db4: 10 80 00 57 b 2034f10 <msdos_find_name_in_fat_file+0x4c8>
2034db8: b6 40 20 00 addx %g0, 0, %i3
* 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)
2034dbc: 02 80 00 19 be 2034e20 <msdos_find_name_in_fat_file+0x3d8>
2034dc0: c8 07 a0 58 ld [ %fp + 0x58 ], %g4
2034dc4: 88 10 20 00 clr %g4
2034dc8: 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;
2034dcc: da 08 40 04 ldub [ %g1 + %g4 ], %o5
2034dd0: 9e 0b e0 ff and %o7, 0xff, %o7
2034dd4: b6 0b e0 01 and %o7, 1, %i3
2034dd8: 80 a0 00 1b cmp %g0, %i3
2034ddc: 9f 33 e0 01 srl %o7, 1, %o7
2034de0: b6 40 3f ff addx %g0, -1, %i3
2034de4: 9e 03 40 0f add %o5, %o7, %o7
2034de8: b6 0e e0 80 and %i3, 0x80, %i3
{
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++)
2034dec: 88 01 20 01 inc %g4
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
2034df0: b6 06 ff 80 add %i3, -128, %i3
{
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++)
2034df4: 80 a1 20 0b cmp %g4, 0xb
2034df8: 12 bf ff f5 bne 2034dcc <msdos_find_name_in_fat_file+0x384>
2034dfc: 9e 03 c0 1b add %o7, %i3, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
2034e00: 9e 1b c0 19 xor %o7, %i1, %o7
2034e04: 80 8b e0 ff btst 0xff, %o7
2034e08: 12 80 00 06 bne 2034e20 <msdos_find_name_in_fat_file+0x3d8><== NEVER TAKEN
2034e0c: c8 07 a0 58 ld [ %fp + 0x58 ], %g4
2034e10: 80 a6 20 00 cmp %i0, 0
2034e14: 22 80 00 15 be,a 2034e68 <msdos_find_name_in_fat_file+0x420><== ALWAYS TAKEN
2034e18: f6 07 bf dc ld [ %fp + -36 ], %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 ||
2034e1c: c8 07 a0 58 ld [ %fp + 0x58 ], %g4 <== NOT EXECUTED
2034e20: 80 a1 20 01 cmp %g4, 1
2034e24: 32 80 00 38 bne,a 2034f04 <msdos_find_name_in_fat_file+0x4bc>
2034e28: c6 27 bf f4 st %g3, [ %fp + -12 ]
((name_type == MSDOS_NAME_SHORT) &&
2034e2c: c8 07 bf f4 ld [ %fp + -12 ], %g4
2034e30: 80 a1 3f ff cmp %g4, -1
2034e34: 32 80 00 34 bne,a 2034f04 <msdos_find_name_in_fat_file+0x4bc><== NEVER TAKEN
2034e38: c6 27 bf f4 st %g3, [ %fp + -12 ] <== NOT EXECUTED
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
2034e3c: 90 10 00 01 mov %g1, %o0
2034e40: c2 27 bf d4 st %g1, [ %fp + -44 ]
2034e44: c4 3f bf c8 std %g2, [ %fp + -56 ]
2034e48: 92 10 00 1a mov %i2, %o1
2034e4c: 40 00 40 a8 call 20450ec <memcmp>
2034e50: 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) &&
2034e54: c2 07 bf d4 ld [ %fp + -44 ], %g1
2034e58: 80 a2 20 00 cmp %o0, 0
2034e5c: 12 80 00 29 bne 2034f00 <msdos_find_name_in_fat_file+0x4b8>
2034e60: c4 1f bf c8 ldd [ %fp + -56 ], %g2
2034e64: f6 07 bf dc ld [ %fp + -36 ], %i3
2034e68: 88 10 00 10 mov %l0, %g4
2034e6c: b2 10 00 12 mov %l2, %i1
2034e70: a0 10 00 16 mov %l6, %l0
2034e74: a4 10 00 02 mov %g2, %l2
2034e78: ac 10 00 01 mov %g1, %l6
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
2034e7c: 90 10 00 10 mov %l0, %o0
2034e80: 92 10 00 19 mov %i1, %o1
2034e84: 94 10 20 01 mov 1, %o2
2034e88: 96 10 00 04 mov %g4, %o3
2034e8c: 7f ff c1 55 call 20253e0 <fat_file_ioctl>
2034e90: 98 10 00 1b mov %i3, %o4
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
2034e94: b0 92 20 00 orcc %o0, 0, %i0
2034e98: 12 80 00 18 bne 2034ef8 <msdos_find_name_in_fat_file+0x4b0><== NEVER TAKEN
2034e9c: d2 07 bf f4 ld [ %fp + -12 ], %o1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
2034ea0: 80 a2 7f ff cmp %o1, -1
2034ea4: 02 80 00 0d be 2034ed8 <msdos_find_name_in_fat_file+0x490>
2034ea8: e4 26 e0 04 st %l2, [ %i3 + 4 ]
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
2034eac: 7f ff 37 c4 call 2002dbc <.umul>
2034eb0: 90 10 00 1d mov %i5, %o0
2034eb4: 92 10 00 19 mov %i1, %o1
2034eb8: 96 10 00 08 mov %o0, %o3
2034ebc: 94 10 20 01 mov 1, %o2
2034ec0: 90 10 00 10 mov %l0, %o0
2034ec4: 7f ff c1 47 call 20253e0 <fat_file_ioctl>
2034ec8: 98 07 bf f4 add %fp, -12, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
2034ecc: 80 a2 20 00 cmp %o0, 0
2034ed0: 12 80 01 38 bne 20353b0 <msdos_find_name_in_fat_file+0x968><== NEVER TAKEN
2034ed4: 01 00 00 00 nop
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2034ed8: c2 07 bf f4 ld [ %fp + -12 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
2034edc: 90 10 00 1a mov %i2, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2034ee0: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
2034ee4: c2 07 bf f8 ld [ %fp + -8 ], %g1
memcpy(name_dir_entry, entry,
2034ee8: 92 10 00 16 mov %l6, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
2034eec: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(name_dir_entry, entry,
2034ef0: 40 00 40 ad call 20451a4 <memcpy>
2034ef4: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
2034ef8: 81 c7 e0 08 ret
2034efc: 81 e8 00 00 restore
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
2034f00: c6 27 bf f4 st %g3, [ %fp + -12 ]
lfn_matched = false;
2034f04: 10 80 00 03 b 2034f10 <msdos_find_name_in_fat_file+0x4c8>
2034f08: b6 10 20 00 clr %i3
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
2034f0c: c2 2f bf e8 stb %g1, [ %fp + -24 ]
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)
2034f10: 84 00 a0 20 add %g2, 0x20, %g2
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;
2034f14: 80 a0 80 1d cmp %g2, %i5
2034f18: 2a bf ff 25 bcs,a 2034bac <msdos_find_name_in_fat_file+0x164><== ALWAYS TAKEN
2034f1c: c8 04 60 94 ld [ %l1 + 0x94 ], %g4
2034f20: a0 04 00 1d add %l0, %i5, %l0 <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
2034f24: ae 05 e0 01 inc %l7 <== NOT EXECUTED
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
2034f28: d8 04 60 94 ld [ %l1 + 0x94 ], %o4
2034f2c: 90 10 00 16 mov %l6, %o0
2034f30: c6 27 bf cc st %g3, [ %fp + -52 ]
2034f34: 92 10 00 12 mov %l2, %o1
2034f38: 94 10 00 10 mov %l0, %o2
2034f3c: 7f ff c0 48 call 202505c <fat_file_read>
2034f40: 96 10 00 1d mov %i5, %o3
2034f44: 80 a2 20 00 cmp %o0, 0
2034f48: 12 bf ff 09 bne 2034b6c <msdos_find_name_in_fat_file+0x124><== ALWAYS TAKEN
2034f4c: c6 07 bf cc ld [ %fp + -52 ], %g3
2034f50: 82 10 00 13 mov %l3, %g1 <== NOT EXECUTED
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
2034f54: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
2034f58: a0 10 00 16 mov %l6, %l0 <== NOT EXECUTED
2034f5c: b2 10 00 12 mov %l2, %i1 <== NOT EXECUTED
2034f60: e6 07 bf e0 ld [ %fp + -32 ], %l3 <== NOT EXECUTED
2034f64: f6 07 bf dc ld [ %fp + -36 ], %i3 <== NOT EXECUTED
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
2034f68: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2034f6c: 02 bf ff e3 be 2034ef8 <msdos_find_name_in_fat_file+0x4b0><== NOT EXECUTED
2034f70: b0 16 21 01 or %i0, 0x101, %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)
2034f74: c4 07 a0 58 ld [ %fp + 0x58 ], %g2
2034f78: 80 a0 a0 02 cmp %g2, 2
2034f7c: 12 80 00 2b bne 2035028 <msdos_find_name_in_fat_file+0x5e0>
2034f80: 80 a7 20 00 cmp %i4, 0
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2034f84: 90 10 00 13 mov %l3, %o0
2034f88: 7f ff 37 8d call 2002dbc <.umul>
2034f8c: 92 10 00 1d mov %i5, %o1
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2034f90: c2 4e 80 00 ldsb [ %i2 ], %g1
*/
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;
2034f94: b0 07 20 01 add %i4, 1, %i0
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2034f98: 90 02 00 14 add %o0, %l4, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2034f9c: 80 a0 60 2e cmp %g1, 0x2e
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2034fa0: 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 == '.'))
2034fa4: 02 80 00 05 be 2034fb8 <msdos_find_name_in_fat_file+0x570><== NEVER TAKEN
2034fa8: b0 06 00 08 add %i0, %o0, %i0
2034fac: 80 a0 60 20 cmp %g1, 0x20
2034fb0: 32 80 00 05 bne,a 2034fc4 <msdos_find_name_in_fat_file+0x57c>
2034fb4: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
*c = '_';
2034fb8: 82 10 20 5f mov 0x5f, %g1
2034fbc: c2 2e 80 00 stb %g1, [ %i2 ]
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2034fc0: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
2034fc4: 80 a0 60 2e cmp %g1, 0x2e
2034fc8: 22 80 00 06 be,a 2034fe0 <msdos_find_name_in_fat_file+0x598><== NEVER TAKEN
2034fcc: 82 10 20 5f mov 0x5f, %g1 <== NOT EXECUTED
2034fd0: 80 a0 60 20 cmp %g1, 0x20
2034fd4: 32 80 00 05 bne,a 2034fe8 <msdos_find_name_in_fat_file+0x5a0>
2034fd8: 84 06 a0 02 add %i2, 2, %g2
*c = '_';
2034fdc: 82 10 20 5f mov 0x5f, %g1
2034fe0: c2 2e a0 01 stb %g1, [ %i2 + 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++)
2034fe4: 84 06 a0 02 add %i2, 2, %g2
2034fe8: 82 10 20 0c mov 0xc, %g1
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
2034fec: 07 00 81 7d sethi %hi(0x205f400), %g3
2034ff0: 89 3e 00 01 sra %i0, %g1, %g4
2034ff4: 9e 10 e2 78 or %g3, 0x278, %o7
2034ff8: 88 09 20 0f and %g4, 0xf, %g4
2034ffc: c8 0b c0 04 ldub [ %o7 + %g4 ], %g4
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++)
2035000: 82 00 7f fc add %g1, -4, %g1
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
2035004: c8 28 80 00 stb %g4, [ %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++)
2035008: 80 a0 7f fc cmp %g1, -4
203500c: 12 bf ff f9 bne 2034ff0 <msdos_find_name_in_fat_file+0x5a8>
2035010: 84 00 a0 01 inc %g2
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
2035014: 82 10 20 7e mov 0x7e, %g1
2035018: c2 2e a0 06 stb %g1, [ %i2 + 6 ]
*c++ = '1';
203501c: 82 10 20 31 mov 0x31, %g1
2035020: c2 2e a0 07 stb %g1, [ %i2 + 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)
2035024: 80 a7 20 00 cmp %i4, 0
2035028: 02 80 00 12 be 2035070 <msdos_find_name_in_fat_file+0x628>
203502c: c0 2f bf ef clrb [ %fp + -17 ]
2035030: 82 10 20 00 clr %g1
2035034: 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 =
2035038: c8 0e 80 01 ldub [ %i2 + %g1 ], %g4
((lfn_checksum & 1) ? 0x80 : 0) + (lfn_checksum >> 1) + *p;
203503c: 86 08 a0 ff and %g2, 0xff, %g3
2035040: 84 08 e0 01 and %g3, 1, %g2
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
2035044: 80 a0 00 02 cmp %g0, %g2
2035048: 87 30 e0 01 srl %g3, 1, %g3
203504c: 84 40 3f ff addx %g0, -1, %g2
2035050: 86 01 00 03 add %g4, %g3, %g3
2035054: 84 08 a0 80 and %g2, 0x80, %g2
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
2035058: 82 00 60 01 inc %g1
lfn_checksum =
203505c: 84 00 bf 80 add %g2, -128, %g2
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
2035060: 80 a0 60 0b cmp %g1, 0xb
2035064: 12 bf ff f5 bne 2035038 <msdos_find_name_in_fat_file+0x5f0>
2035068: 84 00 c0 02 add %g3, %g2, %g2
203506c: c4 2f bf ef stb %g2, [ %fp + -17 ]
* 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)
2035070: 80 a5 60 00 cmp %l5, 0
2035074: 22 80 00 06 be,a 203508c <msdos_find_name_in_fat_file+0x644><== NEVER TAKEN
2035078: a6 10 00 17 mov %l7, %l3 <== 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;
203507c: ae 1d c0 13 xor %l7, %l3, %l7
2035080: 80 a0 00 17 cmp %g0, %l7
2035084: 10 80 00 04 b 2035094 <msdos_find_name_in_fat_file+0x64c>
2035088: b0 40 20 00 addx %g0, 0, %i0
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
{
read_cluster = true;
203508c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
empty_space_offset = dir_offset;
empty_space_entry = 0;
2035090: a8 10 20 00 clr %l4 <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2035094: 82 10 3f ff mov -1, %g1
2035098: 90 10 00 13 mov %l3, %o0
203509c: c2 27 bf f8 st %g1, [ %fp + -8 ]
20350a0: c2 27 bf f4 st %g1, [ %fp + -12 ]
20350a4: 7f ff 37 46 call 2002dbc <.umul>
20350a8: 92 10 00 1d mov %i5, %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(
20350ac: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
20350b0: 88 07 20 01 add %i4, 1, %g4
20350b4: 84 00 7f f3 add %g1, -13, %g2
20350b8: 87 2f 20 04 sll %i4, 4, %g3
20350bc: 83 2f 20 02 sll %i4, 2, %g1
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
20350c0: a4 10 00 08 mov %o0, %l2
* 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(
20350c4: 82 20 c0 01 sub %g3, %g1, %g1
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
20350c8: aa 10 20 00 clr %l5
* 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(
20350cc: 82 00 40 1c add %g1, %i4, %g1
20350d0: c8 27 bf e8 st %g4, [ %fp + -24 ]
20350d4: 82 00 80 01 add %g2, %g1, %g1
20350d8: ae 10 00 1c mov %i4, %l7
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
20350dc: 10 80 00 ae b 2035394 <msdos_find_name_in_fat_file+0x94c>
20350e0: c2 27 bf e4 st %g1, [ %fp + -28 ]
{
int length = 0;
if (read_cluster)
20350e4: 02 80 00 0c be 2035114 <msdos_find_name_in_fat_file+0x6cc><== ALWAYS TAKEN
20350e8: 89 2d 60 04 sll %l5, 4, %g4
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(mt_entry, fat_fd,
20350ec: d8 04 60 94 ld [ %l1 + 0x94 ], %o4 <== NOT EXECUTED
20350f0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20350f4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20350f8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
20350fc: 7f ff bf d8 call 202505c <fat_file_read> <== NOT EXECUTED
2035100: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
2035104: 80 a2 00 1d cmp %o0, %i5 <== NOT EXECUTED
2035108: 12 80 00 0f bne 2035144 <msdos_find_name_in_fat_file+0x6fc><== NOT EXECUTED
203510c: 80 a2 20 00 cmp %o0, 0 <== 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(
2035110: 89 2d 60 04 sll %l5, 4, %g4 <== NOT EXECUTED
#endif
ret = fat_file_read(mt_entry, fat_fd,
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
2035114: c4 07 bf e8 ld [ %fp + -24 ], %g2
* 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(
2035118: 87 2d 60 02 sll %l5, 2, %g3
203511c: 86 21 00 03 sub %g4, %g3, %g3
2035120: c8 07 bf e4 ld [ %fp + -28 ], %g4
2035124: 82 05 60 01 add %l5, 1, %g1
2035128: 86 00 c0 15 add %g3, %l5, %g3
#endif
ret = fat_file_read(mt_entry, fat_fd,
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
203512c: 82 20 80 01 sub %g2, %g1, %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(
2035130: b0 10 00 14 mov %l4, %i0
2035134: 84 10 20 00 clr %g2
2035138: ac 10 20 00 clr %l6
203513c: 10 80 00 7e b 2035334 <msdos_find_name_in_fat_file+0x8ec>
2035140: 86 21 00 03 sub %g4, %g3, %g3
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
{
if (ret != FAT_EOF)
2035144: 12 80 00 8b bne 2035370 <msdos_find_name_in_fat_file+0x928><== NOT EXECUTED
2035148: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (mt_entry, fat_fd, empty_space_offset * bts2rd,
203514c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2035150: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2035154: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2035158: 7f ff c0 d7 call 20254b4 <fat_file_extend> <== NOT EXECUTED
203515c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&new_length);
if (ret != RC_OK)
2035160: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2035164: 12 80 00 93 bne 20353b0 <msdos_find_name_in_fat_file+0x968><== NOT EXECUTED
2035168: c2 07 bf fc ld [ %fp + -4 ], %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))
203516c: 80 a0 40 12 cmp %g1, %l2 <== NOT EXECUTED
2035170: 12 80 00 80 bne 2035370 <msdos_find_name_in_fat_file+0x928><== NOT EXECUTED
2035174: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
2035178: d0 04 60 94 ld [ %l1 + 0x94 ], %o0 <== NOT EXECUTED
203517c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2035180: 40 00 40 95 call 20453d4 <memset> <== NOT EXECUTED
2035184: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
ret = fat_file_write(mt_entry, fat_fd,
2035188: d8 04 60 94 ld [ %l1 + 0x94 ], %o4 <== NOT EXECUTED
203518c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2035190: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2035194: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2035198: 7f ff c1 43 call 20256a4 <fat_file_write> <== NOT EXECUTED
203519c: 96 10 00 1d mov %i5, %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)
20351a0: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
20351a4: 02 80 00 81 be 20353a8 <msdos_find_name_in_fat_file+0x960><== NOT EXECUTED
20351a8: 80 a2 00 1d cmp %o0, %i5 <== NOT EXECUTED
return ret;
else if (ret != bts2rd)
20351ac: 02 bf ff da be 2035114 <msdos_find_name_in_fat_file+0x6cc><== NOT EXECUTED
20351b0: 89 2d 60 04 sll %l5, 4, %g4 <== NOT EXECUTED
20351b4: 30 80 00 6f b,a 2035370 <msdos_find_name_in_fat_file+0x928><== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
20351b8: c8 07 bf e8 ld [ %fp + -24 ], %g4
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
20351bc: aa 05 60 01 inc %l5
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;
20351c0: b8 07 00 18 add %i4, %i0, %i4
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
20351c4: 80 a5 40 04 cmp %l5, %g4
20351c8: 12 80 00 23 bne 2035254 <msdos_find_name_in_fat_file+0x80c>
20351cc: ac 05 a0 20 add %l6, 0x20, %l6
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
20351d0: 90 10 00 10 mov %l0, %o0
20351d4: 92 10 00 19 mov %i1, %o1
20351d8: 94 10 20 01 mov 1, %o2
20351dc: 96 10 00 12 mov %l2, %o3
20351e0: 7f ff c0 80 call 20253e0 <fat_file_ioctl>
20351e4: 98 10 00 1b mov %i3, %o4
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
20351e8: 80 a2 20 00 cmp %o0, 0
20351ec: 12 80 00 71 bne 20353b0 <msdos_find_name_in_fat_file+0x968><== NEVER TAKEN
20351f0: d2 07 bf f4 ld [ %fp + -12 ], %o1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
20351f4: 80 a2 7f ff cmp %o1, -1
20351f8: 02 80 00 0d be 203522c <msdos_find_name_in_fat_file+0x7e4>
20351fc: f0 26 e0 04 st %i0, [ %i3 + 4 ]
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
2035200: 7f ff 36 ef call 2002dbc <.umul>
2035204: 90 10 00 1d mov %i5, %o0
2035208: 92 10 00 19 mov %i1, %o1
203520c: 96 10 00 08 mov %o0, %o3
2035210: 94 10 20 01 mov 1, %o2
2035214: 90 10 00 10 mov %l0, %o0
2035218: 7f ff c0 72 call 20253e0 <fat_file_ioctl>
203521c: 98 07 bf f4 add %fp, -12, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
2035220: 80 a2 20 00 cmp %o0, 0
2035224: 12 80 00 63 bne 20353b0 <msdos_find_name_in_fat_file+0x968><== NEVER TAKEN
2035228: 01 00 00 00 nop
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
203522c: c2 07 bf f4 ld [ %fp + -12 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
2035230: 90 10 00 1c mov %i4, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2035234: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
2035238: c2 07 bf f8 ld [ %fp + -8 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
203523c: 92 10 00 1a mov %i2, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
2035240: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
2035244: 40 00 3f d8 call 20451a4 <memcpy>
2035248: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
203524c: 10 80 00 3e b 2035344 <msdos_find_name_in_fat_file+0x8fc>
2035250: d8 04 60 94 ld [ %l1 + 0x94 ], %o4
* 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)
2035254: c8 07 bf f4 ld [ %fp + -12 ], %g4
2035258: 80 a1 3f ff cmp %g4, -1
203525c: 32 80 00 05 bne,a 2035270 <msdos_find_name_in_fat_file+0x828>
2035260: c2 27 bf d4 st %g1, [ %fp + -44 ]
{
lfn_start.cln = empty_space_offset;
2035264: e6 27 bf f4 st %l3, [ %fp + -12 ]
lfn_start.ofs = dir_entry;
2035268: f0 27 bf f8 st %i0, [ %fp + -8 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
203526c: c2 27 bf d4 st %g1, [ %fp + -44 ]
2035270: c4 3f bf c8 std %g2, [ %fp + -56 ]
2035274: 90 10 00 1c mov %i4, %o0
2035278: 92 10 20 00 clr %o1
203527c: 40 00 40 56 call 20453d4 <memset>
2035280: 94 10 20 20 mov 0x20, %o2
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
2035284: c8 0f bf ef ldub [ %fp + -17 ], %g4
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
2035288: 98 10 20 00 clr %o4
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
203528c: c8 2f 20 0d stb %g4, [ %i4 + 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(
2035290: c4 1f bf c8 ldd [ %fp + -56 ], %g2
*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++)
2035294: c2 07 bf d4 ld [ %fp + -44 ], %g1
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
2035298: 88 07 20 01 add %i4, 1, %g4
* 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(
203529c: 9a 00 c0 02 add %g3, %g2, %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++)
20352a0: 9e 10 20 00 clr %o7
{
if (*n != 0)
20352a4: d4 4b 40 00 ldsb [ %o5 ], %o2
20352a8: 80 a2 a0 00 cmp %o2, 0
20352ac: 02 80 00 05 be 20352c0 <msdos_find_name_in_fat_file+0x878>
20352b0: d6 0b 40 00 ldub [ %o5 ], %o3
{
*p = *n;
20352b4: d6 29 00 00 stb %o3, [ %g4 ]
n++;
20352b8: 10 80 00 05 b 20352cc <msdos_find_name_in_fat_file+0x884>
20352bc: 9a 03 60 01 inc %o5
}
else
{
p [0] = fill;
20352c0: d8 29 00 00 stb %o4, [ %g4 ]
p [1] = fill;
20352c4: d8 29 20 01 stb %o4, [ %g4 + 1 ]
fill = 0xff;
20352c8: 98 10 3f ff mov -1, %o4
}
switch (i)
20352cc: 80 a3 e0 04 cmp %o7, 4
20352d0: 02 80 00 06 be 20352e8 <msdos_find_name_in_fat_file+0x8a0>
20352d4: 80 a3 e0 0a cmp %o7, 0xa
20352d8: 32 80 00 08 bne,a 20352f8 <msdos_find_name_in_fat_file+0x8b0>
20352dc: 88 01 20 02 add %g4, 2, %g4
{
case 4:
p += 5;
break;
case 10:
p += 4;
20352e0: 10 80 00 04 b 20352f0 <msdos_find_name_in_fat_file+0x8a8>
20352e4: 88 01 20 04 add %g4, 4, %g4
switch (i)
{
case 4:
p += 5;
break;
20352e8: 10 80 00 04 b 20352f8 <msdos_find_name_in_fat_file+0x8b0>
20352ec: 88 01 20 05 add %g4, 5, %g4
case 10:
p += 4;
break;
20352f0: 10 80 00 03 b 20352fc <msdos_find_name_in_fat_file+0x8b4>
20352f4: 9e 03 e0 01 inc %o7
*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++)
20352f8: 9e 03 e0 01 inc %o7
20352fc: 80 a3 e0 0d cmp %o7, 0xd
2035300: 32 bf ff ea bne,a 20352a8 <msdos_find_name_in_fat_file+0x860>
2035304: d4 4b 40 00 ldsb [ %o5 ], %o2
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
2035308: 80 a5 60 01 cmp %l5, 1
203530c: 12 80 00 04 bne 203531c <msdos_find_name_in_fat_file+0x8d4>
2035310: c2 2f 00 00 stb %g1, [ %i4 ]
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
2035314: 88 10 60 40 or %g1, 0x40, %g4
2035318: c8 2f 00 00 stb %g4, [ %i4 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
203531c: c8 0f 20 0b ldub [ %i4 + 0xb ], %g4
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2035320: b0 06 20 20 add %i0, 0x20, %i0
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
2035324: 88 11 20 0f or %g4, 0xf, %g4
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2035328: 82 00 7f ff add %g1, -1, %g1
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
203532c: c8 2f 20 0b stb %g4, [ %i4 + 0xb ]
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2035330: 84 00 bf f3 add %g2, -13, %g2
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
2035334: 80 a6 00 1d cmp %i0, %i5
2035338: 2a bf ff a0 bcs,a 20351b8 <msdos_find_name_in_fat_file+0x770><== ALWAYS TAKEN
203533c: f8 04 60 94 ld [ %l1 + 0x94 ], %i4
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(mt_entry, fat_fd,
2035340: d8 04 60 94 ld [ %l1 + 0x94 ], %o4 <== NOT EXECUTED
2035344: 90 10 00 10 mov %l0, %o0
2035348: 92 10 00 19 mov %i1, %o1
203534c: 94 04 80 14 add %l2, %l4, %o2
2035350: 96 10 00 16 mov %l6, %o3
2035354: 7f ff c0 d4 call 20256a4 <fat_file_write>
2035358: 98 03 00 14 add %o4, %l4, %o4
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
203535c: 80 a2 3f ff cmp %o0, -1
2035360: 02 80 00 16 be 20353b8 <msdos_find_name_in_fat_file+0x970><== NEVER TAKEN
2035364: 80 a2 00 16 cmp %o0, %l6
return ret;
else if (ret != length)
2035368: 02 80 00 08 be 2035388 <msdos_find_name_in_fat_file+0x940><== ALWAYS TAKEN
203536c: a4 04 80 1d add %l2, %i5, %l2
rtems_set_errno_and_return_minus_one(EIO);
2035370: 40 00 32 4c call 2041ca0 <__errno> <== NOT EXECUTED
2035374: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2035378: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
203537c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2035380: 81 c7 e0 08 ret <== NOT EXECUTED
2035384: 81 e8 00 00 restore <== NOT EXECUTED
empty_space_offset++;
2035388: a6 04 e0 01 inc %l3
empty_space_entry = 0;
203538c: a8 10 20 00 clr %l4
read_cluster = true;
2035390: b0 10 20 01 mov 1, %i0
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
2035394: 80 a5 c0 15 cmp %l7, %l5
2035398: 16 bf ff 53 bge 20350e4 <msdos_find_name_in_fat_file+0x69c>
203539c: 80 8e 20 ff btst 0xff, %i0
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
20353a0: 81 c7 e0 08 ret
20353a4: 91 e8 20 00 restore %g0, 0, %o0
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)
20353a8: 81 c7 e0 08 ret <== NOT EXECUTED
20353ac: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
20353b0: 81 c7 e0 08 ret <== NOT EXECUTED
20353b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
}
ret = fat_file_write(mt_entry, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
20353b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
20353bc: 81 c7 e0 08 ret <== NOT EXECUTED
20353c0: 81 e8 00 00 restore <== NOT EXECUTED
020353c4 <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
)
{
20353c4: 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) &&
20353c8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20353cc: 80 a0 60 01 cmp %g1, 1
20353d0: 12 80 00 0f bne 203540c <msdos_find_node_by_cluster_num_in_fat_file+0x48><== ALWAYS TAKEN
20353d4: e6 06 20 20 ld [ %i0 + 0x20 ], %l3
20353d8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
20353dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20353e0: 32 80 00 07 bne,a 20353fc <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
20353e4: e0 14 e0 06 lduh [ %l3 + 6 ], %l0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
20353e8: c2 0c e0 0a ldub [ %l3 + 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) &&
20353ec: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
20353f0: 22 80 00 03 be,a 20353fc <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
20353f4: e0 14 e0 06 lduh [ %l3 + 6 ], %l0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
20353f8: e0 06 60 18 ld [ %i1 + 0x18 ], %l0 <== 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)
20353fc: 29 00 00 3f sethi %hi(0xfc00), %l4
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
2035400: a4 10 20 00 clr %l2
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)
2035404: 10 80 00 44 b 2035514 <msdos_find_node_by_cluster_num_in_fat_file+0x150>
2035408: a8 15 23 ff or %l4, 0x3ff, %l4
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;
203540c: 10 bf ff fc b 20353fc <msdos_find_node_by_cluster_num_in_fat_file+0x38>
2035410: e0 14 e0 06 lduh [ %l3 + 6 ], %l0
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
2035414: 14 80 00 08 bg 2035434 <msdos_find_node_by_cluster_num_in_fat_file+0x70><== ALWAYS TAKEN
2035418: 80 a2 00 10 cmp %o0, %l0
rtems_set_errno_and_return_minus_one( EIO );
203541c: 40 00 32 21 call 2041ca0 <__errno> <== NOT EXECUTED
2035420: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2035424: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2035428: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203542c: 81 c7 e0 08 ret <== NOT EXECUTED
2035430: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
2035434: 22 80 00 0a be,a 203545c <msdos_find_node_by_cluster_num_in_fat_file+0x98><== ALWAYS TAKEN
2035438: fa 04 e0 94 ld [ %l3 + 0x94 ], %i5
203543c: 11 00 81 9a sethi %hi(0x2066800), %o0 <== NOT EXECUTED
2035440: 15 00 81 9b sethi %hi(0x2066c00), %o2 <== NOT EXECUTED
2035444: 17 00 81 9b sethi %hi(0x2066c00), %o3 <== NOT EXECUTED
2035448: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
203544c: 92 10 26 4b mov 0x64b, %o1 <== NOT EXECUTED
2035450: 94 12 a0 88 or %o2, 0x88, %o2 <== NOT EXECUTED
2035454: 7f ff c7 90 call 2027294 <__assert_func> <== NOT EXECUTED
2035458: 96 12 e0 38 or %o3, 0x38, %o3 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
203545c: a2 10 20 00 clr %l1
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
2035460: c2 0f 40 00 ldub [ %i5 ], %g1
2035464: 80 a0 60 00 cmp %g1, 0
2035468: 02 80 00 38 be 2035548 <msdos_find_node_by_cluster_num_in_fat_file+0x184><== NEVER TAKEN
203546c: 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)) ==
2035470: 22 80 00 25 be,a 2035504 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NEVER TAKEN
2035474: a2 04 60 20 add %l1, 0x20, %l1 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2035478: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
203547c: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
2035480: 85 28 a0 10 sll %g2, 0x10, %g2
2035484: 87 30 a0 18 srl %g2, 0x18, %g3
2035488: 83 28 60 10 sll %g1, 0x10, %g1
203548c: 85 30 a0 08 srl %g2, 8, %g2
2035490: 84 08 80 14 and %g2, %l4, %g2
2035494: 84 10 c0 02 or %g3, %g2, %g2
2035498: 87 30 60 18 srl %g1, 0x18, %g3
203549c: 85 28 a0 10 sll %g2, 0x10, %g2
20354a0: 83 30 60 08 srl %g1, 8, %g1
20354a4: 82 08 40 14 and %g1, %l4, %g1
20354a8: 82 10 c0 01 or %g3, %g1, %g1
20354ac: 82 10 80 01 or %g2, %g1, %g1
20354b0: 80 a0 40 1a cmp %g1, %i2
20354b4: 32 80 00 14 bne,a 2035504 <msdos_find_node_by_cluster_num_in_fat_file+0x140>
20354b8: a2 04 60 20 add %l1, 0x20, %l1
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
20354bc: 90 10 00 18 mov %i0, %o0
20354c0: 92 10 00 19 mov %i1, %o1
20354c4: 94 10 20 01 mov 1, %o2
20354c8: 96 10 00 12 mov %l2, %o3
20354cc: 7f ff bf c5 call 20253e0 <fat_file_ioctl>
20354d0: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
20354d4: b0 92 20 00 orcc %o0, 0, %i0
20354d8: 12 bf ff d5 bne 203542c <msdos_find_node_by_cluster_num_in_fat_file+0x68><== NEVER TAKEN
20354dc: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
20354e0: e2 26 e0 04 st %l1, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20354e4: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20354e8: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
20354ec: 90 10 00 1c mov %i4, %o0
20354f0: 92 10 00 1d mov %i5, %o1
20354f4: 40 00 3f 2c call 20451a4 <memcpy>
20354f8: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
20354fc: 81 c7 e0 08 ret
2035500: 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)
2035504: 80 a4 40 10 cmp %l1, %l0
2035508: 0a bf ff d6 bcs 2035460 <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== ALWAYS TAKEN
203550c: ba 07 60 20 add %i5, 0x20, %i5
2035510: a4 04 80 10 add %l2, %l0, %l2 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
2035514: d8 04 e0 94 ld [ %l3 + 0x94 ], %o4
2035518: 90 10 00 18 mov %i0, %o0
203551c: 92 10 00 19 mov %i1, %o1
2035520: 94 10 00 12 mov %l2, %o2
2035524: 7f ff be ce call 202505c <fat_file_read>
2035528: 96 10 00 10 mov %l0, %o3
203552c: 80 a2 20 00 cmp %o0, 0
2035530: 32 bf ff b9 bne,a 2035414 <msdos_find_node_by_cluster_num_in_fat_file+0x50><== ALWAYS TAKEN
2035534: 80 a2 20 1f cmp %o0, 0x1f
return RC_OK;
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
2035538: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
203553c: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
2035540: 81 c7 e0 08 ret <== NOT EXECUTED
2035544: 81 e8 00 00 restore <== NOT EXECUTED
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
2035548: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
203554c: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
2035550: 81 c7 e0 08 ret <== NOT EXECUTED
2035554: 81 e8 00 00 restore <== NOT EXECUTED
0201f610 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
201f610: 9d e3 bc d8 save %sp, -808, %sp
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
201f614: 92 10 20 02 mov 2, %o1
201f618: 90 10 00 19 mov %i1, %o0
201f61c: 15 00 81 89 sethi %hi(0x2062400), %o2
201f620: 7f ff ff 83 call 201f42c <msdos_format_printf>
201f624: 94 12 a2 20 or %o2, 0x220, %o2 ! 2062620 <rtems_rtc_shell_usage+0xca0>
fd = open(devname, O_RDWR);
201f628: 92 10 20 02 mov 2, %o1
201f62c: 7f ff a8 32 call 20096f4 <open>
201f630: 90 10 00 18 mov %i0, %o0
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
struct stat stat_buf;
int ret_val = 0;
201f634: 82 38 00 08 xnor %g0, %o0, %g1
201f638: 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);
201f63c: b8 10 00 08 mov %o0, %i4
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
struct stat stat_buf;
int ret_val = 0;
201f640: b6 40 3f ff addx %g0, -1, %i3
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201f644: 90 10 00 19 mov %i1, %o0
201f648: 92 10 20 02 mov 2, %o1
201f64c: 15 00 81 89 sethi %hi(0x2062400), %o2
201f650: 96 10 00 18 mov %i0, %o3
201f654: 7f ff ff 76 call 201f42c <msdos_format_printf>
201f658: 94 12 a2 30 or %o2, 0x230, %o2
"stat check: %s\n", devname);
if (ret_val == 0) {
201f65c: 80 a6 e0 00 cmp %i3, 0
201f660: 12 80 00 06 bne 201f678 <msdos_format+0x68> <== NEVER TAKEN
201f664: ba 10 3f ff mov -1, %i5
rc = fstat(fd, &stat_buf);
201f668: 90 10 00 1c mov %i4, %o0
201f66c: 40 00 20 79 call 2027850 <fstat>
201f670: 92 07 bf a8 add %fp, -88, %o1
201f674: ba 10 00 08 mov %o0, %i5
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
201f678: 90 10 00 19 mov %i1, %o0
201f67c: 92 10 20 01 mov 1, %o1
201f680: 15 00 81 89 sethi %hi(0x2062400), %o2
201f684: 96 10 00 18 mov %i0, %o3
201f688: 7f ff ff 69 call 201f42c <msdos_format_printf>
201f68c: 94 12 a2 40 or %o2, 0x240, %o2
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
201f690: 80 a7 60 00 cmp %i5, 0
201f694: 12 80 01 92 bne 201fcdc <msdos_format+0x6cc> <== NEVER TAKEN
201f698: c4 07 bf b4 ld [ %fp + -76 ], %g2
201f69c: 03 00 00 3c sethi %hi(0xf000), %g1
201f6a0: 84 08 80 01 and %g2, %g1, %g2
201f6a4: 03 00 00 18 sethi %hi(0x6000), %g1
201f6a8: 80 a0 80 01 cmp %g2, %g1
201f6ac: 02 80 02 f1 be 2020270 <msdos_format+0xc60> <== ALWAYS TAKEN
201f6b0: 92 10 20 00 clr %o1
errno = ENOTTY;
201f6b4: 40 00 89 7b call 2041ca0 <__errno> <== NOT EXECUTED
201f6b8: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
201f6bc: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
201f6c0: 10 80 01 86 b 201fcd8 <msdos_format+0x6c8> <== NOT EXECUTED
201f6c4: 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);
201f6c8: 92 16 a2 05 or %i2, 0x205, %o1
201f6cc: 7f ff a4 82 call 20088d4 <ioctl>
201f6d0: 94 07 bf 5c add %fp, -164, %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) {
201f6d4: b6 92 20 00 orcc %o0, 0, %i3
201f6d8: 12 80 01 23 bne 201fb64 <msdos_format+0x554> <== NEVER TAKEN
201f6dc: f4 07 bf 58 ld [ %fp + -168 ], %i2
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
201f6e0: f0 07 bf 5c ld [ %fp + -164 ], %i0
201f6e4: 92 10 00 1a mov %i2, %o1
201f6e8: 7f ff 8d b5 call 2002dbc <.umul>
201f6ec: 90 10 00 18 mov %i0, %o0
201f6f0: a0 10 20 00 clr %l0
201f6f4: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201f6f8: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
201f6fc: e0 3f bd 50 std %l0, [ %fp + -688 ]
201f700: 9a 10 20 00 clr %o5
201f704: 90 10 00 19 mov %i1, %o0
201f708: 92 10 20 02 mov 2, %o1
201f70c: 15 00 81 89 sethi %hi(0x2062400), %o2
201f710: 96 10 00 1a mov %i2, %o3
201f714: 94 12 a2 50 or %o2, 0x250, %o2
201f718: 7f ff ff 45 call 201f42c <msdos_format_printf>
201f71c: 98 10 00 18 mov %i0, %o4
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
201f720: 80 a6 60 00 cmp %i1, 0
201f724: 02 80 00 0a be 201f74c <msdos_format+0x13c> <== NEVER TAKEN
201f728: 82 10 20 02 mov 2, %g1
(rqdata->fat_num == 0)) {
201f72c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
201f730: 80 a0 60 00 cmp %g1, 0
201f734: 12 80 00 04 bne 201f744 <msdos_format+0x134> <== NEVER TAKEN
201f738: 80 a0 60 06 cmp %g1, 6
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
201f73c: 10 80 00 04 b 201f74c <msdos_format+0x13c>
201f740: 82 10 20 02 mov 2, %g1
}
else if (rqdata->fat_num <= 6) {
201f744: 38 80 01 08 bgu,a 201fb64 <msdos_format+0x554> <== NOT EXECUTED
201f748: b6 10 20 16 mov 0x16, %i3 <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
201f74c: c2 2f bf 88 stb %g1, [ %fp + -120 ]
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201f750: d6 0f bf 88 ldub [ %fp + -120 ], %o3
201f754: 90 10 00 19 mov %i1, %o0
201f758: 92 10 20 02 mov 2, %o1
201f75c: 15 00 81 89 sethi %hi(0x2062400), %o2
201f760: 7f ff ff 33 call 201f42c <msdos_format_printf>
201f764: 94 12 a3 08 or %o2, 0x308, %o2 ! 2062708 <rtems_rtc_shell_usage+0xd88>
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
201f768: 82 10 20 01 mov 1, %g1
if ((rqdata != NULL) &&
201f76c: 80 a6 60 00 cmp %i1, 0
201f770: 12 80 00 04 bne 201f780 <msdos_format+0x170> <== ALWAYS TAKEN
201f774: c2 27 bf 64 st %g1, [ %fp + -156 ]
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
201f778: 10 80 00 16 b 201f7d0 <msdos_format+0x1c0> <== NOT EXECUTED
201f77c: c2 07 bf 5c ld [ %fp + -164 ], %g1 <== NOT EXECUTED
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
201f780: c2 0e 60 14 ldub [ %i1 + 0x14 ], %g1
201f784: 80 a0 60 01 cmp %g1, 1
201f788: 22 80 00 37 be,a 201f864 <msdos_format+0x254> <== NEVER TAKEN
201f78c: c2 2f bf 8a stb %g1, [ %fp + -118 ] <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
}
else if ((rqdata != NULL) &&
201f790: 80 a0 60 02 cmp %g1, 2
201f794: 22 80 00 34 be,a 201f864 <msdos_format+0x254> <== NEVER TAKEN
201f798: c2 2f bf 8a stb %g1, [ %fp + -118 ] <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
201f79c: 80 a0 60 03 cmp %g1, 3
201f7a0: 12 80 00 05 bne 201f7b4 <msdos_format+0x1a4> <== ALWAYS TAKEN
201f7a4: 80 a0 60 00 cmp %g1, 0
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
201f7a8: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
201f7ac: 10 80 00 2e b 201f864 <msdos_format+0x254> <== NOT EXECUTED
201f7b0: c2 2f bf 8a stb %g1, [ %fp + -118 ] <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
201f7b4: 02 80 00 07 be 201f7d0 <msdos_format+0x1c0> <== ALWAYS TAKEN
201f7b8: c2 07 bf 5c ld [ %fp + -164 ], %g1
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
201f7bc: 40 00 89 39 call 2041ca0 <__errno> <== NOT EXECUTED
201f7c0: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
201f7c4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201f7c8: 10 80 00 27 b 201f864 <msdos_format+0x254> <== NOT EXECUTED
201f7cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
201f7d0: 05 00 00 1f sethi %hi(0x7c00), %g2
201f7d4: 84 10 a3 a7 or %g2, 0x3a7, %g2 ! 7fa7 <PROM_START+0x7fa7>
201f7d8: 80 a0 40 02 cmp %g1, %g2
201f7dc: 18 80 00 04 bgu 201f7ec <msdos_format+0x1dc> <== NEVER TAKEN
201f7e0: 05 00 07 ff sethi %hi(0x1ffc00), %g2
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
201f7e4: 10 80 00 07 b 201f800 <msdos_format+0x1f0>
201f7e8: 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
201f7ec: 84 10 a2 9f or %g2, 0x29f, %g2 <== NOT EXECUTED
201f7f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201f7f4: 38 80 00 06 bgu,a 201f80c <msdos_format+0x1fc> <== NOT EXECUTED
201f7f8: 07 10 00 00 sethi %hi(0x40000000), %g3 <== NOT EXECUTED
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
201f7fc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
201f800: c2 2f bf 8a stb %g1, [ %fp + -118 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
201f804: 10 80 00 15 b 201f858 <msdos_format+0x248>
201f808: 82 10 20 02 mov 2, %g1
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
201f80c: 86 84 40 03 addcc %l1, %g3, %g3 <== NOT EXECUTED
201f810: 83 30 e0 1e srl %g3, 0x1e, %g1 <== NOT EXECUTED
201f814: 84 10 20 00 clr %g2 <== NOT EXECUTED
201f818: 84 44 00 02 addx %l0, %g2, %g2 <== NOT EXECUTED
201f81c: 85 28 a0 02 sll %g2, 2, %g2 <== NOT EXECUTED
201f820: 86 10 80 01 or %g2, %g1, %g3 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
201f824: 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)
201f828: 84 10 20 01 mov 1, %g2 <== 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;
201f82c: c2 2f bf 8a stb %g1, [ %fp + -118 ] <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
201f830: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
201f834: 89 28 80 01 sll %g2, %g1, %g4 <== NOT EXECUTED
201f838: 80 89 00 03 btst %g4, %g3 <== NOT EXECUTED
201f83c: 32 80 00 06 bne,a 201f854 <msdos_format+0x244> <== NOT EXECUTED
201f840: 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--)
201f844: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
201f848: 12 bf ff fc bne 201f838 <msdos_format+0x228> <== NOT EXECUTED
201f84c: 89 28 80 01 sll %g2, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
201f850: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
201f854: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
201f858: 80 a6 60 00 cmp %i1, 0
201f85c: 02 80 00 06 be 201f874 <msdos_format+0x264> <== NEVER TAKEN
201f860: c2 27 bf 64 st %g1, [ %fp + -156 ]
(rqdata->sectors_per_cluster > 0)) {
201f864: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
201f868: 80 a0 60 00 cmp %g1, 0
201f86c: 32 80 00 02 bne,a 201f874 <msdos_format+0x264> <== NEVER TAKEN
201f870: c2 27 bf 64 st %g1, [ %fp + -156 ] <== 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) {
201f874: f0 07 bf 58 ld [ %fp + -168 ], %i0
201f878: d6 07 bf 64 ld [ %fp + -156 ], %o3
201f87c: b4 10 20 80 mov 0x80, %i2
* 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) {
201f880: 80 a2 c0 1a cmp %o3, %i2
201f884: 2a 80 00 0a bcs,a 201f8ac <msdos_format+0x29c>
201f888: b5 36 a0 01 srl %i2, 1, %i2
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
201f88c: 11 00 00 20 sethi %hi(0x8000), %o0
201f890: 40 00 ee f0 call 205b450 <.udiv>
201f894: 92 10 00 18 mov %i0, %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
201f898: 80 a6 80 08 cmp %i2, %o0
201f89c: 18 80 00 03 bgu 201f8a8 <msdos_format+0x298> <== NEVER TAKEN
201f8a0: 96 10 00 1a mov %i2, %o3
<= 32768L/fmt_params->bytes_per_sector) {
/* value is small enough so this value is ok */
onebit = 1;
201f8a4: b4 10 20 01 mov 1, %i2
* 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) {
201f8a8: b5 36 a0 01 srl %i2, 1, %i2
201f8ac: 80 a6 a0 00 cmp %i2, 0
201f8b0: 12 bf ff f5 bne 201f884 <msdos_format+0x274>
201f8b4: 80 a2 c0 1a cmp %o3, %i2
}
}
}
}
if (ret_val == 0) {
201f8b8: 80 a6 e0 00 cmp %i3, 0
201f8bc: 12 80 00 a9 bne 201fb60 <msdos_format+0x550> <== NEVER TAKEN
201f8c0: d6 27 bf 64 st %o3, [ %fp + -156 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201f8c4: 90 10 00 19 mov %i1, %o0
201f8c8: 92 10 20 02 mov 2, %o1
201f8cc: 15 00 81 89 sethi %hi(0x2062400), %o2
201f8d0: 7f ff fe d7 call 201f42c <msdos_format_printf>
201f8d4: 94 12 a2 88 or %o2, 0x288, %o2 ! 2062688 <rtems_rtc_shell_usage+0xd08>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
201f8d8: c2 0f bf 8a ldub [ %fp + -118 ], %g1
201f8dc: 84 08 60 ff and %g1, 0xff, %g2
201f8e0: 80 a0 a0 04 cmp %g2, 4
201f8e4: 12 80 00 0a bne 201f90c <msdos_format+0x2fc> <== ALWAYS TAKEN
201f8e8: 84 10 20 01 mov 1, %g2
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
201f8ec: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
201f8f0: c2 27 bf 60 st %g1, [ %fp + -160 ] <== 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;
201f8f4: 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;
201f8f8: c0 27 bf 70 clr [ %fp + -144 ] <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
201f8fc: c2 27 bf 80 st %g1, [ %fp + -128 ] <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
201f900: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
201f904: 10 80 00 1b b 201f970 <msdos_format+0x360> <== NOT EXECUTED
201f908: c2 27 bf 84 st %g1, [ %fp + -124 ] <== 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) &&
201f90c: 80 a6 60 00 cmp %i1, 0
201f910: 02 80 00 08 be 201f930 <msdos_format+0x320> <== NEVER TAKEN
201f914: c4 27 bf 60 st %g2, [ %fp + -160 ]
(rqdata->files_per_root_dir > 0)) {
201f918: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
/* 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) &&
201f91c: 80 a0 a0 00 cmp %g2, 0
201f920: 02 80 00 05 be 201f934 <msdos_format+0x324> <== ALWAYS TAKEN
201f924: 82 08 60 ff and %g1, 0xff, %g1
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
201f928: 10 80 00 08 b 201f948 <msdos_format+0x338> <== NOT EXECUTED
201f92c: c4 27 bf 70 st %g2, [ %fp + -144 ] <== NOT EXECUTED
}
else {
if (fmt_params->fattype == FAT_FAT16) {
201f930: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
201f934: 80 a0 60 02 cmp %g1, 2
201f938: 32 80 00 03 bne,a 201f944 <msdos_format+0x334> <== ALWAYS TAKEN
201f93c: 82 10 20 40 mov 0x40, %g1
201f940: 82 10 22 00 mov 0x200, %g1 <== NOT EXECUTED
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
201f944: c2 27 bf 70 st %g1, [ %fp + -144 ]
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
201f948: f4 07 bf 70 ld [ %fp + -144 ], %i2
(2*fmt_params->bytes_per_sector/
201f94c: d2 07 bf 58 ld [ %fp + -168 ], %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
201f950: b4 06 bf ff add %i2, -1, %i2
(2*fmt_params->bytes_per_sector/
201f954: 93 2a 60 01 sll %o1, 1, %o1
201f958: 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 +
201f95c: b4 06 80 09 add %i2, %o1, %i2
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
201f960: 40 00 ef 68 call 205b700 <.urem>
201f964: 90 10 00 1a mov %i2, %o0
201f968: b4 26 80 08 sub %i2, %o0, %i2
201f96c: f4 27 bf 70 st %i2, [ %fp + -144 ]
(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)
201f970: f0 07 bf 58 ld [ %fp + -168 ], %i0
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)
201f974: d0 07 bf 70 ld [ %fp + -144 ], %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
201f978: 92 10 00 18 mov %i0, %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)
201f97c: a4 06 3f ff add %i0, -1, %l2
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)
201f980: 91 2a 20 05 sll %o0, 5, %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
201f984: 40 00 ee b3 call 205b450 <.udiv>
201f988: 90 04 80 08 add %l2, %o0, %o0
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
201f98c: c2 07 bf 60 ld [ %fp + -160 ], %g1
201f990: c4 07 bf 5c ld [ %fp + -164 ], %g2
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 =
201f994: d0 27 bf 74 st %o0, [ %fp + -140 ]
(((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 -
201f998: 82 20 80 01 sub %g2, %g1, %g1
201f99c: 82 20 40 08 sub %g1, %o0, %g1
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
201f9a0: e2 0f bf 8a ldub [ %fp + -118 ], %l1
(((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 -
201f9a4: c2 27 bd 4c st %g1, [ %fp + -692 ]
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
201f9a8: e0 0f bf 88 ldub [ %fp + -120 ], %l0
201f9ac: f4 07 bf 64 ld [ %fp + -156 ], %i2
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) {
201f9b0: 92 10 00 18 mov %i0, %o1
201f9b4: 40 00 ee a7 call 205b450 <.udiv>
201f9b8: 11 00 00 20 sethi %hi(0x8000), %o0
201f9bc: 10 80 00 03 b 201f9c8 <msdos_format+0x3b8>
201f9c0: 80 a2 00 1a cmp %o0, %i2
201f9c4: 80 a2 00 1a cmp %o0, %i2 <== NOT EXECUTED
201f9c8: 2a bf ff ff bcs,a 201f9c4 <msdos_format+0x3b4> <== NEVER TAKEN
201f9cc: b5 36 a0 01 srl %i2, 1, %i2 <== 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))) {
201f9d0: 82 1c 60 02 xor %l1, 2, %g1
+ (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)) ||
201f9d4: 80 a0 00 01 cmp %g0, %g1
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
201f9d8: a0 0c 20 ff and %l0, 0xff, %l0
/ 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))) {
201f9dc: 2f 00 00 3f sethi %hi(0xfc00), %l7
+ (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)) ||
201f9e0: ac 60 3f ff subx %g0, -1, %l6
201f9e4: 82 1c 60 01 xor %l1, 1, %g1
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
201f9e8: e0 27 bd 48 st %l0, [ %fp + -696 ]
+ (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)) ||
201f9ec: 80 a0 00 01 cmp %g0, %g1
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
201f9f0: ae 15 e3 f5 or %l7, 0x3f5, %l7
+ (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)) ||
201f9f4: aa 60 3f ff subx %g0, -1, %l5
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
201f9f8: 29 00 00 20 sethi %hi(0x8000), %l4
* 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;
201f9fc: d0 07 bd 4c ld [ %fp + -692 ], %o0
201fa00: 40 00 ee 94 call 205b450 <.udiv>
201fa04: 92 10 00 1a mov %i2, %o1
if (fattype == FAT_FAT12) {
201fa08: 80 a4 60 01 cmp %l1, 1
201fa0c: 12 80 00 06 bne 201fa24 <msdos_format+0x414> <== NEVER TAKEN
201fa10: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 3 / 2;
201fa14: 91 2a 20 01 sll %o0, 1, %o0
201fa18: 90 02 00 10 add %o0, %l0, %o0
201fa1c: 10 80 00 06 b 201fa34 <msdos_format+0x424>
201fa20: 91 32 20 01 srl %o0, 1, %o0
}
else if (fattype == FAT_FAT16) {
201fa24: 80 a4 60 02 cmp %l1, 2 <== NOT EXECUTED
201fa28: 12 80 00 03 bne 201fa34 <msdos_format+0x424> <== NOT EXECUTED
201fa2c: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
201fa30: 91 2c 20 01 sll %l0, 1, %o0 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
201fa34: 92 10 00 18 mov %i0, %o1
201fa38: 40 00 ee 86 call 205b450 <.udiv>
201fa3c: 90 02 00 12 add %o0, %l2, %o0
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
201fa40: d2 07 bd 48 ld [ %fp + -696 ], %o1
+ (sectors_per_cluster - 1))
201fa44: 82 06 bf ff add %i2, -1, %g1
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
201fa48: a6 10 00 08 mov %o0, %l3
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
201fa4c: 7f ff 8c dc call 2002dbc <.umul>
201fa50: c2 27 bd 44 st %g1, [ %fp + -700 ]
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
201fa54: c2 07 bd 44 ld [ %fp + -700 ], %g1
201fa58: 92 10 00 1a mov %i2, %o1
201fa5c: 40 00 ee 7d call 205b450 <.udiv>
201fa60: 90 00 40 08 add %g1, %o0, %o0
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
201fa64: 90 24 00 08 sub %l0, %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)) ||
201fa68: 80 a2 2f f5 cmp %o0, 0xff5
201fa6c: 18 80 00 03 bgu 201fa78 <msdos_format+0x468> <== NEVER TAKEN
201fa70: 82 10 20 01 mov 1, %g1
201fa74: 82 10 20 00 clr %g1
201fa78: 80 88 60 ff btst 0xff, %g1
201fa7c: 02 80 00 06 be 201fa94 <msdos_format+0x484> <== ALWAYS TAKEN
201fa80: 80 a5 c0 08 cmp %l7, %o0
201fa84: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
201fa88: 32 80 00 09 bne,a 201faac <msdos_format+0x49c> <== NOT EXECUTED
201fa8c: b5 2e a0 01 sll %i2, 1, %i2 <== NOT EXECUTED
201fa90: 80 a5 c0 08 cmp %l7, %o0 <== NOT EXECUTED
201fa94: 1a 80 00 07 bcc 201fab0 <msdos_format+0x4a0> <== ALWAYS TAKEN
201fa98: a0 10 20 01 mov 1, %l0
201fa9c: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
201faa0: 02 80 00 05 be 201fab4 <msdos_format+0x4a4> <== NOT EXECUTED
201faa4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
201faa8: b5 2e a0 01 sll %i2, 1, %i2 <== NOT EXECUTED
201faac: a0 10 20 00 clr %l0 <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
201fab0: 90 10 00 1a mov %i2, %o0
201fab4: 7f ff 8c c2 call 2002dbc <.umul>
201fab8: 92 10 00 18 mov %i0, %o1
201fabc: 80 a2 00 14 cmp %o0, %l4
201fac0: 18 80 00 06 bgu 201fad8 <msdos_format+0x4c8> <== NEVER TAKEN
201fac4: 80 8c 20 ff btst 0xff, %l0
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
201fac8: 02 bf ff ce be 201fa00 <msdos_format+0x3f0> <== NEVER TAKEN
201facc: d0 07 bd 4c ld [ %fp + -692 ], %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;
201fad0: 10 80 00 07 b 201faec <msdos_format+0x4dc>
201fad4: e6 27 bf 68 st %l3, [ %fp + -152 ]
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
201fad8: 40 00 88 72 call 2041ca0 <__errno> <== NOT EXECUTED
201fadc: b4 10 20 00 clr %i2 <== NOT EXECUTED
201fae0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201fae4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201fae8: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
}
/*
* determine media code
*/
if (ret_val == 0) {
201faec: 80 a6 e0 00 cmp %i3, 0
201faf0: 12 80 00 1c bne 201fb60 <msdos_format+0x550> <== NEVER TAKEN
201faf4: f4 27 bf 64 st %i2, [ %fp + -156 ]
if ((rqdata != NULL) &&
201faf8: 80 a6 60 00 cmp %i1, 0
201fafc: 02 80 00 17 be 201fb58 <msdos_format+0x548> <== NEVER TAKEN
201fb00: 82 10 3f f8 mov -8, %g1
(rqdata->media != 0)) {
201fb04: f4 0e 60 15 ldub [ %i1 + 0x15 ], %i2
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
201fb08: b0 8e a0 ff andcc %i2, 0xff, %i0
201fb0c: 22 80 00 16 be,a 201fb64 <msdos_format+0x554> <== ALWAYS TAKEN
201fb10: c2 2f bf 89 stb %g1, [ %fp + -119 ]
(rqdata->media != 0)) {
const char valid_media_codes[] =
201fb14: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
201fb18: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED
201fb1c: 13 00 81 89 sethi %hi(0x2062400), %o1 <== NOT EXECUTED
201fb20: 40 00 95 a1 call 20451a4 <memcpy> <== NOT EXECUTED
201fb24: 92 12 63 38 or %o1, 0x338, %o1 ! 2062738 <rtems_rtc_shell_usage+0xdb8><== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
201fb28: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED
201fb2c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201fb30: 40 00 95 2a call 2044fd8 <memchr> <== NOT EXECUTED
201fb34: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
201fb38: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201fb3c: 32 80 00 0a bne,a 201fb64 <msdos_format+0x554> <== NOT EXECUTED
201fb40: f4 2f bf 89 stb %i2, [ %fp + -119 ] <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
201fb44: 40 00 88 57 call 2041ca0 <__errno> <== NOT EXECUTED
201fb48: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
201fb4c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201fb50: 10 80 00 05 b 201fb64 <msdos_format+0x554> <== NOT EXECUTED
201fb54: 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;
201fb58: 10 80 00 03 b 201fb64 <msdos_format+0x554> <== NOT EXECUTED
201fb5c: c2 2f bf 89 stb %g1, [ %fp + -119 ] <== NOT EXECUTED
}
/*
* determine media code
*/
if (ret_val == 0) {
201fb60: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
201fb64: f0 07 bf 74 ld [ %fp + -140 ], %i0
201fb68: d0 0f bf 88 ldub [ %fp + -120 ], %o0
201fb6c: 80 a6 20 00 cmp %i0, 0
201fb70: f4 07 bf 60 ld [ %fp + -160 ], %i2
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
201fb74: 90 0a 20 ff and %o0, 0xff, %o0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
201fb78: 02 80 00 08 be 201fb98 <msdos_format+0x588> <== NEVER TAKEN
201fb7c: d2 07 bf 68 ld [ %fp + -152 ], %o1
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
201fb80: 7f ff 8c 8f call 2002dbc <.umul>
201fb84: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
201fb88: f0 27 bf 7c st %i0, [ %fp + -132 ]
* 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);
201fb8c: b4 02 00 1a add %o0, %i2, %i2
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
201fb90: 10 80 00 08 b 201fbb0 <msdos_format+0x5a0>
201fb94: f4 27 bf 78 st %i2, [ %fp + -136 ]
/*
* 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);
201fb98: 7f ff 8c 89 call 2002dbc <.umul> <== NOT EXECUTED
201fb9c: 01 00 00 00 nop <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
201fba0: c2 07 bf 64 ld [ %fp + -156 ], %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);
201fba4: b4 02 00 1a add %o0, %i2, %i2 <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
201fba8: c2 27 bf 7c st %g1, [ %fp + -132 ] <== NOT EXECUTED
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
201fbac: f4 27 bf 78 st %i2, [ %fp + -136 ] <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
201fbb0: 80 a6 e0 00 cmp %i3, 0
201fbb4: 12 80 00 46 bne 201fccc <msdos_format+0x6bc> <== NEVER TAKEN
201fbb8: 05 00 81 84 sethi %hi(0x2061000), %g2
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
201fbbc: 80 a6 60 00 cmp %i1, 0
201fbc0: 02 80 00 06 be 201fbd8 <msdos_format+0x5c8> <== NEVER TAKEN
201fbc4: 82 10 a2 30 or %g2, 0x230, %g1
(rqdata->OEMName != NULL)) {
201fbc8: 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) &&
201fbcc: 80 a0 60 00 cmp %g1, 0
201fbd0: 22 80 00 02 be,a 201fbd8 <msdos_format+0x5c8> <== NEVER TAKEN
201fbd4: 82 10 a2 30 or %g2, 0x230, %g1 <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201fbd8: 05 00 81 ae sethi %hi(0x206b800), %g2
201fbdc: 86 10 20 09 mov 9, %g3
201fbe0: f0 00 a1 58 ld [ %g2 + 0x158 ], %i0
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
201fbe4: b4 10 20 20 mov 0x20, %i2
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
201fbe8: 10 80 00 0f b 201fc24 <msdos_format+0x614>
201fbec: 84 07 bf 8b add %fp, -117, %g2
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201fbf0: 88 0e e0 ff and %i3, 0xff, %g4
201fbf4: 88 06 00 04 add %i0, %g4, %g4
201fbf8: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
201fbfc: 80 89 20 97 btst 0x97, %g4
201fc00: 02 80 00 06 be 201fc18 <msdos_format+0x608>
201fc04: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
201fc08: f6 28 80 00 stb %i3, [ %g2 ]
201fc0c: 82 00 60 01 inc %g1
201fc10: 10 80 00 04 b 201fc20 <msdos_format+0x610>
201fc14: 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++=' ';
201fc18: f4 28 80 00 stb %i2, [ %g2 ]
201fc1c: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
201fc20: 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;
201fc24: 86 80 ff ff addcc %g3, -1, %g3
201fc28: 32 bf ff f2 bne,a 201fbf0 <msdos_format+0x5e0>
201fc2c: f6 08 40 00 ldub [ %g1 ], %i3
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) &&
201fc30: 10 80 01 9d b 20202a4 <msdos_format+0xc94>
201fc34: 80 a6 60 00 cmp %i1, 0
201fc38: 80 a0 60 00 cmp %g1, 0
201fc3c: 22 80 00 05 be,a 201fc50 <msdos_format+0x640> <== NEVER TAKEN
201fc40: 03 00 81 81 sethi %hi(0x2060400), %g1 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
201fc44: 84 10 20 01 mov 1, %g2
201fc48: 10 80 00 03 b 201fc54 <msdos_format+0x644>
201fc4c: c4 2f bf a0 stb %g2, [ %fp + -96 ]
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
201fc50: 82 10 62 60 or %g1, 0x260, %g1 <== NOT EXECUTED
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201fc54: 05 00 81 ae sethi %hi(0x206b800), %g2
201fc58: 86 10 20 0c mov 0xc, %g3
201fc5c: f0 00 a1 58 ld [ %g2 + 0x158 ], %i0
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
201fc60: b4 10 20 20 mov 0x20, %i2
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
201fc64: 10 80 00 0f b 201fca0 <msdos_format+0x690>
201fc68: 84 07 bf 94 add %fp, -108, %g2
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201fc6c: 88 0e e0 ff and %i3, 0xff, %g4
201fc70: 88 06 00 04 add %i0, %g4, %g4
201fc74: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
201fc78: 80 89 20 97 btst 0x97, %g4
201fc7c: 02 80 00 06 be 201fc94 <msdos_format+0x684>
201fc80: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
201fc84: f6 28 80 00 stb %i3, [ %g2 ]
201fc88: 82 00 60 01 inc %g1
201fc8c: 10 80 00 04 b 201fc9c <msdos_format+0x68c>
201fc90: 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++=' ';
201fc94: f4 28 80 00 stb %i2, [ %g2 ]
201fc98: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
201fc9c: c0 29 00 00 clrb [ %g4 ]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
201fca0: 86 80 ff ff addcc %g3, -1, %g3
201fca4: 32 bf ff f2 bne,a 201fc6c <msdos_format+0x65c>
201fca8: f6 08 40 00 ldub [ %g1 ], %i3
201fcac: 30 80 01 82 b,a 20202b4 <msdos_format+0xca4>
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;
201fcb0: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
201fcb4: 10 80 00 09 b 201fcd8 <msdos_format+0x6c8> <== NOT EXECUTED
201fcb8: c2 27 bf a4 st %g1, [ %fp + -92 ] <== NOT EXECUTED
}
else {
*volid_ptr = rand();
201fcbc: 40 00 9d 22 call 2047144 <rand>
201fcc0: 01 00 00 00 nop
201fcc4: 10 80 00 05 b 201fcd8 <msdos_format+0x6c8>
201fcc8: d0 27 bf a4 st %o0, [ %fp + -92 ]
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
201fccc: 40 00 87 f5 call 2041ca0 <__errno> <== NOT EXECUTED
201fcd0: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
201fcd4: f6 22 00 00 st %i3, [ %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) &&
201fcd8: 80 a7 60 00 cmp %i5, 0
201fcdc: 12 80 00 11 bne 201fd20 <msdos_format+0x710> <== NEVER TAKEN
201fce0: 80 a7 60 00 cmp %i5, 0
201fce4: 80 a6 60 00 cmp %i1, 0
201fce8: 02 80 00 0e be 201fd20 <msdos_format+0x710> <== NEVER TAKEN
201fcec: 80 a7 60 00 cmp %i5, 0
(rqdata != NULL) &&
201fcf0: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
201fcf4: 80 a0 60 00 cmp %g1, 0
201fcf8: 12 80 00 0d bne 201fd2c <msdos_format+0x71c> <== NEVER TAKEN
201fcfc: 90 10 00 19 mov %i1, %o0
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
201fd00: d6 07 bf 5c ld [ %fp + -164 ], %o3
201fd04: d8 07 bf 58 ld [ %fp + -168 ], %o4
201fd08: 92 10 00 1c mov %i4, %o1
201fd0c: 94 10 20 00 clr %o2
201fd10: 7f ff fd f4 call 201f4e0 <msdos_format_fill_sectors>
201fd14: 9a 10 3f e5 mov -27, %o5
201fd18: ba 10 00 08 mov %o0, %i5
}
/*
* create master boot record
*/
if (ret_val == 0) {
201fd1c: 80 a7 60 00 cmp %i5, 0
201fd20: 12 80 01 4e bne 2020258 <msdos_format+0xc48> <== NEVER TAKEN
201fd24: 80 a7 3f ff cmp %i4, -1
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201fd28: 90 10 00 19 mov %i1, %o0
201fd2c: 92 10 20 02 mov 2, %o1
201fd30: 15 00 81 89 sethi %hi(0x2062400), %o2
201fd34: 7f ff fd be call 201f42c <msdos_format_printf>
201fd38: 94 12 a2 a8 or %o2, 0x2a8, %o2 ! 20626a8 <rtems_rtc_shell_usage+0xd28>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
201fd3c: 90 10 00 1c mov %i4, %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,
201fd40: fa 07 bf 58 ld [ %fp + -168 ], %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)) {
201fd44: 92 10 20 00 clr %o1
201fd48: 94 10 20 00 clr %o2
201fd4c: 40 00 21 e1 call 20284d0 <lseek>
201fd50: 96 10 20 00 clr %o3
201fd54: 80 a2 20 00 cmp %o0, 0
201fd58: 06 80 00 08 bl 201fd78 <msdos_format+0x768> <== NEVER TAKEN
201fd5c: 90 10 00 1c mov %i4, %o0
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
201fd60: 92 07 bd 58 add %fp, -680, %o1
201fd64: 7f ff a7 09 call 2009988 <read>
201fd68: 94 10 00 1d mov %i5, %o2
201fd6c: 80 a2 20 00 cmp %o0, 0
201fd70: 16 80 01 57 bge 20202cc <msdos_format+0xcbc> <== ALWAYS TAKEN
201fd74: 90 10 00 19 mov %i1, %o0
/*
* 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){
201fd78: 10 80 01 37 b 2020254 <msdos_format+0xc44> <== NOT EXECUTED
201fd7c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
201fd80: ba 10 20 00 clr %i5 <== NOT EXECUTED
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
201fd84: 92 10 20 00 clr %o1
201fd88: 94 10 21 be mov 0x1be, %o2
201fd8c: 40 00 95 92 call 20453d4 <memset>
201fd90: 90 07 bd 58 add %fp, -680, %o0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
201fd94: 90 07 bd 5b add %fp, -677, %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,
201fd98: c0 37 bf 56 clrh [ %fp + -170 ]
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
201fd9c: 92 07 bf 8b add %fp, -117, %o1
201fda0: 40 00 95 01 call 20451a4 <memcpy>
201fda4: 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);
201fda8: c2 07 bf 58 ld [ %fp + -168 ], %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);
201fdac: fa 2f bd 6b stb %i5, [ %fp + -661 ]
* 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);
201fdb0: c2 2f bd 63 stb %g1, [ %fp + -669 ]
201fdb4: 83 30 60 08 srl %g1, 8, %g1
201fdb8: c2 2f bd 64 stb %g1, [ %fp + -668 ]
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
201fdbc: c2 07 bf 64 ld [ %fp + -156 ], %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);
201fdc0: bb 37 60 08 srl %i5, 8, %i5
*/
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);
201fdc4: c2 2f bd 65 stb %g1, [ %fp + -667 ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
201fdc8: c2 07 bf 60 ld [ %fp + -160 ], %g1
/* 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);
201fdcc: fa 2f bd 6c stb %i5, [ %fp + -660 ]
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);
201fdd0: c2 2f bd 66 stb %g1, [ %fp + -666 ]
201fdd4: 83 30 60 08 srl %g1, 8, %g1
201fdd8: c2 2f bd 67 stb %g1, [ %fp + -665 ]
/* 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);
201fddc: c2 07 bf 70 ld [ %fp + -144 ], %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);
201fde0: 05 00 00 3f sethi %hi(0xfc00), %g2
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
201fde4: c2 2f bd 69 stb %g1, [ %fp + -663 ]
201fde8: 83 30 60 08 srl %g1, 8, %g1
201fdec: c2 2f bd 6a stb %g1, [ %fp + -662 ]
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
201fdf0: c2 0f bf 89 ldub [ %fp + -119 ], %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);
201fdf4: 84 10 a3 ff or %g2, 0x3ff, %g2
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
201fdf8: c2 2f bd 6d stb %g1, [ %fp + -659 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
201fdfc: 82 10 3f ff mov -1, %g1
201fe00: c2 2f bd 70 stb %g1, [ %fp + -656 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
201fe04: 82 10 20 06 mov 6, %g1
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
201fe08: fa 0f bf 8a ldub [ %fp + -118 ], %i5
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
201fe0c: c2 2f bd 72 stb %g1, [ %fp + -654 ]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
201fe10: 82 0e c0 02 and %i3, %g2, %g1
201fe14: 83 30 60 08 srl %g1, 8, %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 */
201fe18: 88 10 20 02 mov 2, %g4
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
201fe1c: 86 10 20 01 mov 1, %g3
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
201fe20: f6 2f bd 78 stb %i3, [ %fp + -648 ]
201fe24: c2 2f bd 79 stb %g1, [ %fp + -647 ]
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 */
201fe28: c8 2f bd 68 stb %g4, [ %fp + -664 ]
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);
201fe2c: 83 36 e0 10 srl %i3, 0x10, %g1
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
201fe30: c6 2f bd 74 stb %g3, [ %fp + -652 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
201fe34: c2 2f bd 7a stb %g1, [ %fp + -646 ]
201fe38: b7 36 e0 18 srl %i3, 0x18, %i3
201fe3c: f6 2f bd 7b stb %i3, [ %fp + -645 ]
if (fmt_params->fattype != FAT_FAT32) {
201fe40: 80 a7 60 04 cmp %i5, 4
201fe44: 02 80 00 1c be 201feb4 <msdos_format+0x8a4> <== NEVER TAKEN
201fe48: c2 07 bf 68 ld [ %fp + -152 ], %g1
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
201fe4c: c2 2f bd 6e stb %g1, [ %fp + -658 ]
201fe50: 83 30 60 08 srl %g1, 8, %g1
201fe54: c2 2f bd 6f stb %g1, [ %fp + -657 ]
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);
201fe58: 82 10 20 29 mov 0x29, %g1
201fe5c: c2 2f bd 7e stb %g1, [ %fp + -642 ]
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
201fe60: c2 07 bf a4 ld [ %fp + -92 ], %g1
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
201fe64: 92 07 bf 94 add %fp, -108, %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 */
201fe68: 84 08 40 02 and %g1, %g2, %g2
201fe6c: 85 30 a0 08 srl %g2, 8, %g2
201fe70: c2 2f bd 7f stb %g1, [ %fp + -641 ]
201fe74: c4 2f bd 80 stb %g2, [ %fp + -640 ]
201fe78: 85 30 60 10 srl %g1, 0x10, %g2
201fe7c: 83 30 60 18 srl %g1, 0x18, %g1
201fe80: c4 2f bd 81 stb %g2, [ %fp + -639 ]
201fe84: c2 2f bd 82 stb %g1, [ %fp + -638 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
201fe88: 90 07 bd 83 add %fp, -637, %o0
201fe8c: 40 00 94 c6 call 20451a4 <memcpy>
201fe90: 94 10 20 0b mov 0xb, %o2
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
201fe94: 13 00 81 89 sethi %hi(0x2062400), %o1
201fe98: 80 a7 60 01 cmp %i5, 1
201fe9c: 12 80 00 04 bne 201feac <msdos_format+0x89c> <== NEVER TAKEN
201fea0: 92 12 62 10 or %o1, 0x210, %o1
201fea4: 13 00 81 89 sethi %hi(0x2062400), %o1
201fea8: 92 12 62 00 or %o1, 0x200, %o1 ! 2062600 <rtems_rtc_shell_usage+0xc80>
201feac: 10 80 00 1d b 201ff20 <msdos_format+0x910>
201feb0: 90 07 bd 8e add %fp, -626, %o0
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
201feb4: 84 08 40 02 and %g1, %g2, %g2 <== NOT EXECUTED
201feb8: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
201febc: c2 2f bd 7c stb %g1, [ %fp + -644 ] <== NOT EXECUTED
201fec0: c4 2f bd 7d stb %g2, [ %fp + -643 ] <== NOT EXECUTED
201fec4: 85 30 60 10 srl %g1, 0x10, %g2 <== NOT EXECUTED
201fec8: 83 30 60 18 srl %g1, 0x18, %g1 <== NOT EXECUTED
201fecc: c2 2f bd 7f stb %g1, [ %fp + -641 ] <== 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 */
201fed0: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
201fed4: c4 2f bd 7e stb %g2, [ %fp + -642 ] <== 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 */
201fed8: c2 2f bd 8a stb %g1, [ %fp + -630 ] <== NOT EXECUTED
201fedc: 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 */
201fee0: c8 2f bd 84 stb %g4, [ %fp + -636 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
201fee4: c6 2f bd 88 stb %g3, [ %fp + -632 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
201fee8: c2 2f bd 8b stb %g1, [ %fp + -629 ] <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
201feec: 92 10 20 00 clr %o1 <== NOT EXECUTED
201fef0: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
201fef4: 40 00 95 38 call 20453d4 <memset> <== NOT EXECUTED
201fef8: 90 07 bd 8c add %fp, -628, %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);
201fefc: 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);
201ff00: 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);
201ff04: c2 2f bd 9a stb %g1, [ %fp + -614 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
201ff08: 90 07 bd 9f add %fp, -609, %o0 <== NOT EXECUTED
201ff0c: 40 00 95 32 call 20453d4 <memset> <== NOT EXECUTED
201ff10: 94 10 20 0b mov 0xb, %o2 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
201ff14: 13 00 81 89 sethi %hi(0x2062400), %o1 <== NOT EXECUTED
201ff18: 90 07 bd aa add %fp, -598, %o0 <== NOT EXECUTED
201ff1c: 92 12 62 c0 or %o1, 0x2c0, %o1 <== NOT EXECUTED
201ff20: 40 00 94 a1 call 20451a4 <memcpy>
201ff24: 94 10 20 08 mov 8, %o2
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
201ff28: 82 10 20 55 mov 0x55, %g1
201ff2c: c2 2f bf 56 stb %g1, [ %fp + -170 ]
201ff30: 82 10 3f aa mov -86, %g1
201ff34: c2 2f bf 57 stb %g1, [ %fp + -169 ]
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
201ff38: 82 10 3f eb mov -21, %g1
201ff3c: c2 2f bd 58 stb %g1, [ %fp + -680 ]
FAT_SET_VAL8(mbr,1,0x3c);
201ff40: 82 10 20 3c mov 0x3c, %g1
201ff44: c2 2f bd 59 stb %g1, [ %fp + -679 ]
FAT_SET_VAL8(mbr,2,0x90);
201ff48: 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,
201ff4c: 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);
201ff50: c2 2f bd 5a stb %g1, [ %fp + -678 ]
/*
* 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,
201ff54: 92 10 20 02 mov 2, %o1
201ff58: 15 00 81 89 sethi %hi(0x2062400), %o2
201ff5c: 7f ff fd 34 call 201f42c <msdos_format_printf>
201ff60: 94 12 a2 d0 or %o2, 0x2d0, %o2 ! 20626d0 <rtems_rtc_shell_usage+0xd50>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
201ff64: d4 07 bf 58 ld [ %fp + -168 ], %o2
201ff68: 90 10 00 1c mov %i4, %o0
201ff6c: 92 10 20 00 clr %o1
201ff70: 7f ff fd 44 call 201f480 <msdos_format_write_sec>
201ff74: 96 07 bd 58 add %fp, -680, %o3
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
201ff78: ba 92 20 00 orcc %o0, 0, %i5
201ff7c: 12 80 00 b6 bne 2020254 <msdos_format+0xc44> <== NEVER TAKEN
201ff80: c2 07 bf 80 ld [ %fp + -128 ], %g1
201ff84: 80 a0 60 00 cmp %g1, 0
201ff88: 02 80 00 10 be 201ffc8 <msdos_format+0x9b8> <== ALWAYS TAKEN
201ff8c: fa 07 bf 84 ld [ %fp + -124 ], %i5
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201ff90: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
201ff94: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
201ff98: 15 00 81 89 sethi %hi(0x2062400), %o2 <== NOT EXECUTED
201ff9c: 7f ff fd 24 call 201f42c <msdos_format_printf> <== NOT EXECUTED
201ffa0: 94 12 a2 e8 or %o2, 0x2e8, %o2 ! 20626e8 <rtems_rtc_shell_usage+0xd68><== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
201ffa4: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
201ffa8: d4 07 bf 58 ld [ %fp + -168 ], %o2 <== NOT EXECUTED
201ffac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201ffb0: 7f ff fd 34 call 201f480 <msdos_format_write_sec> <== NOT EXECUTED
201ffb4: 96 07 bd 58 add %fp, -680, %o3 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
201ffb8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
201ffbc: 12 80 00 a7 bne 2020258 <msdos_format+0xc48> <== NOT EXECUTED
201ffc0: 80 a7 3f ff cmp %i4, -1 <== NOT EXECUTED
(fmt_params.fsinfo_sec != 0)) {
201ffc4: fa 07 bf 84 ld [ %fp + -124 ], %i5 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
201ffc8: 80 a7 60 00 cmp %i5, 0
201ffcc: 02 80 00 28 be 202006c <msdos_format+0xa5c> <== ALWAYS TAKEN
201ffd0: d2 07 bf 68 ld [ %fp + -152 ], %o1
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
201ffd4: 92 10 20 00 clr %o1 <== NOT EXECUTED
201ffd8: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
201ffdc: 40 00 94 fe call 20453d4 <memset> <== NOT EXECUTED
201ffe0: 90 07 bd 58 add %fp, -680, %o0 <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
201ffe4: 82 10 20 52 mov 0x52, %g1 <== NOT EXECUTED
201ffe8: c2 2f bd 58 stb %g1, [ %fp + -680 ] <== NOT EXECUTED
201ffec: c2 2f bd 59 stb %g1, [ %fp + -679 ] <== NOT EXECUTED
201fff0: 82 10 20 61 mov 0x61, %g1 <== NOT EXECUTED
201fff4: c2 2f bd 5a stb %g1, [ %fp + -678 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
201fff8: c2 2f bf 3f stb %g1, [ %fp + -193 ] <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
201fffc: 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,
2020000: d4 07 bf 58 ld [ %fp + -168 ], %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);
2020004: c2 2f bf 56 stb %g1, [ %fp + -170 ] <== NOT EXECUTED
2020008: 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 );
202000c: 84 10 20 41 mov 0x41, %g2 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
2020010: 86 10 20 72 mov 0x72, %g3 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
2020014: c2 2f bf 57 stb %g1, [ %fp + -169 ] <== NOT EXECUTED
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
2020018: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
202001c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
2020020: c4 2f bd 5b stb %g2, [ %fp + -677 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
2020024: c6 2f bf 3c stb %g3, [ %fp + -196 ] <== NOT EXECUTED
2020028: c6 2f bf 3d stb %g3, [ %fp + -195 ] <== NOT EXECUTED
202002c: c4 2f bf 3e stb %g2, [ %fp + -194 ] <== 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,
2020030: c2 2f bf 40 stb %g1, [ %fp + -192 ] <== NOT EXECUTED
2020034: c2 2f bf 41 stb %g1, [ %fp + -191 ] <== NOT EXECUTED
2020038: c2 2f bf 42 stb %g1, [ %fp + -190 ] <== NOT EXECUTED
202003c: c2 2f bf 43 stb %g1, [ %fp + -189 ] <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
2020040: c2 2f bf 44 stb %g1, [ %fp + -188 ] <== NOT EXECUTED
2020044: c2 2f bf 45 stb %g1, [ %fp + -187 ] <== NOT EXECUTED
2020048: c2 2f bf 46 stb %g1, [ %fp + -186 ] <== NOT EXECUTED
202004c: c2 2f bf 47 stb %g1, [ %fp + -185 ] <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
2020050: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2020054: 7f ff fd 0b call 201f480 <msdos_format_write_sec> <== NOT EXECUTED
2020058: 96 07 bd 58 add %fp, -680, %o3 <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
202005c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2020060: 12 80 00 7e bne 2020258 <msdos_format+0xc48> <== NOT EXECUTED
2020064: 80 a7 3f ff cmp %i4, -1 <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
(rqdata,
2020068: d2 07 bf 68 ld [ %fp + -152 ], %o1 <== NOT EXECUTED
202006c: d0 0f bf 88 ldub [ %fp + -120 ], %o0
2020070: 7f ff 8b 53 call 2002dbc <.umul>
2020074: fa 07 bf 60 ld [ %fp + -160 ], %i5
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
2020078: d8 07 bf 58 ld [ %fp + -168 ], %o4
(rqdata,
202007c: 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
2020080: 94 10 00 1d mov %i5, %o2
2020084: 90 10 00 19 mov %i1, %o0
2020088: 92 10 00 1c mov %i4, %o1
202008c: 7f ff fd 15 call 201f4e0 <msdos_format_fill_sectors>
2020090: 9a 10 20 00 clr %o5
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
2020094: ba 92 20 00 orcc %o0, 0, %i5
2020098: 12 80 00 6f bne 2020254 <msdos_format+0xc44> <== NEVER TAKEN
202009c: d4 1f bf 78 ldd [ %fp + -136 ], %o2
ret_val = msdos_format_fill_sectors
20200a0: d8 07 bf 58 ld [ %fp + -168 ], %o4
20200a4: 90 10 00 19 mov %i1, %o0
20200a8: 92 10 00 1c mov %i4, %o1
20200ac: 7f ff fd 0d call 201f4e0 <msdos_format_fill_sectors>
20200b0: 9a 10 20 00 clr %o5
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
20200b4: ba 92 20 00 orcc %o0, 0, %i5
20200b8: 12 80 00 67 bne 2020254 <msdos_format+0xc44> <== NEVER TAKEN
20200bc: c2 0f bf a0 ldub [ %fp + -96 ], %g1
20200c0: 80 a0 60 00 cmp %g1, 0
20200c4: 02 80 00 14 be 2020114 <msdos_format+0xb04> <== NEVER TAKEN
20200c8: 92 10 20 00 clr %o1
memset(tmp_sec,0,sizeof(tmp_sec));
20200cc: 94 10 22 00 mov 0x200, %o2
20200d0: 40 00 94 c1 call 20453d4 <memset>
20200d4: 90 07 bd 58 add %fp, -680, %o0
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
20200d8: 92 07 bf 94 add %fp, -108, %o1
20200dc: 94 10 20 0b mov 0xb, %o2
20200e0: 40 00 94 31 call 20451a4 <memcpy>
20200e4: 90 07 bd 58 add %fp, -680, %o0
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
20200e8: d2 07 bf 78 ld [ %fp + -136 ], %o1
20200ec: d4 07 bf 58 ld [ %fp + -168 ], %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;
20200f0: 82 10 20 08 mov 8, %g1
ret_val = msdos_format_write_sec
20200f4: 90 10 00 1c mov %i4, %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;
20200f8: c2 2f bd 63 stb %g1, [ %fp + -669 ]
ret_val = msdos_format_write_sec
20200fc: 7f ff fc e1 call 201f480 <msdos_format_write_sec>
2020100: 96 07 bd 58 add %fp, -680, %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){
2020104: 80 a2 20 00 cmp %o0, 0
2020108: 12 80 00 52 bne 2020250 <msdos_format+0xc40> <== NEVER TAKEN
202010c: c2 0f bf a0 ldub [ %fp + -96 ], %g1
2020110: 80 a0 60 00 cmp %g1, 0
2020114: 02 80 00 51 be 2020258 <msdos_format+0xc48> <== NEVER TAKEN
2020118: 80 a7 3f ff cmp %i4, -1
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
202011c: 90 07 bd 58 add %fp, -680, %o0
2020120: 92 10 20 00 clr %o1
2020124: 40 00 94 ac call 20453d4 <memset>
2020128: 94 10 22 00 mov 0x200, %o2
switch(fmt_params.fattype) {
202012c: c2 0f bf 8a ldub [ %fp + -118 ], %g1
2020130: 80 a0 60 02 cmp %g1, 2
2020134: 02 80 00 0c be 2020164 <msdos_format+0xb54> <== NEVER TAKEN
2020138: 80 a0 60 04 cmp %g1, 4
202013c: 02 80 00 12 be 2020184 <msdos_format+0xb74> <== NEVER TAKEN
2020140: 80 a0 60 01 cmp %g1, 1
2020144: 12 80 00 1d bne 20201b8 <msdos_format+0xba8> <== NEVER TAKEN
2020148: c2 0f bf 89 ldub [ %fp + -119 ], %g1
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
202014c: c2 2f bd 58 stb %g1, [ %fp + -680 ]
/* 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)));
2020150: 82 10 3f 8f mov -113, %g1
2020154: c2 2f bd 59 stb %g1, [ %fp + -679 ]
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
2020158: 82 10 3f ff mov -1, %g1
break;
202015c: 10 80 00 1b b 20201c8 <msdos_format+0xbb8>
2020160: c2 2f bd 5a stb %g1, [ %fp + -678 ]
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
2020164: c2 0f bf 89 ldub [ %fp + -119 ], %g1 <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
2020168: 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);
202016c: c2 2f bd 58 stb %g1, [ %fp + -680 ] <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
2020170: c4 2f bd 5a stb %g2, [ %fp + -678 ] <== 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);
2020174: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
2020178: c2 2f bd 59 stb %g1, [ %fp + -679 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
202017c: 10 80 00 13 b 20201c8 <msdos_format+0xbb8> <== NOT EXECUTED
2020180: c2 2f bd 5b stb %g1, [ %fp + -677 ] <== NOT EXECUTED
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
2020184: c2 0f bf 89 ldub [ %fp + -119 ], %g1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
2020188: 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);
202018c: c2 2f bd 58 stb %g1, [ %fp + -680 ] <== NOT EXECUTED
2020190: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
2020194: c4 2f bd 5c stb %g2, [ %fp + -676 ] <== 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);
2020198: c2 2f bd 59 stb %g1, [ %fp + -679 ] <== NOT EXECUTED
202019c: c2 2f bd 5a stb %g1, [ %fp + -678 ] <== NOT EXECUTED
20201a0: c2 2f bd 5b stb %g1, [ %fp + -677 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
20201a4: c2 2f bd 5d stb %g1, [ %fp + -675 ] <== NOT EXECUTED
20201a8: c2 2f bd 5e stb %g1, [ %fp + -674 ] <== NOT EXECUTED
20201ac: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
break;
20201b0: 10 80 00 06 b 20201c8 <msdos_format+0xbb8> <== NOT EXECUTED
20201b4: c2 2f bd 5f stb %g1, [ %fp + -673 ] <== NOT EXECUTED
default:
ret_val = -1;
errno = EINVAL;
20201b8: 40 00 86 ba call 2041ca0 <__errno> <== NOT EXECUTED
20201bc: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
20201c0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20201c4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
20201c8: c2 0f bf 8a ldub [ %fp + -118 ], %g1
20201cc: 80 a0 60 04 cmp %g1, 4
20201d0: 12 80 00 14 bne 2020220 <msdos_format+0xc10> <== ALWAYS TAKEN
20201d4: b6 10 20 00 clr %i3
/*
* 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);
20201d8: 82 10 3f f8 mov -8, %g1 <== NOT EXECUTED
20201dc: c2 2f bd 60 stb %g1, [ %fp + -672 ] <== NOT EXECUTED
20201e0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
20201e4: c2 2f bd 61 stb %g1, [ %fp + -671 ] <== NOT EXECUTED
20201e8: c2 2f bd 62 stb %g1, [ %fp + -670 ] <== NOT EXECUTED
20201ec: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
20201f0: 10 80 00 0c b 2020220 <msdos_format+0xc10> <== NOT EXECUTED
20201f4: c2 2f bd 63 stb %g1, [ %fp + -669 ] <== 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),
20201f8: 7f ff 8a f1 call 2002dbc <.umul>
20201fc: 90 10 00 1b mov %i3, %o0
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
(fd,
2020200: d2 07 bf 60 ld [ %fp + -160 ], %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
2020204: d4 07 bf 58 ld [ %fp + -168 ], %o2
(fd,
2020208: 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
202020c: 96 07 bd 58 add %fp, -680, %o3
2020210: 90 10 00 1c mov %i4, %o0
2020214: 7f ff fc 9b call 201f480 <msdos_format_write_sec>
2020218: b6 06 e0 01 inc %i3
202021c: ba 10 00 08 mov %o0, %i5
* 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;
2020220: 80 a7 60 00 cmp %i5, 0
2020224: 12 80 00 0c bne 2020254 <msdos_format+0xc44> <== NEVER TAKEN
2020228: c4 0f bf 88 ldub [ %fp + -120 ], %g2
(i < fmt_params.fat_num) && (ret_val == 0);
202022c: 80 a6 c0 02 cmp %i3, %g2
2020230: 06 80 00 03 bl 202023c <msdos_format+0xc2c>
2020234: 82 10 20 01 mov 1, %g1
2020238: 82 10 20 00 clr %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;
202023c: 80 88 60 ff btst 0xff, %g1
2020240: 12 bf ff ee bne 20201f8 <msdos_format+0xbe8>
2020244: d2 07 bf 68 ld [ %fp + -152 ], %o1
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
2020248: 10 80 00 04 b 2020258 <msdos_format+0xc48>
202024c: 80 a7 3f ff cmp %i4, -1
/*
* 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){
2020250: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
2020254: 80 a7 3f ff cmp %i4, -1 <== NOT EXECUTED
2020258: 02 80 00 04 be 2020268 <msdos_format+0xc58> <== NEVER TAKEN
202025c: 01 00 00 00 nop
close(fd);
2020260: 7f ff a0 8d call 2008494 <close>
2020264: 90 10 00 1c mov %i4, %o0
}
return ret_val;
}
2020268: 81 c7 e0 08 ret
202026c: 91 e8 00 1d restore %g0, %i5, %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));
2020270: 94 10 20 50 mov 0x50, %o2
2020274: 40 00 94 58 call 20453d4 <memset>
2020278: 90 07 bf 58 add %fp, -168, %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);
202027c: 90 10 00 1c mov %i4, %o0
2020280: 35 10 01 10 sethi %hi(0x40044000), %i2
2020284: 94 07 bf 58 add %fp, -168, %o2
2020288: 7f ff a1 93 call 20088d4 <ioctl>
202028c: 92 16 a2 03 or %i2, 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) {
2020290: b6 92 20 00 orcc %o0, 0, %i3
2020294: 12 bf fe 35 bne 201fb68 <msdos_format+0x558> <== NEVER TAKEN
2020298: f0 07 bf 74 ld [ %fp + -140 ], %i0
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
202029c: 10 bf fd 0b b 201f6c8 <msdos_format+0xb8>
20202a0: 90 10 00 1c mov %i4, %o0
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) &&
20202a4: 32 bf fe 65 bne,a 201fc38 <msdos_format+0x628> <== ALWAYS TAKEN
20202a8: 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 */
20202ac: 10 bf fe 69 b 201fc50 <msdos_format+0x640> <== NOT EXECUTED
20202b0: 03 00 81 81 sethi %hi(0x2060400), %g1 <== NOT EXECUTED
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
20202b4: 40 00 27 25 call 2029f48 <rtems_clock_get_tod_timeval>
20202b8: 90 07 bf f0 add %fp, -16, %o0
if (rc == RTEMS_SUCCESSFUL) {
20202bc: 80 a2 20 00 cmp %o0, 0
20202c0: 02 bf fe 7c be 201fcb0 <msdos_format+0x6a0> <== NEVER TAKEN
20202c4: c2 07 bf f0 ld [ %fp + -16 ], %g1
20202c8: 30 bf fe 7d b,a 201fcbc <msdos_format+0x6ac>
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,
20202cc: 92 10 20 02 mov 2, %o1
20202d0: 15 00 81 89 sethi %hi(0x2062400), %o2
20202d4: 7f ff fc 56 call 201f42c <msdos_format_printf>
20202d8: 94 12 a3 20 or %o2, 0x320, %o2 ! 2062720 <rtems_rtc_shell_usage+0xda0>
{
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) {
20202dc: fa 07 bf 5c ld [ %fp + -164 ], %i5
20202e0: 03 00 00 3f sethi %hi(0xfc00), %g1
20202e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
20202e8: 80 a7 40 01 cmp %i5, %g1
20202ec: 08 bf fe a6 bleu 201fd84 <msdos_format+0x774> <== ALWAYS TAKEN
20202f0: b6 10 20 00 clr %i3
20202f4: 10 bf fe a3 b 201fd80 <msdos_format+0x770> <== NOT EXECUTED
20202f8: b6 10 00 1d mov %i5, %i3 <== NOT EXECUTED
0201f4e0 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
201f4e0: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
201f4e4: 7f ff a6 25 call 2008d78 <malloc>
201f4e8: 90 10 00 1c mov %i4, %o0
if (fill_buffer == NULL) {
201f4ec: a0 92 20 00 orcc %o0, 0, %l0
201f4f0: 12 80 00 07 bne 201f50c <msdos_format_fill_sectors+0x2c> <== ALWAYS TAKEN
201f4f4: 92 10 00 1d mov %i5, %o1
errno = ENOMEM;
201f4f8: 40 00 89 ea call 2041ca0 <__errno> <== NOT EXECUTED
201f4fc: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
201f500: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
201f504: 10 80 00 05 b 201f518 <msdos_format_fill_sectors+0x38> <== NOT EXECUTED
201f508: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
201f50c: 94 10 00 1c mov %i4, %o2
201f510: 40 00 97 b1 call 20453d4 <memset>
201f514: ba 10 20 00 clr %i5
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201f518: 90 10 00 18 mov %i0, %o0
201f51c: 92 10 20 02 mov 2, %o1
201f520: 15 00 81 89 sethi %hi(0x2062400), %o2
201f524: 7f ff ff c2 call 201f42c <msdos_format_printf>
201f528: 94 12 a1 d0 or %o2, 0x1d0, %o2 ! 20625d0 <rtems_rtc_shell_usage+0xc50>
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f52c: 83 2e e0 04 sll %i3, 4, %g1
201f530: ab 2e e0 02 sll %i3, 2, %l5
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, ".");
201f534: 29 00 81 81 sethi %hi(0x2060400), %l4
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f538: aa 05 40 01 add %l5, %g1, %l5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
201f53c: a6 10 00 1b mov %i3, %l3
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f540: 83 2d 60 02 sll %l5, 2, %g1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
201f544: a4 10 20 00 clr %l2
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
201f548: a2 10 3f ff mov -1, %l1
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f54c: aa 05 40 01 add %l5, %g1, %l5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
201f550: 10 80 00 16 b 201f5a8 <msdos_format_fill_sectors+0xc8>
201f554: a8 15 23 60 or %l4, 0x360, %l4
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
201f558: 40 00 ef be call 205b450 <.udiv>
201f55c: 92 10 00 1b mov %i3, %o1
if (percent != last_percent) {
201f560: 80 a2 00 11 cmp %o0, %l1
201f564: 02 80 00 08 be 201f584 <msdos_format_fill_sectors+0xa4>
201f568: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
201f56c: 12 80 00 06 bne 201f584 <msdos_format_fill_sectors+0xa4>
201f570: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
201f574: 90 10 00 18 mov %i0, %o0
201f578: 92 10 20 02 mov 2, %o1
201f57c: 7f ff ff ac call 201f42c <msdos_format_printf>
201f580: 94 10 00 14 mov %l4, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
201f584: 92 10 00 1a mov %i2, %o1
201f588: 90 10 00 19 mov %i1, %o0
201f58c: 94 10 00 1c mov %i4, %o2
201f590: 96 10 00 10 mov %l0, %o3
201f594: 7f ff ff bb call 201f480 <msdos_format_write_sec>
201f598: b4 06 a0 01 inc %i2
start_sector++;
sector_cnt--;
201f59c: a6 04 ff ff add %l3, -1, %l3
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
201f5a0: ba 10 00 08 mov %o0, %i5
start_sector++;
sector_cnt--;
201f5a4: a4 04 bf 9c add %l2, -100, %l2
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
201f5a8: 80 a4 e0 00 cmp %l3, 0
201f5ac: 02 80 00 04 be 201f5bc <msdos_format_fill_sectors+0xdc>
201f5b0: 80 a7 60 00 cmp %i5, 0
201f5b4: 02 bf ff e9 be 201f558 <msdos_format_fill_sectors+0x78> <== ALWAYS TAKEN
201f5b8: 90 04 80 15 add %l2, %l5, %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");
201f5bc: 90 10 00 18 mov %i0, %o0
201f5c0: 92 10 20 02 mov 2, %o1
201f5c4: 15 00 81 95 sethi %hi(0x2065400), %o2
201f5c8: 7f ff ff 99 call 201f42c <msdos_format_printf>
201f5cc: 94 12 a3 d8 or %o2, 0x3d8, %o2 ! 20657d8 <e2a_32V+0x810>
if (ret_val)
201f5d0: 80 a7 60 00 cmp %i5, 0
201f5d4: 02 80 00 09 be 201f5f8 <msdos_format_fill_sectors+0x118> <== ALWAYS TAKEN
201f5d8: 80 a4 20 00 cmp %l0, 0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
201f5dc: 15 00 81 89 sethi %hi(0x2062400), %o2 <== NOT EXECUTED
201f5e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201f5e4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201f5e8: 94 12 a1 e0 or %o2, 0x1e0, %o2 <== NOT EXECUTED
201f5ec: 7f ff ff 90 call 201f42c <msdos_format_printf> <== NOT EXECUTED
201f5f0: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
201f5f4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
201f5f8: 02 80 00 04 be 201f608 <msdos_format_fill_sectors+0x128> <== NEVER TAKEN
201f5fc: 01 00 00 00 nop
free(fill_buffer);
201f600: 7f ff a4 5e call 2008778 <free>
201f604: 90 10 00 10 mov %l0, %o0
fill_buffer = NULL;
}
return ret_val;
}
201f608: 81 c7 e0 08 ret
201f60c: 91 e8 00 1d restore %g0, %i5, %o0
0201f42c <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
201f42c: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
201f430: 94 07 a0 50 add %fp, 0x50, %o2
201f434: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
201f438: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
201f43c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
201f440: d4 27 bf fc st %o2, [ %fp + -4 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
201f444: 80 a6 20 00 cmp %i0, 0
201f448: 02 80 00 0c be 201f478 <msdos_format_printf+0x4c> <== NEVER TAKEN
201f44c: 92 10 00 1a mov %i2, %o1
201f450: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201f454: 80 a0 40 19 cmp %g1, %i1
201f458: 06 80 00 08 bl 201f478 <msdos_format_printf+0x4c> <== ALWAYS TAKEN
201f45c: 3b 00 81 ae sethi %hi(0x206b800), %i5
{
vfprintf (stdout, format, args);
201f460: c2 07 61 68 ld [ %i5 + 0x168 ], %g1 ! 206b968 <_impure_ptr><== NOT EXECUTED
201f464: 40 00 ce bf call 2052f60 <vfprintf> <== NOT EXECUTED
201f468: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
201f46c: c2 07 61 68 ld [ %i5 + 0x168 ], %g1 <== NOT EXECUTED
201f470: 40 00 8b 1c call 20420e0 <fflush> <== NOT EXECUTED
201f474: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
201f478: 81 c7 e0 08 ret
201f47c: 81 e8 00 00 restore
0201f480 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
201f480: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
201f484: 94 10 20 00 clr %o2
201f488: 96 10 00 1a mov %i2, %o3
201f48c: 90 10 20 00 clr %o0
201f490: 40 00 f1 48 call 205b9b0 <__muldi3>
201f494: 92 10 00 19 mov %i1, %o1
201f498: 84 10 00 08 mov %o0, %g2
201f49c: 86 10 00 09 mov %o1, %g3
201f4a0: 90 10 00 18 mov %i0, %o0
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
201f4a4: ba 10 00 18 mov %i0, %i5
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
201f4a8: 92 10 00 02 mov %g2, %o1
201f4ac: 94 10 00 03 mov %g3, %o2
201f4b0: 96 10 20 00 clr %o3
201f4b4: 40 00 24 07 call 20284d0 <lseek>
201f4b8: b0 10 3f ff mov -1, %i0
201f4bc: 80 a2 20 00 cmp %o0, 0
201f4c0: 06 80 00 06 bl 201f4d8 <msdos_format_write_sec+0x58> <== NEVER TAKEN
201f4c4: 90 10 00 1d mov %i5, %o0
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
201f4c8: 92 10 00 1b mov %i3, %o1
201f4cc: 7f ff b5 0b call 200c8f8 <write>
201f4d0: 94 10 00 1a mov %i2, %o2
201f4d4: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
201f4d8: 81 c7 e0 08 ret
201f4dc: 81 e8 00 00 restore
02035558 <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
)
{
2035558: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
203555c: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
2035560: 90 10 00 18 mov %i0, %o0
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
2035564: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
2035568: c0 27 bf fc clr [ %fp + -4 ]
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
203556c: 92 10 00 1a mov %i2, %o1
2035570: 7f ff be 63 call 2024efc <fat_file_open>
2035574: 94 07 bf fc add %fp, -4, %o2
if (rc != RC_OK)
2035578: b0 92 20 00 orcc %o0, 0, %i0
203557c: 12 80 00 9a bne 20357e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28c><== NEVER TAKEN
2035580: d2 07 bf fc ld [ %fp + -4 ], %o1
return rc;
fat_fd->cln = cln;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2035584: 03 00 08 00 sethi %hi(0x200000), %g1
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
2035588: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
203558c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2035590: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
2035594: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
2035598: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(mt_entry, fat_fd);
203559c: 7f ff c1 14 call 20259ec <fat_file_size>
20355a0: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
20355a4: b0 92 20 00 orcc %o0, 0, %i0
20355a8: 12 80 00 1a bne 2035610 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xb8><== NEVER TAKEN
20355ac: 90 10 00 1d mov %i5, %o0
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
20355b0: b2 07 bf b8 add %fp, -72, %i1
20355b4: 92 10 20 00 clr %o1
20355b8: 94 10 20 20 mov 0x20, %o2
20355bc: 40 00 3f 86 call 20453d4 <memset>
20355c0: 90 10 00 19 mov %i1, %o0
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
20355c4: 39 00 81 81 sethi %hi(0x2060400), %i4
20355c8: 92 10 20 01 mov 1, %o1
20355cc: 94 10 00 19 mov %i1, %o2
20355d0: 96 10 20 0b mov 0xb, %o3
20355d4: 7f ff fb 6e call 203438c <msdos_long_to_short>
20355d8: 90 17 23 60 or %i4, 0x360, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
20355dc: d2 07 bf fc ld [ %fp + -4 ], %o1
20355e0: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
20355e4: f2 23 a0 60 st %i1, [ %sp + 0x60 ]
20355e8: 90 10 00 1d mov %i5, %o0
20355ec: 94 10 20 00 clr %o2
20355f0: 96 17 23 60 or %i4, 0x360, %o3
20355f4: 98 10 20 01 mov 1, %o4
20355f8: 7f ff fd 14 call 2034a48 <msdos_find_name_in_fat_file>
20355fc: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
2035600: b0 92 20 00 orcc %o0, 0, %i0
2035604: 02 80 00 05 be 2035618 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc0><== ALWAYS TAKEN
2035608: b8 07 bf d8 add %fp, -40, %i4
{
fat_file_close(mt_entry, fat_fd);
203560c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2035610: 10 80 00 73 b 20357dc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x284><== NOT EXECUTED
2035614: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2035618: 92 10 20 00 clr %o1
203561c: 94 10 20 20 mov 0x20, %o2
2035620: 40 00 3f 6d call 20453d4 <memset>
2035624: 90 10 00 1c mov %i4, %o0
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
2035628: 31 00 81 80 sethi %hi(0x2060000), %i0
203562c: 92 10 20 02 mov 2, %o1
2035630: 90 16 20 80 or %i0, 0x80, %o0
2035634: 94 10 00 1c mov %i4, %o2
2035638: 7f ff fb 55 call 203438c <msdos_long_to_short>
203563c: 96 10 20 0b mov 0xb, %o3
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
2035640: d2 07 bf fc ld [ %fp + -4 ], %o1
2035644: 96 16 20 80 or %i0, 0x80, %o3
2035648: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
203564c: f8 23 a0 60 st %i4, [ %sp + 0x60 ]
2035650: 90 10 00 1d mov %i5, %o0
2035654: 94 10 20 00 clr %o2
2035658: 98 10 20 02 mov 2, %o4
203565c: 7f ff fc fb call 2034a48 <msdos_find_name_in_fat_file>
2035660: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
2035664: b0 92 20 00 orcc %o0, 0, %i0
2035668: 12 80 00 44 bne 2035778 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x220><== NEVER TAKEN
203566c: d2 07 bf fc ld [ %fp + -4 ], %o1
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
2035670: e2 16 60 1a lduh [ %i1 + 0x1a ], %l1
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
2035674: 90 10 00 1d mov %i5, %o0
2035678: 7f ff bf 2c call 2025328 <fat_file_close>
203567c: f2 16 60 14 lduh [ %i1 + 0x14 ], %i1
if ( rc != RC_OK )
2035680: b0 92 20 00 orcc %o0, 0, %i0
2035684: 12 80 00 58 bne 20357e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28c><== NEVER TAKEN
2035688: 03 00 00 3f sethi %hi(0xfc00), %g1
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
203568c: c6 17 20 14 lduh [ %i4 + 0x14 ], %g3
2035690: c4 17 20 1a lduh [ %i4 + 0x1a ], %g2
2035694: 87 28 e0 10 sll %g3, 0x10, %g3
2035698: 89 30 e0 18 srl %g3, 0x18, %g4
203569c: 85 28 a0 10 sll %g2, 0x10, %g2
20356a0: 87 30 e0 08 srl %g3, 8, %g3
20356a4: 82 10 63 ff or %g1, 0x3ff, %g1
20356a8: 86 08 c0 01 and %g3, %g1, %g3
20356ac: 86 11 00 03 or %g4, %g3, %g3
20356b0: 89 30 a0 18 srl %g2, 0x18, %g4
20356b4: 87 28 e0 10 sll %g3, 0x10, %g3
20356b8: 85 30 a0 08 srl %g2, 8, %g2
20356bc: 82 08 80 01 and %g2, %g1, %g1
20356c0: 82 11 00 01 or %g4, %g1, %g1
20356c4: 80 90 c0 01 orcc %g3, %g1, %g0
20356c8: 12 80 00 08 bne 20356e8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x190><== ALWAYS TAKEN
20356cc: 90 10 00 1d mov %i5, %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;
20356d0: 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;
20356d4: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20356d8: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20356dc: 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;
20356e0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
20356e4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
20356e8: 92 10 00 1a mov %i2, %o1
20356ec: 7f ff be 04 call 2024efc <fat_file_open>
20356f0: 94 07 bf fc add %fp, -4, %o2
if (rc != RC_OK)
20356f4: b0 92 20 00 orcc %o0, 0, %i0
20356f8: 12 80 00 3b bne 20357e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28c><== NEVER TAKEN
20356fc: c8 17 bf f2 lduh [ %fp + -14 ], %g4
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
2035700: f8 17 bf ec lduh [ %fp + -20 ], %i4
2035704: 89 29 20 10 sll %g4, 0x10, %g4
2035708: b9 2f 20 10 sll %i4, 0x10, %i4
203570c: 83 31 20 18 srl %g4, 0x18, %g1
2035710: 85 37 20 18 srl %i4, 0x18, %g2
2035714: 07 00 00 3f sethi %hi(0xfc00), %g3
2035718: b9 37 20 08 srl %i4, 8, %i4
203571c: 86 10 e3 ff or %g3, 0x3ff, %g3
2035720: 89 31 20 08 srl %g4, 8, %g4
2035724: b8 0f 00 03 and %i4, %g3, %i4
2035728: 84 10 80 1c or %g2, %i4, %g2
203572c: 86 09 00 03 and %g4, %g3, %g3
2035730: 85 28 a0 10 sll %g2, 0x10, %g2
2035734: 82 10 40 03 or %g1, %g3, %g1
2035738: 82 90 80 01 orcc %g2, %g1, %g1
203573c: 12 80 00 03 bne 2035748 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f0><== ALWAYS TAKEN
2035740: d2 07 bf fc ld [ %fp + -4 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2035744: c2 04 20 38 ld [ %l0 + 0x38 ], %g1 <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
2035748: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
203574c: 03 00 08 00 sethi %hi(0x200000), %g1
2035750: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
2035754: 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;
2035758: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
203575c: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
2035760: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(mt_entry, fat_fd);
2035764: 7f ff c0 a2 call 20259ec <fat_file_size>
2035768: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
203576c: b0 92 20 00 orcc %o0, 0, %i0
2035770: 02 80 00 04 be 2035780 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x228><== ALWAYS TAKEN
2035774: d2 07 bf fc ld [ %fp + -4 ], %o1
{
fat_file_close(mt_entry, fat_fd);
2035778: 10 80 00 19 b 20357dc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x284><== NOT EXECUTED
203577c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
2035780: b3 2e 60 10 sll %i1, 0x10, %i1
2035784: a3 2c 60 10 sll %l1, 0x10, %l1
2035788: 95 36 60 18 srl %i1, 0x18, %o2
203578c: 85 34 60 18 srl %l1, 0x18, %g2
2035790: b3 36 60 08 srl %i1, 8, %i1
2035794: a3 34 60 08 srl %l1, 8, %l1
2035798: 03 00 00 3f sethi %hi(0xfc00), %g1
203579c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
20357a0: b2 0e 40 01 and %i1, %g1, %i1
20357a4: 82 0c 40 01 and %l1, %g1, %g1
20357a8: 94 12 80 19 or %o2, %i1, %o2
20357ac: a2 10 80 01 or %g2, %g1, %l1
20357b0: 95 2a a0 10 sll %o2, 0x10, %o2
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
20357b4: 90 10 00 1d mov %i5, %o0
20357b8: 94 12 80 11 or %o2, %l1, %o2
20357bc: 96 10 00 1a mov %i2, %o3
20357c0: 7f ff ff 01 call 20353c4 <msdos_find_node_by_cluster_num_in_fat_file>
20357c4: 98 10 00 1b mov %i3, %o4
20357c8: d2 07 bf fc ld [ %fp + -4 ], %o1
20357cc: b0 10 00 08 mov %o0, %i0
dir_pos, dir_entry);
if (rc != RC_OK)
20357d0: 80 a6 20 00 cmp %i0, 0
20357d4: 02 80 00 06 be 20357ec <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x294><== ALWAYS TAKEN
20357d8: 90 10 00 1d mov %i5, %o0
{
fat_file_close(mt_entry, fat_fd);
20357dc: 7f ff be d3 call 2025328 <fat_file_close> <== NOT EXECUTED
20357e0: 01 00 00 00 nop <== NOT EXECUTED
return rc;
20357e4: 81 c7 e0 08 ret <== NOT EXECUTED
20357e8: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = fat_file_close(mt_entry, fat_fd);
20357ec: 7f ff be cf call 2025328 <fat_file_close>
20357f0: 01 00 00 00 nop
20357f4: b0 10 00 08 mov %o0, %i0
return rc;
}
20357f8: 81 c7 e0 08 ret
20357fc: 81 e8 00 00 restore
02035800 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
2035800: 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,
2035804: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
2035808: 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
)
{
203580c: 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,
2035810: 9a 10 00 1c mov %i4, %o5
2035814: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
2035818: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
203581c: 94 10 00 19 mov %i1, %o2
2035820: 96 10 00 1a mov %i2, %o3
2035824: 7f ff fc 89 call 2034a48 <msdos_find_name_in_fat_file>
2035828: 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))
203582c: 03 00 00 1f sethi %hi(0x7c00), %g1
2035830: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
2035834: 80 a2 00 01 cmp %o0, %g1
2035838: 02 80 00 05 be 203584c <msdos_get_name_node+0x4c>
203583c: b8 10 00 08 mov %o0, %i4
2035840: 80 a2 20 00 cmp %o0, 0
2035844: 12 80 00 2d bne 20358f8 <msdos_get_name_node+0xf8> <== NEVER TAKEN
2035848: 01 00 00 00 nop
return rc;
if (!create_node)
203584c: 80 a6 60 00 cmp %i1, 0
2035850: 12 80 00 2a bne 20358f8 <msdos_get_name_node+0xf8>
2035854: 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)
2035858: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
203585c: 80 a7 00 01 cmp %i4, %g1
2035860: 02 80 00 26 be 20358f8 <msdos_get_name_node+0xf8>
2035864: 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)
2035868: 12 80 00 24 bne 20358f8 <msdos_get_name_node+0xf8> <== NEVER TAKEN
203586c: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
2035870: 13 00 81 80 sethi %hi(0x2060000), %o1
2035874: 94 10 20 02 mov 2, %o2
2035878: 40 00 4d 98 call 2048ed8 <strncmp>
203587c: 92 12 60 80 or %o1, 0x80, %o1
2035880: 80 a2 20 00 cmp %o0, 0
2035884: 12 80 00 1d bne 20358f8 <msdos_get_name_node+0xf8>
2035888: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
203588c: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
2035890: c8 14 20 14 lduh [ %l0 + 0x14 ], %g4
2035894: 87 28 e0 10 sll %g3, 0x10, %g3
2035898: 89 29 20 10 sll %g4, 0x10, %g4
203589c: b3 30 e0 18 srl %g3, 0x18, %i1
20358a0: 83 31 20 18 srl %g4, 0x18, %g1
20358a4: 89 31 20 08 srl %g4, 8, %g4
20358a8: 84 10 a3 ff or %g2, 0x3ff, %g2
20358ac: 87 30 e0 08 srl %g3, 8, %g3
20358b0: 88 09 00 02 and %g4, %g2, %g4
20358b4: 84 08 c0 02 and %g3, %g2, %g2
20358b8: 82 10 40 04 or %g1, %g4, %g1
20358bc: b2 16 40 02 or %i1, %g2, %i1
20358c0: 83 28 60 10 sll %g1, 0x10, %g1
/* are we right under root dir ? */
if (dotdot_cln == 0)
20358c4: b2 90 40 19 orcc %g1, %i1, %i1
20358c8: 12 80 00 08 bne 20358e8 <msdos_get_name_node+0xe8>
20358cc: 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;
20358d0: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20358d4: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20358d8: 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;
20358dc: 82 10 20 01 mov 1, %g1
20358e0: 10 80 00 06 b 20358f8 <msdos_get_name_node+0xf8>
20358e4: c2 27 40 00 st %g1, [ %i5 ]
}
else
{
rc =
20358e8: f0 06 20 18 ld [ %i0 + 0x18 ], %i0
20358ec: b4 10 00 1d mov %i5, %i2
20358f0: 7f ff ff 1a call 2035558 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
20358f4: 97 e8 00 10 restore %g0, %l0, %o3
}
}
}
}
return rc;
}
20358f8: 81 c7 e0 08 ret
20358fc: 91 e8 00 1c restore %g0, %i4, %o0
02020390 <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
)
{
2020390: 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));
2020394: 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;
2020398: c0 27 bf fc clr [ %fp + -4 ]
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
202039c: 92 10 20 98 mov 0x98, %o1
20203a0: 7f ff a0 18 call 2008400 <calloc>
20203a4: ba 10 00 18 mov %i0, %i5
if (!fs_info)
20203a8: b8 92 20 00 orcc %o0, 0, %i4
20203ac: 02 80 00 48 be 20204cc <msdos_initialize_support+0x13c> <== NEVER TAKEN
20203b0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
20203b4: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
rc = fat_init_volume_info(temp_mt_entry);
20203b8: 40 00 17 e9 call 202635c <fat_init_volume_info>
20203bc: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
20203c0: b0 92 20 00 orcc %o0, 0, %i0
20203c4: 12 80 00 13 bne 2020410 <msdos_initialize_support+0x80> <== NEVER TAKEN
20203c8: 01 00 00 00 nop
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20203cc: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xfdbfffff>
20203d0: c2 27 bf f4 st %g1, [ %fp + -12 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20203d4: c2 27 bf f8 st %g1, [ %fp + -8 ]
/*
* 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;
20203d8: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
20203dc: f4 27 20 8c st %i2, [ %i4 + 0x8c ]
fs_info->directory_handlers = directory_handlers;
20203e0: f6 27 20 88 st %i3, [ %i4 + 0x88 ]
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
20203e4: c0 27 bf f0 clr [ %fp + -16 ]
/*
* 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;
20203e8: c2 27 bf ec st %g1, [ %fp + -20 ]
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
20203ec: 90 10 00 1d mov %i5, %o0
20203f0: 92 07 bf ec add %fp, -20, %o1
20203f4: 40 00 12 c2 call 2024efc <fat_file_open>
20203f8: 94 07 bf fc add %fp, -4, %o2
if (rc != RC_OK)
20203fc: b0 92 20 00 orcc %o0, 0, %i0
2020400: 02 80 00 08 be 2020420 <msdos_initialize_support+0x90> <== ALWAYS TAKEN
2020404: d2 07 bf fc ld [ %fp + -4 ], %o1
{
fat_shutdown_drive(temp_mt_entry);
2020408: 40 00 17 90 call 2026248 <fat_shutdown_drive> <== NOT EXECUTED
202040c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
2020410: 7f ff a0 da call 2008778 <free> <== NOT EXECUTED
2020414: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rc;
2020418: 81 c7 e0 08 ret <== NOT EXECUTED
202041c: 81 e8 00 00 restore <== NOT EXECUTED
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2020420: 03 00 08 00 sethi %hi(0x200000), %g1
2020424: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2020428: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
202042c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2020430: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
2020434: 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 )
2020438: 80 a0 60 00 cmp %g1, 0
202043c: 12 80 00 09 bne 2020460 <msdos_initialize_support+0xd0> <== NEVER TAKEN
2020440: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
2020444: c2 07 20 28 ld [ %i4 + 0x28 ], %g1
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
2020448: d0 17 20 06 lduh [ %i4 + 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) ?
202044c: 80 a2 00 01 cmp %o0, %g1
2020450: 1a 80 00 13 bcc 202049c <msdos_initialize_support+0x10c> <== NEVER TAKEN
2020454: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
2020458: 10 80 00 11 b 202049c <msdos_initialize_support+0x10c>
202045c: 90 10 00 01 mov %g1, %o0
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
2020460: 40 00 15 63 call 20259ec <fat_file_size> <== NOT EXECUTED
2020464: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if ( rc != RC_OK )
2020468: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
202046c: 22 80 00 0c be,a 202049c <msdos_initialize_support+0x10c><== NOT EXECUTED
2020470: d0 17 20 06 lduh [ %i4 + 6 ], %o0 <== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
2020474: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
2020478: 40 00 13 ac call 2025328 <fat_file_close> <== NOT EXECUTED
202047c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
2020480: 40 00 17 72 call 2026248 <fat_shutdown_drive> <== NOT EXECUTED
2020484: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
2020488: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
202048c: 7f ff a0 bb call 2008778 <free> <== NOT EXECUTED
2020490: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
2020494: 81 c7 e0 08 ret <== NOT EXECUTED
2020498: 81 e8 00 00 restore <== NOT EXECUTED
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
202049c: 7f ff 9f d9 call 2008400 <calloc>
20204a0: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
20204a4: 80 a2 20 00 cmp %o0, 0
20204a8: 12 80 00 0d bne 20204dc <msdos_initialize_support+0x14c> <== ALWAYS TAKEN
20204ac: d0 27 20 94 st %o0, [ %i4 + 0x94 ]
{
fat_file_close(temp_mt_entry, fat_fd);
20204b0: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
20204b4: 40 00 13 9d call 2025328 <fat_file_close> <== NOT EXECUTED
20204b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
20204bc: 40 00 17 63 call 2026248 <fat_shutdown_drive> <== NOT EXECUTED
20204c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
20204c4: 7f ff a0 ad call 2008778 <free> <== NOT EXECUTED
20204c8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
20204cc: 40 00 85 f5 call 2041ca0 <__errno> <== NOT EXECUTED
20204d0: 01 00 00 00 nop <== NOT EXECUTED
20204d4: 10 80 00 16 b 202052c <msdos_initialize_support+0x19c> <== NOT EXECUTED
20204d8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
20204dc: 92 10 20 01 mov 1, %o1
20204e0: 90 10 20 03 mov 3, %o0
20204e4: 94 10 20 10 mov 0x10, %o2
20204e8: 96 10 20 00 clr %o3
20204ec: 7f ff b2 60 call 200ce6c <rtems_semaphore_create>
20204f0: 98 07 20 90 add %i4, 0x90, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
20204f4: 80 a2 20 00 cmp %o0, 0
20204f8: 02 80 00 10 be 2020538 <msdos_initialize_support+0x1a8> <== ALWAYS TAKEN
20204fc: d2 07 bf fc ld [ %fp + -4 ], %o1
{
fat_file_close(temp_mt_entry, fat_fd);
2020500: 40 00 13 8a call 2025328 <fat_file_close> <== NOT EXECUTED
2020504: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
2020508: 40 00 17 50 call 2026248 <fat_shutdown_drive> <== NOT EXECUTED
202050c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
2020510: 7f ff a0 9a call 2008778 <free> <== NOT EXECUTED
2020514: d0 07 20 94 ld [ %i4 + 0x94 ], %o0 <== NOT EXECUTED
free(fs_info);
2020518: 7f ff a0 98 call 2008778 <free> <== NOT EXECUTED
202051c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
2020520: 40 00 85 e0 call 2041ca0 <__errno> <== NOT EXECUTED
2020524: 01 00 00 00 nop <== NOT EXECUTED
2020528: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
202052c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2020530: 81 c7 e0 08 ret <== NOT EXECUTED
2020534: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
2020538: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
202053c: d2 20 60 08 st %o1, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
2020540: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
temp_mt_entry->mt_fs_root->location.ops = op_table;
2020544: f2 20 60 14 st %i1, [ %g1 + 0x14 ]
return rc;
}
2020548: 81 c7 e0 08 ret
202054c: 81 e8 00 00 restore
0202035c <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(rtems_filesystem_mount_table_entry_t *mt_entry)
{
202035c: 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,
2020360: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
};
void msdos_lock(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(
2020364: 92 10 20 00 clr %o1
2020368: d0 00 60 90 ld [ %g1 + 0x90 ], %o0
202036c: 7f ff b3 74 call 200d13c <rtems_semaphore_obtain>
2020370: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
2020374: 80 a2 20 00 cmp %o0, 0
2020378: 02 80 00 04 be 2020388 <msdos_lock+0x2c> <== ALWAYS TAKEN
202037c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
2020380: 7f ff b5 7d call 200d974 <rtems_fatal_error_occurred> <== NOT EXECUTED
2020384: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2020388: 81 c7 e0 08 ret
202038c: 81 e8 00 00 restore
0203438c <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)
{
203438c: 9d e3 bf a0 save %sp, -96, %sp
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
2034390: 92 10 20 20 mov 0x20, %o1
2034394: 90 10 00 1a mov %i2, %o0
2034398: 40 00 44 0f call 20453d4 <memset>
203439c: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
20343a0: c2 4e 00 00 ldsb [ %i0 ], %g1
20343a4: 82 18 60 2e xor %g1, 0x2e, %g1
20343a8: 80 a0 00 01 cmp %g0, %g1
20343ac: 84 60 3f ff subx %g0, -1, %g2
20343b0: 80 a6 60 01 cmp %i1, 1
20343b4: 12 80 00 09 bne 20343d8 <msdos_long_to_short+0x4c>
20343b8: ba 10 00 18 mov %i0, %i5
20343bc: 80 a0 a0 00 cmp %g2, 0
20343c0: 02 80 00 19 be 2034424 <msdos_long_to_short+0x98>
20343c4: 82 10 20 00 clr %g1
{
sfn[0] = '.';
20343c8: 82 10 20 2e mov 0x2e, %g1
20343cc: c2 2e 80 00 stb %g1, [ %i2 ]
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
20343d0: 81 c7 e0 08 ret
20343d4: 91 e8 20 01 restore %g0, 1, %o0
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
20343d8: 80 a0 a0 00 cmp %g2, 0
20343dc: 02 80 00 12 be 2034424 <msdos_long_to_short+0x98>
20343e0: 82 10 20 00 clr %g1
20343e4: 80 a6 60 02 cmp %i1, 2
20343e8: 12 80 00 10 bne 2034428 <msdos_long_to_short+0x9c> <== NEVER TAKEN
20343ec: 80 a0 40 19 cmp %g1, %i1
20343f0: c2 4f 60 01 ldsb [ %i5 + 1 ], %g1
20343f4: 80 a0 60 2e cmp %g1, 0x2e
20343f8: 02 80 00 75 be 20345cc <msdos_long_to_short+0x240> <== ALWAYS TAKEN
20343fc: 82 10 20 00 clr %g1
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
2034400: 10 80 00 0a b 2034428 <msdos_long_to_short+0x9c> <== NOT EXECUTED
2034404: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
if ((lfn[i] != ' ') && (lfn[i] != '.'))
2034408: 80 a0 a0 2e cmp %g2, 0x2e
203440c: 22 80 00 06 be,a 2034424 <msdos_long_to_short+0x98> <== NEVER TAKEN
2034410: 82 00 60 01 inc %g1 <== NOT EXECUTED
2034414: 80 a0 a0 20 cmp %g2, 0x20
2034418: 12 80 00 07 bne 2034434 <msdos_long_to_short+0xa8>
203441c: 80 a0 40 19 cmp %g1, %i1
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
2034420: 82 00 60 01 inc %g1
2034424: 80 a0 40 19 cmp %g1, %i1
2034428: 26 bf ff f8 bl,a 2034408 <msdos_long_to_short+0x7c> <== ALWAYS TAKEN
203442c: c4 4f 40 01 ldsb [ %i5 + %g1 ], %g2
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
2034430: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
2034434: 02 80 00 64 be 20345c4 <msdos_long_to_short+0x238> <== NEVER TAKEN
2034438: b0 10 20 00 clr %i0
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
203443c: 2f 00 81 9a sethi %hi(0x2066800), %l7
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2034440: 2b 00 81 9a sethi %hi(0x2066800), %l5
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
2034444: b6 10 20 00 clr %i3
2034448: b0 10 3f ff mov -1, %i0
203444c: a4 10 20 00 clr %l2
2034450: a6 10 20 00 clr %l3
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2034454: ae 15 e3 78 or %l7, 0x378, %l7
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2034458: 2d 00 81 ae sethi %hi(0x206b800), %l6
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
203445c: 10 80 00 41 b 2034560 <msdos_long_to_short+0x1d4>
2034460: aa 15 63 80 or %l5, 0x380, %l5
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2034464: a3 3c 60 18 sra %l1, 0x18, %l1
2034468: 82 1c 60 2e xor %l1, 0x2e, %g1
203446c: 80 a0 00 01 cmp %g0, %g1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2034470: 90 10 00 17 mov %l7, %o0
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2034474: 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)
2034478: 92 10 00 11 mov %l1, %o1
203447c: 40 00 4f a3 call 2048308 <strchr>
2034480: b8 10 20 02 mov 2, %i4
2034484: 80 a2 20 00 cmp %o0, 0
2034488: 12 80 00 12 bne 20344d0 <msdos_long_to_short+0x144>
203448c: 80 a7 20 02 cmp %i4, 2
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2034490: 80 8d 20 ff btst 0xff, %l4
2034494: 12 80 00 0e bne 20344cc <msdos_long_to_short+0x140>
2034498: b8 10 20 01 mov 1, %i4
203449c: c4 05 a1 58 ld [ %l6 + 0x158 ], %g2
20344a0: 82 0c 20 ff and %l0, 0xff, %g1
20344a4: 82 00 80 01 add %g2, %g1, %g1
20344a8: c2 08 60 01 ldub [ %g1 + 1 ], %g1
20344ac: 80 88 60 07 btst 7, %g1
20344b0: 12 80 00 08 bne 20344d0 <msdos_long_to_short+0x144>
20344b4: 80 a7 20 02 cmp %i4, 2
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
20344b8: 90 10 00 15 mov %l5, %o0
20344bc: 40 00 4f 93 call 2048308 <strchr>
20344c0: 92 10 00 11 mov %l1, %o1
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
20344c4: 80 a0 00 08 cmp %g0, %o0
20344c8: b8 40 20 00 addx %g0, 0, %i4
#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))
20344cc: 80 a7 20 02 cmp %i4, 2
20344d0: 02 80 00 35 be 20345a4 <msdos_long_to_short+0x218>
20344d4: 80 a7 20 00 cmp %i4, 0
20344d8: 02 80 00 33 be 20345a4 <msdos_long_to_short+0x218> <== NEVER TAKEN
20344dc: 80 a6 3f ff cmp %i0, -1
return type;
if (dot_at >= 0)
20344e0: 02 80 00 0a be 2034508 <msdos_long_to_short+0x17c>
20344e4: a8 0d 20 ff and %l4, 0xff, %l4
{
if (is_dot || ((count - dot_at) > 3))
20344e8: 80 a5 20 00 cmp %l4, 0
20344ec: 12 80 00 3e bne 20345e4 <msdos_long_to_short+0x258> <== ALWAYS TAKEN
20344f0: 82 26 c0 18 sub %i3, %i0, %g1
20344f4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
20344f8: 04 80 00 0e ble 2034530 <msdos_long_to_short+0x1a4> <== NOT EXECUTED
20344fc: 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;
2034500: 10 80 00 2c b 20345b0 <msdos_long_to_short+0x224> <== NOT EXECUTED
2034504: b8 10 20 02 mov 2, %i4 <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
2034508: 80 a6 e0 08 cmp %i3, 8
203450c: 12 80 00 06 bne 2034524 <msdos_long_to_short+0x198>
2034510: 80 a5 20 00 cmp %l4, 0
2034514: 02 80 00 27 be 20345b0 <msdos_long_to_short+0x224> <== ALWAYS TAKEN
2034518: b8 10 20 02 mov 2, %i4
203451c: 10 80 00 10 b 203455c <msdos_long_to_short+0x1d0> <== NOT EXECUTED
2034520: b0 10 20 08 mov 8, %i0 <== NOT EXECUTED
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
2034524: 32 80 00 0e bne,a 203455c <msdos_long_to_short+0x1d0>
2034528: b0 10 00 1b mov %i3, %i0
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
203452c: 82 04 3f bf add %l0, -65, %g1
2034530: 82 08 60 ff and %g1, 0xff, %g1
2034534: 80 a0 60 19 cmp %g1, 0x19
2034538: 28 80 00 09 bleu,a 203455c <msdos_long_to_short+0x1d0>
203453c: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
2034540: a0 04 3f 9f add %l0, -97, %l0
2034544: a0 0c 20 ff and %l0, 0xff, %l0
2034548: 80 a4 20 19 cmp %l0, 0x19
203454c: 28 80 00 04 bleu,a 203455c <msdos_long_to_short+0x1d0>
2034550: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
2034554: 10 80 00 03 b 2034560 <msdos_long_to_short+0x1d4>
2034558: b6 06 e0 01 inc %i3
203455c: b6 06 e0 01 inc %i3
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
2034560: c2 4f 40 1b ldsb [ %i5 + %i3 ], %g1
2034564: 80 a0 60 00 cmp %g1, 0
2034568: 02 80 00 09 be 203458c <msdos_long_to_short+0x200>
203456c: e0 0f 40 1b ldub [ %i5 + %i3 ], %l0
2034570: 80 a6 c0 19 cmp %i3, %i1
2034574: 06 80 00 03 bl 2034580 <msdos_long_to_short+0x1f4>
2034578: 82 10 20 01 mov 1, %g1
203457c: 82 10 20 00 clr %g1
2034580: 80 88 60 ff btst 0xff, %g1
2034584: 12 bf ff b8 bne 2034464 <msdos_long_to_short+0xd8>
2034588: a3 2c 20 18 sll %l0, 0x18, %l1
count++;
name++;
}
if (lowercase && uppercase)
203458c: 80 8c e0 ff btst 0xff, %l3
2034590: 02 80 00 08 be 20345b0 <msdos_long_to_short+0x224>
2034594: b8 10 20 01 mov 1, %i4
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
2034598: b8 0c a0 01 and %l2, 1, %i4
203459c: 10 80 00 05 b 20345b0 <msdos_long_to_short+0x224>
20345a0: b8 07 20 01 inc %i4
* Is this a short name ?
*/
type = msdos_name_type (lfn, lfn_len);
if (type == MSDOS_NAME_INVALID)
20345a4: b0 97 20 00 orcc %i4, 0, %i0
20345a8: 02 80 00 0d be 20345dc <msdos_long_to_short+0x250> <== NEVER TAKEN
20345ac: 01 00 00 00 nop
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
20345b0: 90 10 00 1d mov %i5, %o0
20345b4: 92 10 00 19 mov %i1, %o1
20345b8: 94 10 00 1a mov %i2, %o2
20345bc: 40 00 2e 2f call 203fe78 <msdos_filename_unix2dos>
20345c0: b0 10 00 1c mov %i4, %i0
20345c4: 81 c7 e0 08 ret
20345c8: 81 e8 00 00 restore
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
20345cc: 82 10 20 2e mov 0x2e, %g1
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
20345d0: b0 10 20 01 mov 1, %i0
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
20345d4: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
20345d8: c2 2e 80 00 stb %g1, [ %i2 ]
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
20345dc: 81 c7 e0 08 ret
20345e0: 81 e8 00 00 restore
{
#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;
20345e4: 10 bf ff f3 b 20345b0 <msdos_long_to_short+0x224>
20345e8: b8 10 20 02 mov 2, %i4
02020550 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2020550: 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))
2020554: 07 00 00 3c sethi %hi(0xf000), %g3
2020558: 09 00 00 10 sethi %hi(0x4000), %g4
202055c: 86 0e c0 03 and %i3, %g3, %g3
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2020560: 84 10 00 19 mov %i1, %g2
2020564: 82 10 00 1a mov %i2, %g1
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
2020568: 80 a0 c0 04 cmp %g3, %g4
202056c: 02 80 00 0c be 202059c <msdos_mknod+0x4c>
2020570: b8 10 00 1b mov %i3, %i4
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
2020574: 09 00 00 20 sethi %hi(0x8000), %g4
2020578: 80 a0 c0 04 cmp %g3, %g4
202057c: 02 80 00 09 be 20205a0 <msdos_mknod+0x50> <== ALWAYS TAKEN
2020580: b2 10 20 04 mov 4, %i1
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
2020584: 40 00 85 c7 call 2041ca0 <__errno> <== NOT EXECUTED
2020588: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202058c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2020590: 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;
}
2020594: 81 c7 e0 08 ret <== NOT EXECUTED
2020598: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
202059c: 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);
20205a0: b4 10 00 02 mov %g2, %i2
20205a4: b6 10 00 01 mov %g1, %i3
20205a8: 40 00 4e 22 call 2033e30 <msdos_creat_node>
20205ac: 9b e8 20 00 restore %g0, 0, %o5
020205bc <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
)
{
20205bc: 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;
20205c0: 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,
20205c4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20205c8: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
20205cc: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
20205d0: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
20205d4: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
20205d8: 40 00 4e 16 call 2033e30 <msdos_creat_node> <== NOT EXECUTED
20205dc: 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)
20205e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20205e4: 12 80 00 05 bne 20205f8 <msdos_rename+0x3c> <== NOT EXECUTED
20205e8: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
20205ec: f0 06 60 18 ld [ %i1 + 0x18 ], %i0 <== NOT EXECUTED
20205f0: 40 00 50 81 call 20347f4 <msdos_set_first_char4file_name> <== NOT EXECUTED
20205f4: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
20205f8: 81 c7 e0 08 ret <== NOT EXECUTED
20205fc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02020600 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
2020600: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = pathloc->node_access;
2020604: fa 06 60 08 ld [ %i1 + 8 ], %i5
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
2020608: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
202060c: 80 a0 60 00 cmp %g1, 0
2020610: 12 80 00 22 bne 2020698 <msdos_rmnod+0x98>
2020614: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
{
bool is_empty = false;
2020618: 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);
202061c: 92 10 00 1d mov %i5, %o1
2020620: 40 00 50 be call 2034918 <msdos_dir_is_empty>
2020624: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
2020628: b0 92 20 00 orcc %o0, 0, %i0
202062c: 12 80 00 24 bne 20206bc <msdos_rmnod+0xbc> <== NEVER TAKEN
2020630: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
2020634: 80 a0 60 00 cmp %g1, 0
2020638: 32 80 00 06 bne,a 2020650 <msdos_rmnod+0x50>
202063c: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
2020640: 40 00 85 98 call 2041ca0 <__errno>
2020644: 01 00 00 00 nop
2020648: 10 80 00 11 b 202068c <msdos_rmnod+0x8c>
202064c: 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)
2020650: 80 a0 60 01 cmp %g1, 1
2020654: 18 80 00 0b bgu 2020680 <msdos_rmnod+0x80> <== NEVER TAKEN
2020658: 01 00 00 00 nop
static inline bool rtems_filesystem_location_is_root(
const rtems_filesystem_location_info_t *loc
)
{
return (*loc->ops->are_nodes_equal_h)(
202065c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
loc,
&loc->mt_entry->mt_fs_root->location
2020660: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
static inline bool rtems_filesystem_location_is_root(
const rtems_filesystem_location_info_t *loc
)
{
return (*loc->ops->are_nodes_equal_h)(
2020664: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2020668: d2 00 a0 18 ld [ %g2 + 0x18 ], %o1
202066c: 9f c0 40 00 call %g1
2020670: 90 10 00 19 mov %i1, %o0
}
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_location_is_root(pathloc))
2020674: 80 8a 20 ff btst 0xff, %o0
2020678: 22 80 00 08 be,a 2020698 <msdos_rmnod+0x98> <== ALWAYS TAKEN
202067c: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
2020680: 40 00 85 88 call 2041ca0 <__errno> <== NOT EXECUTED
2020684: 01 00 00 00 nop <== NOT EXECUTED
2020688: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
202068c: c2 22 00 00 st %g1, [ %o0 ]
2020690: 81 c7 e0 08 ret
2020694: 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,
2020698: 92 07 60 20 add %i5, 0x20, %o1
202069c: 40 00 50 56 call 20347f4 <msdos_set_first_char4file_name>
20206a0: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
20206a4: b0 92 20 00 orcc %o0, 0, %i0
20206a8: 12 80 00 05 bne 20206bc <msdos_rmnod+0xbc> <== NEVER TAKEN
20206ac: 01 00 00 00 nop
{
return rc;
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
20206b0: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
20206b4: 40 00 14 7d call 20258a8 <fat_file_mark_removed>
20206b8: 92 10 00 1d mov %i5, %o1
return rc;
}
20206bc: 81 c7 e0 08 ret
20206c0: 81 e8 00 00 restore
020345ec <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
)
{
20345ec: 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);
20345f0: 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;
20345f4: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
20345f8: 94 07 bf fc add %fp, -4, %o2
20345fc: 40 00 2d 85 call 203fc10 <msdos_date_unix2dos>
2034600: 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(mt_entry, fat_fd->dir_pos.sname.cln);
2034604: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
2034608: 7f ff ff 52 call 2034350 <fat_cluster_num_to_sector_num>
203460c: 90 10 00 18 mov %i0, %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034610: 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);
2034614: fa 16 c0 00 lduh [ %i3 ], %i5
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034618: f8 0e e0 02 ldub [ %i3 + 2 ], %i4
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
203461c: ba 07 7f ff add %i5, -1, %i5
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034620: b9 30 40 1c srl %g1, %i4, %i4
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034624: ba 0f 40 01 and %i5, %g1, %i5
time_val = CT_LE_W(time_val);
2034628: 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(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
203462c: b8 02 00 1c add %o0, %i4, %i4
/* 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);
2034630: 83 28 60 10 sll %g1, 0x10, %g1
2034634: 85 30 60 08 srl %g1, 8, %g2
2034638: 83 30 60 18 srl %g1, 0x18, %g1
203463c: 82 10 80 01 or %g2, %g1, %g1
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2034640: 92 10 00 1c mov %i4, %o1
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
2034644: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2034648: 94 07 60 16 add %i5, 0x16, %o2
203464c: 96 10 20 02 mov 2, %o3
2034650: 98 07 bf fc add %fp, -4, %o4
2034654: 7f ff c6 17 call 2025eb0 <_fat_block_write>
2034658: 90 10 00 18 mov %i0, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
203465c: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034660: 92 10 00 1c mov %i4, %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(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
2034664: 83 28 60 10 sll %g1, 0x10, %g1
2034668: 85 30 60 08 srl %g1, 8, %g2
203466c: 83 30 60 18 srl %g1, 0x18, %g1
2034670: 82 10 80 01 or %g2, %g1, %g1
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034674: 94 07 60 18 add %i5, 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(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
2034678: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
203467c: 96 10 20 02 mov 2, %o3
2034680: 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(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2034684: b6 10 00 08 mov %o0, %i3
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034688: 7f ff c6 0a call 2025eb0 <_fat_block_write>
203468c: 90 10 00 18 mov %i0, %o0
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2034690: 92 10 00 1c mov %i4, %o1
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034694: b4 10 00 08 mov %o0, %i2
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2034698: 94 07 60 12 add %i5, 0x12, %o2
203469c: 90 10 00 18 mov %i0, %o0
20346a0: 96 10 20 02 mov 2, %o3
20346a4: 7f ff c6 03 call 2025eb0 <_fat_block_write>
20346a8: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
20346ac: 80 a6 a0 00 cmp %i2, 0
20346b0: 06 80 00 07 bl 20346cc <msdos_set_dir_wrt_time_and_date+0xe0><== NEVER TAKEN
20346b4: 80 a6 e0 00 cmp %i3, 0
20346b8: 06 80 00 05 bl 20346cc <msdos_set_dir_wrt_time_and_date+0xe0><== NEVER TAKEN
20346bc: 01 00 00 00 nop
return -1;
20346c0: b1 3a 20 1f sra %o0, 0x1f, %i0
20346c4: 81 c7 e0 08 ret
20346c8: 81 e8 00 00 restore
return RC_OK;
}
20346cc: 81 c7 e0 08 ret <== NOT EXECUTED
20346d0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
020347f4 <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
)
{
20347f4: 9d e3 bf 98 save %sp, -104, %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;
20347f8: 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;
20347fc: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
2034800: c2 27 bf f8 st %g1, [ %fp + -8 ]
2034804: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fat_pos_t end = dir_pos->sname;
2034808: f6 06 40 00 ld [ %i1 ], %i3
)
{
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;
203480c: c2 27 bf fc st %g1, [ %fp + -4 ]
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
2034810: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
2034814: f4 2f a0 4c stb %i2, [ %fp + 0x4c ]
2034818: ba 10 00 18 mov %i0, %i5
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) &&
203481c: 80 a6 c0 01 cmp %i3, %g1
2034820: 12 80 00 08 bne 2034840 <msdos_set_first_char4file_name+0x4c><== NEVER TAKEN
2034824: e0 06 60 04 ld [ %i1 + 4 ], %l0
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2034828: c2 0f 20 0a ldub [ %i4 + 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) &&
203482c: 80 88 60 03 btst 3, %g1
2034830: 22 80 00 05 be,a 2034844 <msdos_set_first_char4file_name+0x50><== NEVER TAKEN
2034834: f4 17 20 06 lduh [ %i4 + 6 ], %i2 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
2034838: 10 80 00 03 b 2034844 <msdos_set_first_char4file_name+0x50>
203483c: f4 07 20 28 ld [ %i4 + 0x28 ], %i2
else
dir_block_size = fs_info->fat.vol.bpc;
2034840: f4 17 20 06 lduh [ %i4 + 6 ], %i2 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
2034844: c2 06 60 08 ld [ %i1 + 8 ], %g1
2034848: 80 a0 7f ff cmp %g1, -1
203484c: 12 80 00 07 bne 2034868 <msdos_set_first_char4file_name+0x74>
2034850: d2 07 bf f8 ld [ %fp + -8 ], %o1
start = dir_pos->sname;
2034854: c2 06 40 00 ld [ %i1 ], %g1
2034858: c2 27 bf f8 st %g1, [ %fp + -8 ]
203485c: c2 06 60 04 ld [ %i1 + 4 ], %g1
2034860: c2 27 bf fc st %g1, [ %fp + -4 ]
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
2034864: d2 07 bf f8 ld [ %fp + -8 ], %o1
2034868: 7f ff fe ba call 2034350 <fat_cluster_num_to_sector_num>
203486c: 90 10 00 1d mov %i5, %o0
(start.ofs >> fs_info->fat.vol.sec_log2));
2034870: c2 07 bf fc ld [ %fp + -4 ], %g1
2034874: d2 0f 20 02 ldub [ %i4 + 2 ], %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
2034878: d4 17 00 00 lduh [ %i4 ], %o2
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
203487c: 93 30 40 09 srl %g1, %o1, %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
2034880: 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(mt_entry, start.cln) +
2034884: 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(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
2034888: 94 0a 80 01 and %o2, %g1, %o2
203488c: 90 10 00 1d mov %i5, %o0
2034890: 96 10 20 01 mov 1, %o3
2034894: 7f ff c5 87 call 2025eb0 <_fat_block_write>
2034898: 98 07 a0 4c add %fp, 0x4c, %o4
&fchar);
if (ret < 0)
203489c: 80 a2 20 00 cmp %o0, 0
20348a0: 06 80 00 1b bl 203490c <msdos_set_first_char4file_name+0x118><== NEVER TAKEN
20348a4: d2 07 bf f8 ld [ %fp + -8 ], %o1
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
20348a8: 80 a2 40 1b cmp %o1, %i3
20348ac: 12 80 00 05 bne 20348c0 <msdos_set_first_char4file_name+0xcc><== NEVER TAKEN
20348b0: c2 07 bf fc ld [ %fp + -4 ], %g1
20348b4: 80 a0 40 10 cmp %g1, %l0
20348b8: 02 80 00 16 be 2034910 <msdos_set_first_char4file_name+0x11c>
20348bc: 90 10 20 00 clr %o0
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
20348c0: 82 00 60 20 add %g1, 0x20, %g1
if (start.ofs >= dir_block_size)
20348c4: 80 a0 40 1a cmp %g1, %i2
20348c8: 0a bf ff e7 bcs 2034864 <msdos_set_first_char4file_name+0x70><== ALWAYS TAKEN
20348cc: c2 27 bf fc st %g1, [ %fp + -4 ]
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
20348d0: c2 07 20 38 ld [ %i4 + 0x38 ], %g1 <== NOT EXECUTED
20348d4: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
20348d8: 12 80 00 06 bne 20348f0 <msdos_set_first_char4file_name+0xfc><== NOT EXECUTED
20348dc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
20348e0: c2 0f 20 0a ldub [ %i4 + 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) &&
20348e4: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
20348e8: 32 80 00 0a bne,a 2034910 <msdos_set_first_char4file_name+0x11c><== NOT EXECUTED
20348ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
20348f0: 40 00 22 e6 call 203d488 <fat_get_fat_cluster> <== NOT EXECUTED
20348f4: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
20348f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20348fc: 12 80 00 05 bne 2034910 <msdos_set_first_char4file_name+0x11c><== NOT EXECUTED
2034900: 01 00 00 00 nop <== NOT EXECUTED
return rc;
start.ofs = 0;
2034904: 10 bf ff d8 b 2034864 <msdos_set_first_char4file_name+0x70><== NOT EXECUTED
2034908: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
203490c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
}
}
return RC_OK;
}
2034910: 81 c7 e0 08 ret
2034914: 91 e8 00 08 restore %g0, %o0, %o0
020346d4 <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
)
{
20346d4: 9d e3 bf 98 save %sp, -104, %sp
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
20346d8: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
20346dc: f4 06 20 20 ld [ %i0 + 0x20 ], %i2
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
20346e0: c0 37 bf fc clrh [ %fp + -4 ]
uint16_t le_cl_hi = 0;
20346e4: 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(mt_entry, fat_fd->dir_pos.sname.cln);
20346e8: 7f ff ff 1a call 2034350 <fat_cluster_num_to_sector_num>
20346ec: 90 10 00 18 mov %i0, %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
20346f0: 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);
20346f4: fa 16 80 00 lduh [ %i2 ], %i5
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;
20346f8: f6 06 60 1c ld [ %i1 + 0x1c ], %i3
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
20346fc: f8 0e a0 02 ldub [ %i2 + 2 ], %i4
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034700: ba 07 7f ff add %i5, -1, %i5
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034704: b9 30 40 1c srl %g1, %i4, %i4
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034708: ba 0f 40 01 and %i5, %g1, %i5
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
203470c: 83 2e e0 10 sll %i3, 0x10, %g1
2034710: 85 30 60 08 srl %g1, 8, %g2
2034714: 83 30 60 18 srl %g1, 0x18, %g1
2034718: 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(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
203471c: b8 02 00 1c add %o0, %i4, %i4
/* 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));
2034720: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = _fat_block_write(mt_entry, sec,
2034724: 92 10 00 1c mov %i4, %o1
2034728: 94 07 60 1a add %i5, 0x1a, %o2
203472c: 96 10 20 02 mov 2, %o3
2034730: 98 07 bf fc add %fp, -4, %o4
2034734: 7f ff c5 df call 2025eb0 <_fat_block_write>
2034738: 90 10 00 18 mov %i0, %o0
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
203473c: b7 36 e0 10 srl %i3, 0x10, %i3
2034740: b7 2e e0 10 sll %i3, 0x10, %i3
2034744: 83 36 e0 08 srl %i3, 8, %g1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
2034748: b4 10 00 08 mov %o0, %i2
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
203474c: b7 36 e0 18 srl %i3, 0x18, %i3
ret2 = _fat_block_write(mt_entry, sec,
2034750: 90 10 00 18 mov %i0, %o0
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
2034754: b6 10 40 1b or %g1, %i3, %i3
ret2 = _fat_block_write(mt_entry, sec,
2034758: 92 10 00 1c mov %i4, %o1
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
203475c: f6 37 bf fe sth %i3, [ %fp + -2 ]
ret2 = _fat_block_write(mt_entry, sec,
2034760: 94 07 60 14 add %i5, 0x14, %o2
2034764: 96 10 20 02 mov 2, %o3
2034768: 7f ff c5 d2 call 2025eb0 <_fat_block_write>
203476c: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
2034770: 80 a2 20 00 cmp %o0, 0
2034774: 06 80 00 04 bl 2034784 <msdos_set_first_cluster_num+0xb0> <== NEVER TAKEN
2034778: 80 a6 a0 00 cmp %i2, 0
203477c: 16 80 00 03 bge 2034788 <msdos_set_first_cluster_num+0xb4><== ALWAYS TAKEN
2034780: b0 10 20 00 clr %i0
return -1;
2034784: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
2034788: 81 c7 e0 08 ret
203478c: 81 e8 00 00 restore
02020330 <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(rtems_filesystem_mount_table_entry_t *mt_entry)
{
2020330: 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);
2020334: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2020338: 7f ff b3 cb call 200d264 <rtems_semaphore_release>
202033c: d0 00 60 90 ld [ %g1 + 0x90 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
2020340: 80 a2 20 00 cmp %o0, 0
2020344: 02 80 00 04 be 2020354 <msdos_unlock+0x24> <== ALWAYS TAKEN
2020348: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
202034c: 7f ff b5 8a call 200d974 <rtems_fatal_error_occurred> <== NOT EXECUTED
2020350: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2020354: 81 c7 e0 08 ret
2020358: 81 e8 00 00 restore
02004294 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
2004294: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
2004298: 03 00 80 74 sethi %hi(0x201d000), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
200429c: 80 a6 00 19 cmp %i0, %i1
20042a0: 02 80 00 03 be 20042ac <newlib_delete_hook+0x18>
20042a4: fa 00 61 c8 ld [ %g1 + 0x1c8 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
20042a8: fa 06 61 54 ld [ %i1 + 0x154 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
20042ac: 80 a7 60 00 cmp %i5, 0
20042b0: 02 80 00 0b be 20042dc <newlib_delete_hook+0x48> <== NEVER TAKEN
20042b4: 03 00 80 70 sethi %hi(0x201c000), %g1
20042b8: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 201c3a8 <_global_impure_ptr>
20042bc: 80 a7 40 01 cmp %i5, %g1
20042c0: 02 80 00 07 be 20042dc <newlib_delete_hook+0x48>
20042c4: 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);
20042c8: 90 10 00 1d mov %i5, %o0
20042cc: 40 00 2f 81 call 20100d0 <_fwalk>
20042d0: 92 12 60 88 or %o1, 0x88, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
20042d4: 40 00 1b bf call 200b1d0 <_Workspace_Free>
20042d8: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
20042dc: 80 a6 00 19 cmp %i0, %i1
20042e0: 12 80 00 04 bne 20042f0 <newlib_delete_hook+0x5c>
20042e4: c0 26 61 54 clr [ %i1 + 0x154 ]
_REENT = 0;
20042e8: 03 00 80 74 sethi %hi(0x201d000), %g1
20042ec: c0 20 61 c8 clr [ %g1 + 0x1c8 ] ! 201d1c8 <_impure_ptr>
20042f0: 81 c7 e0 08 ret
20042f4: 81 e8 00 00 restore
02004088 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
2004088: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
200408c: 40 00 2f 19 call 200fcf0 <fileno>
2004090: 90 10 00 18 mov %i0, %o0
2004094: 80 a2 20 02 cmp %o0, 2
2004098: 18 80 00 0e bgu 20040d0 <newlib_free_buffers+0x48> <== NEVER TAKEN
200409c: 01 00 00 00 nop
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
20040a0: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
20040a4: 80 88 60 80 btst 0x80, %g1
20040a8: 02 80 00 0c be 20040d8 <newlib_free_buffers+0x50> <== ALWAYS TAKEN
20040ac: 01 00 00 00 nop
free( fp->_bf._base );
20040b0: 7f ff fd 98 call 2003710 <free> <== NOT EXECUTED
20040b4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
20040b8: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
20040bc: 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;
20040c0: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
20040c4: 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;
20040c8: 10 80 00 04 b 20040d8 <newlib_free_buffers+0x50> <== NOT EXECUTED
20040cc: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
20040d0: 40 00 2e 3b call 200f9bc <fclose> <== NOT EXECUTED
20040d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
20040d8: 81 c7 e0 08 ret
20040dc: 91 e8 20 00 restore %g0, 0, %o0
02001c68 <notify>:
}
void
notify (s)
char *s;
{
2001c68: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
2001c6c: 11 00 80 8c sethi %hi(0x2023000), %o0 <== NOT EXECUTED
2001c70: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2001c74: 40 00 59 e0 call 20183f4 <printf> <== NOT EXECUTED
2001c78: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
2001c7c: 31 00 80 8c sethi %hi(0x2023000), %i0 <== NOT EXECUTED
2001c80: 40 00 5a 1e call 20184f8 <puts> <== NOT EXECUTED
2001c84: 91 ee 22 e8 restore %i0, 0x2e8, %o0 <== NOT EXECUTED
02006de0 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
2006de0: 81 c3 e0 08 retl <== NOT EXECUTED
2006de4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006df0 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
/* Do nothing */
}
2006df0: 81 c3 e0 08 retl <== NOT EXECUTED
02006db8 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
2006db8: 81 c3 e0 08 retl <== NOT EXECUTED
2006dbc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006dd8 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
2006dd8: 81 c3 e0 08 retl <== NOT EXECUTED
2006ddc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006e08 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
2006e08: 81 c3 e0 08 retl <== NOT EXECUTED
2006e0c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006e10 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
2006e10: 81 c3 e0 08 retl <== NOT EXECUTED
2006e14: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02005ec4 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
2005ec4: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
2005ec8: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
2005ecc: 80 88 60 01 btst 1, %g1
2005ed0: 02 80 00 59 be 2006034 <oproc+0x170> <== NEVER TAKEN
2005ed4: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
2005ed8: 84 0e 20 ff and %i0, 0xff, %g2
2005edc: 80 a0 a0 09 cmp %g2, 9
2005ee0: 22 80 00 2a be,a 2005f88 <oproc+0xc4>
2005ee4: c4 06 60 28 ld [ %i1 + 0x28 ], %g2
2005ee8: 18 80 00 07 bgu 2005f04 <oproc+0x40> <== ALWAYS TAKEN
2005eec: 80 a0 a0 0a cmp %g2, 0xa
2005ef0: 80 a0 a0 08 cmp %g2, 8 <== NOT EXECUTED
2005ef4: 12 80 00 39 bne 2005fd8 <oproc+0x114> <== NOT EXECUTED
2005ef8: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
2005efc: 10 80 00 32 b 2005fc4 <oproc+0x100> <== NOT EXECUTED
2005f00: 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) {
2005f04: 02 80 00 06 be 2005f1c <oproc+0x58>
2005f08: 80 a0 a0 0d cmp %g2, 0xd
2005f0c: 32 80 00 33 bne,a 2005fd8 <oproc+0x114> <== ALWAYS TAKEN
2005f10: 80 88 60 02 btst 2, %g1
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
2005f14: 10 80 00 0f b 2005f50 <oproc+0x8c> <== NOT EXECUTED
2005f18: 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)
2005f1c: 80 88 60 20 btst 0x20, %g1
2005f20: 32 80 00 02 bne,a 2005f28 <oproc+0x64> <== NEVER TAKEN
2005f24: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
2005f28: 80 88 60 04 btst 4, %g1
2005f2c: 02 80 00 43 be 2006038 <oproc+0x174> <== NEVER TAKEN
2005f30: 90 07 a0 44 add %fp, 0x44, %o0
rtems_termios_puts ("\r", 1, tty);
2005f34: 11 00 80 6e sethi %hi(0x201b800), %o0
2005f38: 92 10 20 01 mov 1, %o1
2005f3c: 90 12 20 a0 or %o0, 0xa0, %o0
2005f40: 7f ff ff 98 call 2005da0 <rtems_termios_puts>
2005f44: 94 10 00 19 mov %i1, %o2
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
2005f48: 10 80 00 3b b 2006034 <oproc+0x170>
2005f4c: c0 26 60 28 clr [ %i1 + 0x28 ]
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
2005f50: 02 80 00 06 be 2005f68 <oproc+0xa4> <== NOT EXECUTED
2005f54: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
2005f58: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
2005f5c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2005f60: 02 80 00 17 be 2005fbc <oproc+0xf8> <== NOT EXECUTED
2005f64: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
2005f68: 22 80 00 33 be,a 2006034 <oproc+0x170> <== NOT EXECUTED
2005f6c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
2005f70: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
2005f74: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2005f78: 02 80 00 2f be 2006034 <oproc+0x170> <== NOT EXECUTED
2005f7c: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
2005f80: 10 80 00 2d b 2006034 <oproc+0x170> <== NOT EXECUTED
2005f84: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
2005f88: 92 10 20 08 mov 8, %o1
2005f8c: 86 08 a0 07 and %g2, 7, %g3
2005f90: 92 22 40 03 sub %o1, %g3, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
2005f94: 07 00 00 06 sethi %hi(0x1800), %g3
2005f98: 82 08 40 03 and %g1, %g3, %g1
2005f9c: 80 a0 40 03 cmp %g1, %g3
2005fa0: 82 00 80 09 add %g2, %o1, %g1
2005fa4: 12 80 00 24 bne 2006034 <oproc+0x170> <== NEVER TAKEN
2005fa8: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
2005fac: 11 00 80 6e sethi %hi(0x201b800), %o0
2005fb0: 94 10 00 19 mov %i1, %o2
2005fb4: 7f ff ff 7b call 2005da0 <rtems_termios_puts>
2005fb8: 90 12 20 a8 or %o0, 0xa8, %o0
return;
2005fbc: 81 c7 e0 08 ret
2005fc0: 81 e8 00 00 restore
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
2005fc4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005fc8: 04 80 00 1b ble 2006034 <oproc+0x170> <== NOT EXECUTED
2005fcc: 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++;
2005fd0: 10 80 00 19 b 2006034 <oproc+0x170> <== NOT EXECUTED
2005fd4: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
2005fd8: 02 80 00 0d be 200600c <oproc+0x148> <== ALWAYS TAKEN
2005fdc: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1
c = toupper(c);
2005fe0: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED
2005fe4: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 201d1c0 <__ctype_ptr__><== NOT EXECUTED
2005fe8: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
2005fec: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
2005ff0: c2 08 60 01 ldub [ %g1 + 1 ], %g1 <== NOT EXECUTED
2005ff4: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
2005ff8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
2005ffc: 22 80 00 02 be,a 2006004 <oproc+0x140> <== NOT EXECUTED
2006000: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED
2006004: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED
if (!iscntrl(c))
2006008: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1 <== NOT EXECUTED
200600c: 05 00 80 74 sethi %hi(0x201d000), %g2
2006010: c4 00 a1 c0 ld [ %g2 + 0x1c0 ], %g2 ! 201d1c0 <__ctype_ptr__>
2006014: 82 00 80 01 add %g2, %g1, %g1
2006018: c2 08 60 01 ldub [ %g1 + 1 ], %g1
200601c: 80 88 60 20 btst 0x20, %g1
2006020: 12 80 00 06 bne 2006038 <oproc+0x174> <== NEVER TAKEN
2006024: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
2006028: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
200602c: 82 00 60 01 inc %g1
2006030: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
2006034: 90 07 a0 44 add %fp, 0x44, %o0
2006038: 92 10 20 01 mov 1, %o1
200603c: 7f ff ff 59 call 2005da0 <rtems_termios_puts>
2006040: 94 10 00 19 mov %i1, %o2
2006044: 81 c7 e0 08 ret
2006048: 81 e8 00 00 restore
02004994 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
2004994: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
2004998: 80 a6 20 00 cmp %i0, 0
200499c: 02 80 00 16 be 20049f4 <partition_free+0x60>
20049a0: 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));
20049a4: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
20049a8: 84 18 60 85 xor %g1, 0x85, %g2
20049ac: 80 a0 00 02 cmp %g0, %g2
20049b0: 82 18 60 05 xor %g1, 5, %g1
20049b4: 84 60 3f ff subx %g0, -1, %g2
20049b8: 80 a0 00 01 cmp %g0, %g1
20049bc: 82 60 3f ff subx %g0, -1, %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
20049c0: 80 90 80 01 orcc %g2, %g1, %g0
20049c4: 02 80 00 0a be 20049ec <partition_free+0x58> <== ALWAYS TAKEN
20049c8: 01 00 00 00 nop
20049cc: ba 10 20 00 clr %i5 ! 0 <PROM_START> <== NOT EXECUTED
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
20049d0: 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]);
20049d4: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
20049d8: 7f ff ff ef call 2004994 <partition_free> <== NOT EXECUTED
20049dc: 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;
20049e0: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
20049e4: 32 bf ff fc bne,a 20049d4 <partition_free+0x40> <== NOT EXECUTED
20049e8: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
20049ec: 40 00 04 1d call 2005a60 <free>
20049f0: 81 e8 00 00 restore
20049f4: 81 c7 e0 08 ret
20049f8: 81 e8 00 00 restore
02004cec <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)
{
2004cec: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
2004cf0: 92 10 20 00 clr %o1
2004cf4: 90 10 00 18 mov %i0, %o0
2004cf8: 40 00 07 9f call 2006b74 <open>
2004cfc: ba 10 20 19 mov 0x19, %i5
if (fd < 0)
2004d00: 80 a2 20 00 cmp %o0, 0
2004d04: 06 80 00 6a bl 2004eac <partition_table_get+0x1c0> <== NEVER TAKEN
2004d08: b8 10 00 08 mov %o0, %i4
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
2004d0c: 40 00 03 7f call 2005b08 <fstat>
2004d10: 92 07 bf b0 add %fp, -80, %o1
if (rc != RTEMS_SUCCESSFUL)
2004d14: 80 a2 20 00 cmp %o0, 0
2004d18: 12 80 00 63 bne 2004ea4 <partition_table_get+0x1b8> <== NEVER TAKEN
2004d1c: 01 00 00 00 nop
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
2004d20: 90 06 60 08 add %i1, 8, %o0
2004d24: 92 10 00 18 mov %i0, %o1
2004d28: 40 00 46 4b call 2016654 <strncpy>
2004d2c: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
2004d30: c4 1f bf c8 ldd [ %fp + -56 ], %g2
2004d34: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
2004d38: c4 07 bf f0 ld [ %fp + -16 ], %g2
2004d3c: 80 a0 a0 00 cmp %g2, 0
2004d40: 02 80 00 03 be 2004d4c <partition_table_get+0x60> <== ALWAYS TAKEN
2004d44: 82 10 22 00 mov 0x200, %g1
2004d48: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2004d4c: 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;
2004d50: c0 27 bf f8 clr [ %fp + -8 ]
rtems_part_desc_t *part_desc;
uint8_t *data;
rtems_status_code rc;
/* get MBR sector */
rc = get_sector(fd, 0, §or);
2004d54: 90 10 00 1c mov %i4, %o0
2004d58: 92 10 20 00 clr %o1
2004d5c: 7f ff ff 28 call 20049fc <get_sector>
2004d60: 94 07 bf f8 add %fp, -8, %o2
if (rc != RTEMS_SUCCESSFUL)
2004d64: ba 92 20 00 orcc %o0, 0, %i5
2004d68: 02 80 00 06 be 2004d80 <partition_table_get+0x94> <== ALWAYS TAKEN
2004d6c: d0 07 bf f8 ld [ %fp + -8 ], %o0
{
if (sector)
2004d70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004d74: 12 80 00 1b bne 2004de0 <partition_table_get+0xf4> <== NOT EXECUTED
2004d78: 01 00 00 00 nop <== NOT EXECUTED
2004d7c: 30 80 00 4a b,a 2004ea4 <partition_table_get+0x1b8> <== 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) &&
2004d80: c4 0a 22 02 ldub [ %o0 + 0x202 ], %g2
2004d84: 80 a0 a0 55 cmp %g2, 0x55
2004d88: 12 80 00 06 bne 2004da0 <partition_table_get+0xb4> <== NEVER TAKEN
2004d8c: 82 10 20 00 clr %g1
* 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)
2004d90: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
2004d94: 82 18 60 aa xor %g1, 0xaa, %g1
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) &&
2004d98: 80 a0 00 01 cmp %g0, %g1
2004d9c: 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))
2004da0: 80 a0 60 00 cmp %g1, 0
2004da4: 32 80 00 05 bne,a 2004db8 <partition_table_get+0xcc> <== ALWAYS TAKEN
2004da8: a0 02 21 c2 add %o0, 0x1c2, %l0
{
free(sector);
2004dac: 40 00 03 2d call 2005a60 <free> <== NOT EXECUTED
2004db0: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
2004db4: 30 80 00 3c b,a 2004ea4 <partition_table_get+0x1b8> <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
}
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
2004db8: b6 10 00 19 mov %i1, %i3
2004dbc: b4 10 00 19 mov %i1, %i2
2004dc0: b0 10 20 01 mov 1, %i0
2004dc4: 90 10 00 10 mov %l0, %o0
2004dc8: 7f ff ff 33 call 2004a94 <data_to_part_desc.part.1>
2004dcc: 92 07 bf fc add %fp, -4, %o1
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)
2004dd0: ba 92 20 00 orcc %o0, 0, %i5
2004dd4: 02 80 00 06 be 2004dec <partition_table_get+0x100> <== ALWAYS TAKEN
2004dd8: c2 07 bf fc ld [ %fp + -4 ], %g1
{
free(sector);
2004ddc: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
2004de0: 40 00 03 20 call 2005a60 <free> <== NOT EXECUTED
2004de4: 01 00 00 00 nop <== NOT EXECUTED
2004de8: 30 80 00 2f b,a 2004ea4 <partition_table_get+0x1b8> <== NOT EXECUTED
return rc;
}
if (part_desc != NULL)
2004dec: 80 a0 60 00 cmp %g1, 0
2004df0: 22 80 00 0a be,a 2004e18 <partition_table_get+0x12c> <== NEVER TAKEN
2004df4: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
2004df8: c6 00 60 04 ld [ %g1 + 4 ], %g3
2004dfc: c4 00 60 08 ld [ %g1 + 8 ], %g2
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
2004e00: f0 28 60 02 stb %i0, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
2004e04: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
2004e08: 84 00 c0 02 add %g3, %g2, %g2
2004e0c: 84 00 bf ff add %g2, -1, %g2
2004e10: c4 20 60 0c st %g2, [ %g1 + 0xc ]
2004e14: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
2004e18: b0 06 20 01 inc %i0
2004e1c: a0 04 20 10 add %l0, 0x10, %l0
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
2004e20: 82 0e 20 ff and %i0, 0xff, %g1
2004e24: 80 a0 60 05 cmp %g1, 5
2004e28: 12 bf ff e7 bne 2004dc4 <partition_table_get+0xd8>
2004e2c: b4 06 a0 04 add %i2, 4, %i2
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004e30: 40 00 03 0c call 2005a60 <free>
2004e34: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
2004e38: 82 10 20 04 mov 4, %g1
2004e3c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
2004e40: b2 10 20 00 clr %i1
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
2004e44: d4 06 e0 28 ld [ %i3 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
2004e48: 80 a2 a0 00 cmp %o2, 0
2004e4c: 02 80 00 12 be 2004e94 <partition_table_get+0x1a8> <== NEVER TAKEN
2004e50: d4 27 bf fc st %o2, [ %fp + -4 ]
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004e54: c2 0a a0 01 ldub [ %o2 + 1 ], %g1
2004e58: 84 18 60 85 xor %g1, 0x85, %g2
2004e5c: 80 a0 00 02 cmp %g0, %g2
2004e60: 82 18 60 05 xor %g1, 5, %g1
2004e64: 84 60 3f ff subx %g0, -1, %g2
2004e68: 80 a0 00 01 cmp %g0, %g1
2004e6c: 82 60 3f ff subx %g0, -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))
2004e70: 80 90 80 01 orcc %g2, %g1, %g0
2004e74: 22 80 00 09 be,a 2004e98 <partition_table_get+0x1ac>
2004e78: b2 06 60 01 inc %i1
{
read_extended_partition(fd, part_desc->start, part_desc);
2004e7c: d2 02 a0 04 ld [ %o2 + 4 ], %o1
2004e80: 7f ff ff 3c call 2004b70 <read_extended_partition>
2004e84: 90 10 00 1c mov %i4, %o0
free(part_desc);
2004e88: 40 00 02 f6 call 2005a60 <free>
2004e8c: d0 07 bf fc ld [ %fp + -4 ], %o0
disk_desc->partitions[part_num] = NULL;
2004e90: c0 26 e0 28 clr [ %i3 + 0x28 ]
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
2004e94: b2 06 60 01 inc %i1
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;
2004e98: 80 a6 60 04 cmp %i1, 4
2004e9c: 12 bf ff ea bne 2004e44 <partition_table_get+0x158>
2004ea0: b6 06 e0 04 add %i3, 4, %i3
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
2004ea4: 40 00 02 36 call 200577c <close>
2004ea8: 90 10 00 1c mov %i4, %o0
return rc;
}
2004eac: 81 c7 e0 08 ret
2004eb0: 91 e8 00 1d restore %g0, %i5, %o0
0200474c <pathconf>:
long pathconf(
const char *path,
int name
)
{
200474c: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
2004750: 92 10 20 00 clr %o1
2004754: 90 10 00 18 mov %i0, %o0
2004758: 7f ff ff 70 call 2004518 <open>
200475c: b0 10 3f ff mov -1, %i0
if ( fd == -1 )
2004760: 80 a2 3f ff cmp %o0, -1
2004764: 02 80 00 07 be 2004780 <pathconf+0x34> <== ALWAYS TAKEN
2004768: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
200476c: 40 00 14 09 call 2009790 <fpathconf> <== NOT EXECUTED
2004770: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2004774: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
2004778: 40 00 13 d8 call 20096d8 <close> <== NOT EXECUTED
200477c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
}
2004780: 81 c7 e0 08 ret
2004784: 81 e8 00 00 restore
0200d084 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
200d084: 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)
200d088: 11 00 80 82 sethi %hi(0x2020800), %o0
200d08c: 92 10 21 ff mov 0x1ff, %o1
200d090: 90 12 23 88 or %o0, 0x388, %o0
200d094: 40 00 05 41 call 200e598 <rtems_mkdir>
200d098: ba 10 3f ff mov -1, %i5
200d09c: 80 a2 20 00 cmp %o0, 0
200d0a0: 12 80 00 47 bne 200d1bc <pipe_create+0x138> <== NEVER TAKEN
200d0a4: 03 00 00 19 sethi %hi(0x6400), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
200d0a8: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <PROM_START+0x666f>
200d0ac: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200d0b0: 03 00 80 89 sethi %hi(0x2022400), %g1
200d0b4: d4 10 63 58 lduh [ %g1 + 0x358 ], %o2 ! 2022758 <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);
200d0b8: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
200d0bc: 84 10 a1 70 or %g2, 0x170, %g2 ! 2f746d70 <RAM_END+0x2d346d70>
200d0c0: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
200d0c4: 86 10 e2 69 or %g3, 0x269, %g3 ! 2f2e6669 <RAM_END+0x2cee6669>
200d0c8: c4 3f bf f0 std %g2, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200d0cc: 84 02 a0 01 add %o2, 1, %g2
200d0d0: 90 07 bf fa add %fp, -6, %o0
200d0d4: c4 30 63 58 sth %g2, [ %g1 + 0x358 ]
200d0d8: 95 2a a0 10 sll %o2, 0x10, %o2
200d0dc: 13 00 80 82 sethi %hi(0x2020800), %o1
200d0e0: 95 32 a0 10 srl %o2, 0x10, %o2
200d0e4: 40 00 13 86 call 2011efc <sprintf>
200d0e8: 92 12 63 90 or %o1, 0x390, %o1
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
200d0ec: 90 07 bf f0 add %fp, -16, %o0
200d0f0: 40 00 04 7f call 200e2ec <mkfifo>
200d0f4: 92 10 21 80 mov 0x180, %o1
200d0f8: 80 a2 20 00 cmp %o0, 0
200d0fc: 02 80 00 05 be 200d110 <pipe_create+0x8c>
200d100: 90 07 bf f0 add %fp, -16, %o0
if (errno != EEXIST){
200d104: 40 00 10 07 call 2011120 <__errno>
200d108: b0 10 00 1d mov %i5, %i0
200d10c: 30 80 00 2d b,a 200d1c0 <pipe_create+0x13c>
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);
200d110: 7f ff df 90 call 2004f50 <open>
200d114: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
200d118: 80 a2 20 00 cmp %o0, 0
200d11c: 16 80 00 06 bge 200d134 <pipe_create+0xb0>
200d120: d0 26 00 00 st %o0, [ %i0 ]
err = errno;
200d124: 40 00 0f ff call 2011120 <__errno>
200d128: 01 00 00 00 nop
200d12c: 10 80 00 1c b 200d19c <pipe_create+0x118>
200d130: f8 02 00 00 ld [ %o0 ], %i4
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]);
200d134: 03 00 80 87 sethi %hi(0x2021c00), %g1
200d138: c4 00 62 5c ld [ %g1 + 0x25c ], %g2 ! 2021e5c <rtems_libio_number_iops>
200d13c: 80 a2 00 02 cmp %o0, %g2
200d140: 1a 80 00 08 bcc 200d160 <pipe_create+0xdc> <== NEVER TAKEN
200d144: 82 10 20 00 clr %g1
200d148: 83 2a 20 03 sll %o0, 3, %g1
200d14c: 91 2a 20 06 sll %o0, 6, %o0
200d150: 90 00 40 08 add %g1, %o0, %o0
200d154: 03 00 80 8a sethi %hi(0x2022800), %g1
200d158: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 20229c0 <rtems_libio_iops>
200d15c: 82 00 40 08 add %g1, %o0, %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
200d160: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d164: 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;
200d168: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d16c: 92 10 20 01 mov 1, %o1
200d170: 7f ff df 78 call 2004f50 <open>
200d174: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
200d178: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
200d17c: 80 a2 20 00 cmp %o0, 0
200d180: 16 80 00 07 bge 200d19c <pipe_create+0x118>
200d184: b8 10 20 00 clr %i4
err = errno;
200d188: 40 00 0f e6 call 2011120 <__errno>
200d18c: 01 00 00 00 nop
200d190: f8 02 00 00 ld [ %o0 ], %i4
close(filsdes[0]);
200d194: 7f ff db 24 call 2003e24 <close>
200d198: d0 06 00 00 ld [ %i0 ], %o0
}
unlink(fifopath);
200d19c: 7f ff ea e3 call 2007d28 <unlink>
200d1a0: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
200d1a4: 80 a7 20 00 cmp %i4, 0
200d1a8: 02 80 00 05 be 200d1bc <pipe_create+0x138>
200d1ac: ba 10 20 00 clr %i5
rtems_set_errno_and_return_minus_one(err);
200d1b0: 40 00 0f dc call 2011120 <__errno>
200d1b4: ba 10 3f ff mov -1, %i5
200d1b8: f8 22 00 00 st %i4, [ %o0 ]
return 0;
}
200d1bc: b0 10 00 1d mov %i5, %i0
200d1c0: 81 c7 e0 08 ret
200d1c4: 81 e8 00 00 restore
0200e524 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
200e524: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
200e528: 03 10 01 19 sethi %hi(0x40046400), %g1
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
200e52c: ba 10 00 18 mov %i0, %i5
if (cmd == FIONREAD) {
200e530: 82 10 62 7f or %g1, 0x27f, %g1
200e534: 80 a6 40 01 cmp %i1, %g1
200e538: 12 80 00 12 bne 200e580 <pipe_ioctl+0x5c>
200e53c: b0 10 3f ea mov -22, %i0
if (buffer == NULL)
200e540: 80 a6 a0 00 cmp %i2, 0
200e544: 02 80 00 0f be 200e580 <pipe_ioctl+0x5c>
200e548: b0 10 3f f2 mov -14, %i0
return -EFAULT;
if (! PIPE_LOCK(pipe))
200e54c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e550: 92 10 20 00 clr %o1
200e554: 94 10 20 00 clr %o2
200e558: 7f ff ea f3 call 2009124 <rtems_semaphore_obtain>
200e55c: b0 10 3f fc mov -4, %i0
200e560: 80 a2 20 00 cmp %o0, 0
200e564: 12 80 00 07 bne 200e580 <pipe_ioctl+0x5c> <== NEVER TAKEN
200e568: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e56c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
PIPE_UNLOCK(pipe);
200e570: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e574: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
200e578: 7f ff eb 35 call 200924c <rtems_semaphore_release>
200e57c: b0 10 20 00 clr %i0
return 0;
}
return -EINVAL;
}
200e580: 81 c7 e0 08 ret
200e584: 81 e8 00 00 restore
0200e1c4 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e1c4: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e1c8: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e1cc: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e1d0: 92 10 20 00 clr %o1
200e1d4: 94 10 20 00 clr %o2
200e1d8: 7f ff eb d3 call 2009124 <rtems_semaphore_obtain>
200e1dc: b0 10 3f fc mov -4, %i0
200e1e0: 80 a2 20 00 cmp %o0, 0
200e1e4: 12 80 00 59 bne 200e348 <pipe_read+0x184> <== NEVER TAKEN
200e1e8: 01 00 00 00 nop
200e1ec: 10 80 00 4b b 200e318 <pipe_read+0x154>
200e1f0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
200e1f4: 80 a0 60 00 cmp %g1, 0
200e1f8: 02 80 00 4c be 200e328 <pipe_read+0x164>
200e1fc: b8 10 20 00 clr %i4
goto out_locked;
if (LIBIO_NODELAY(iop)) {
200e200: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1
200e204: 80 88 60 01 btst 1, %g1
200e208: 32 80 00 48 bne,a 200e328 <pipe_read+0x164>
200e20c: 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 ++;
200e210: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
200e214: 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 ++;
200e218: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e21c: 7f ff ec 0c call 200924c <rtems_semaphore_release>
200e220: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
200e224: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e228: 40 00 05 4e call 200f760 <rtems_barrier_wait>
200e22c: 92 10 20 00 clr %o1
200e230: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e234: 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))
200e238: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e23c: 92 10 20 00 clr %o1
200e240: 94 10 20 00 clr %o2
200e244: 7f ff eb b8 call 2009124 <rtems_semaphore_obtain>
200e248: b8 0f 3f fc and %i4, -4, %i4
200e24c: 80 a2 20 00 cmp %o0, 0
200e250: 12 80 00 3a bne 200e338 <pipe_read+0x174> <== NEVER TAKEN
200e254: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
200e258: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e25c: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e260: 12 80 00 32 bne 200e328 <pipe_read+0x164> <== NEVER TAKEN
200e264: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
200e268: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e26c: 80 a7 20 00 cmp %i4, 0
200e270: 22 bf ff e1 be,a 200e1f4 <pipe_read+0x30>
200e274: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
200e278: 82 26 80 18 sub %i2, %i0, %g1
200e27c: 80 a7 00 01 cmp %i4, %g1
200e280: 38 80 00 02 bgu,a 200e288 <pipe_read+0xc4>
200e284: b8 10 00 01 mov %g1, %i4
chunk1 = pipe->Size - pipe->Start;
200e288: c2 07 60 08 ld [ %i5 + 8 ], %g1
200e28c: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e290: d2 07 40 00 ld [ %i5 ], %o1
200e294: 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);
200e298: 94 10 00 1c mov %i4, %o2
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
200e29c: 80 a7 00 10 cmp %i4, %l0
200e2a0: 90 06 40 18 add %i1, %i0, %o0
200e2a4: 04 80 00 08 ble 200e2c4 <pipe_read+0x100>
200e2a8: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
200e2ac: 40 00 11 8e call 20128e4 <memcpy>
200e2b0: 94 10 00 10 mov %l0, %o2
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
200e2b4: d2 07 40 00 ld [ %i5 ], %o1
200e2b8: 90 06 00 10 add %i0, %l0, %o0
200e2bc: 94 27 00 10 sub %i4, %l0, %o2
200e2c0: 90 06 40 08 add %i1, %o0, %o0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
200e2c4: 40 00 11 88 call 20128e4 <memcpy>
200e2c8: 01 00 00 00 nop
pipe->Start += chunk;
200e2cc: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
200e2d0: d2 07 60 04 ld [ %i5 + 4 ], %o1
200e2d4: 40 00 41 bc call 201e9c4 <.urem>
200e2d8: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
200e2dc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
200e2e0: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
200e2e4: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
200e2e8: 80 a0 60 00 cmp %g1, 0
200e2ec: 12 80 00 03 bne 200e2f8 <pipe_read+0x134>
200e2f0: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
200e2f4: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
200e2f8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e2fc: 80 a0 60 00 cmp %g1, 0
200e300: 22 80 00 06 be,a 200e318 <pipe_read+0x154>
200e304: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPWRITERS(pipe);
200e308: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e30c: 40 00 04 fe call 200f704 <rtems_barrier_release>
200e310: 92 07 bf fc add %fp, -4, %o1
read += chunk;
200e314: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
200e318: 80 a6 00 1a cmp %i0, %i2
200e31c: 2a bf ff d4 bcs,a 200e26c <pipe_read+0xa8>
200e320: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e324: b8 10 20 00 clr %i4
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
200e328: 7f ff eb c9 call 200924c <rtems_semaphore_release>
200e32c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
200e330: 10 80 00 04 b 200e340 <pipe_read+0x17c>
200e334: 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;
200e338: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
200e33c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e340: 24 80 00 02 ble,a 200e348 <pipe_read+0x184>
200e344: b0 10 00 1c mov %i4, %i0
return read;
return ret;
}
200e348: 81 c7 e0 08 ret
200e34c: 81 e8 00 00 restore
0200dcb4 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200dcb4: 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);
200dcb8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
200dcbc: 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)
200dcc0: 80 88 60 02 btst 2, %g1
200dcc4: 02 80 00 05 be 200dcd8 <pipe_release+0x24>
200dcc8: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
200dccc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200dcd0: 82 00 7f ff add %g1, -1, %g1
200dcd4: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
200dcd8: 80 8f 20 04 btst 4, %i4
200dcdc: 02 80 00 05 be 200dcf0 <pipe_release+0x3c>
200dce0: 01 00 00 00 nop
pipe->Writers --;
200dce4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200dce8: 82 00 7f ff add %g1, -1, %g1
200dcec: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
200dcf0: 7f ff ed 57 call 200924c <rtems_semaphore_release>
200dcf4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
200dcf8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200dcfc: 80 a0 60 00 cmp %g1, 0
200dd00: 12 80 00 0a bne 200dd28 <pipe_release+0x74>
200dd04: 80 a7 20 04 cmp %i4, 4
200dd08: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
200dd0c: 80 a0 a0 00 cmp %g2, 0
200dd10: 12 80 00 06 bne 200dd28 <pipe_release+0x74>
200dd14: 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);
200dd18: 7f ff ff dc call 200dc88 <pipe_free>
200dd1c: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
200dd20: 10 80 00 12 b 200dd68 <pipe_release+0xb4>
200dd24: c0 26 00 00 clr [ %i0 ]
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
200dd28: 02 80 00 07 be 200dd44 <pipe_release+0x90>
200dd2c: 80 a7 20 02 cmp %i4, 2
200dd30: 80 a0 60 00 cmp %g1, 0
200dd34: 12 80 00 04 bne 200dd44 <pipe_release+0x90> <== NEVER TAKEN
200dd38: 80 a7 20 02 cmp %i4, 2
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
200dd3c: 10 80 00 09 b 200dd60 <pipe_release+0xac>
200dd40: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
200dd44: 02 80 00 0a be 200dd6c <pipe_release+0xb8> <== NEVER TAKEN
200dd48: 03 00 80 8d sethi %hi(0x2023400), %g1
200dd4c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200dd50: 80 a0 60 00 cmp %g1, 0
200dd54: 12 80 00 06 bne 200dd6c <pipe_release+0xb8> <== NEVER TAKEN
200dd58: 03 00 80 8d sethi %hi(0x2023400), %g1
PIPE_WAKEUPREADERS(pipe);
200dd5c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200dd60: 40 00 06 69 call 200f704 <rtems_barrier_release>
200dd64: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200dd68: 03 00 80 8d sethi %hi(0x2023400), %g1
200dd6c: 7f ff ed 38 call 200924c <rtems_semaphore_release>
200dd70: d0 00 62 88 ld [ %g1 + 0x288 ], %o0 ! 2023688 <pipe_semaphore>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
200dd74: 81 c7 e0 08 ret
200dd78: 81 e8 00 00 restore
0200e350 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e350: 9d e3 bf 98 save %sp, -104, %sp
200e354: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
200e358: 80 a6 a0 00 cmp %i2, 0
200e35c: 02 80 00 70 be 200e51c <pipe_write+0x1cc> <== NEVER TAKEN
200e360: b0 10 20 00 clr %i0
return 0;
if (! PIPE_LOCK(pipe))
200e364: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e368: 92 10 20 00 clr %o1
200e36c: 94 10 20 00 clr %o2
200e370: 7f ff eb 6d call 2009124 <rtems_semaphore_obtain>
200e374: b0 10 3f fc mov -4, %i0
200e378: 80 a2 20 00 cmp %o0, 0
200e37c: 12 80 00 68 bne 200e51c <pipe_write+0x1cc> <== NEVER TAKEN
200e380: 01 00 00 00 nop
return -EINTR;
if (pipe->Readers == 0) {
200e384: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e388: 80 a0 60 00 cmp %g1, 0
200e38c: 02 80 00 54 be 200e4dc <pipe_write+0x18c>
200e390: 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;
200e394: c2 07 60 04 ld [ %i5 + 4 ], %g1
200e398: 80 a6 80 01 cmp %i2, %g1
200e39c: 18 80 00 03 bgu 200e3a8 <pipe_write+0x58> <== NEVER TAKEN
200e3a0: a2 10 20 01 mov 1, %l1
200e3a4: 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;
200e3a8: 10 80 00 48 b 200e4c8 <pipe_write+0x178>
200e3ac: 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)) {
200e3b0: 80 88 60 01 btst 1, %g1
200e3b4: 32 80 00 4b bne,a 200e4e0 <pipe_write+0x190>
200e3b8: 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 ++;
200e3bc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
200e3c0: 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 ++;
200e3c4: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e3c8: 7f ff eb a1 call 200924c <rtems_semaphore_release>
200e3cc: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
200e3d0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e3d4: 40 00 04 e3 call 200f760 <rtems_barrier_wait>
200e3d8: 92 10 20 00 clr %o1
200e3dc: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e3e0: 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))
200e3e4: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e3e8: 92 10 20 00 clr %o1
200e3ec: 94 10 20 00 clr %o2
200e3f0: 7f ff eb 4d call 2009124 <rtems_semaphore_obtain>
200e3f4: b8 0f 3f fc and %i4, -4, %i4
200e3f8: 80 a2 20 00 cmp %o0, 0
200e3fc: 12 80 00 44 bne 200e50c <pipe_write+0x1bc> <== NEVER TAKEN
200e400: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
200e404: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e408: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e40c: 12 80 00 35 bne 200e4e0 <pipe_write+0x190> <== NEVER TAKEN
200e410: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
200e414: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e418: 80 a0 60 00 cmp %g1, 0
200e41c: 02 80 00 31 be 200e4e0 <pipe_write+0x190> <== NEVER TAKEN
200e420: 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) {
200e424: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e428: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e42c: b8 24 00 01 sub %l0, %g1, %i4
200e430: 80 a7 00 11 cmp %i4, %l1
200e434: 2a bf ff df bcs,a 200e3b0 <pipe_write+0x60>
200e438: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
200e43c: 84 26 80 18 sub %i2, %i0, %g2
200e440: 80 a7 00 02 cmp %i4, %g2
200e444: 38 80 00 02 bgu,a 200e44c <pipe_write+0xfc>
200e448: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
200e44c: d0 07 60 08 ld [ %i5 + 8 ], %o0
200e450: 92 10 00 10 mov %l0, %o1
200e454: 40 00 41 5c call 201e9c4 <.urem>
200e458: 90 00 40 08 add %g1, %o0, %o0
200e45c: c2 07 40 00 ld [ %i5 ], %g1
200e460: 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);
200e464: 94 10 00 1c mov %i4, %o2
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
200e468: 80 a7 00 10 cmp %i4, %l0
200e46c: 92 06 40 18 add %i1, %i0, %o1
200e470: 04 80 00 08 ble 200e490 <pipe_write+0x140>
200e474: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
200e478: 40 00 11 1b call 20128e4 <memcpy>
200e47c: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
200e480: d0 07 40 00 ld [ %i5 ], %o0
200e484: 92 04 00 18 add %l0, %i0, %o1
200e488: 94 27 00 10 sub %i4, %l0, %o2
200e48c: 92 06 40 09 add %i1, %o1, %o1
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
200e490: 40 00 11 15 call 20128e4 <memcpy>
200e494: 01 00 00 00 nop
pipe->Length += chunk;
200e498: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e49c: 82 00 40 1c add %g1, %i4, %g1
200e4a0: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
200e4a4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e4a8: 80 a0 60 00 cmp %g1, 0
200e4ac: 22 80 00 06 be,a 200e4c4 <pipe_write+0x174>
200e4b0: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPREADERS(pipe);
200e4b4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e4b8: 40 00 04 93 call 200f704 <rtems_barrier_release>
200e4bc: 92 07 bf fc add %fp, -4, %o1
written += chunk;
200e4c0: b0 06 00 1c add %i0, %i4, %i0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
200e4c4: 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) {
200e4c8: 80 a6 00 1a cmp %i0, %i2
200e4cc: 2a bf ff d7 bcs,a 200e428 <pipe_write+0xd8>
200e4d0: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e4d4: 10 80 00 03 b 200e4e0 <pipe_write+0x190>
200e4d8: b8 10 20 00 clr %i4
200e4dc: b0 10 20 00 clr %i0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
200e4e0: 7f ff eb 5b call 200924c <rtems_semaphore_release>
200e4e4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
200e4e8: 80 a7 3f e0 cmp %i4, -32
200e4ec: 32 80 00 0a bne,a 200e514 <pipe_write+0x1c4>
200e4f0: 80 a6 20 00 cmp %i0, 0
kill(getpid(), SIGPIPE);
200e4f4: 40 00 01 44 call 200ea04 <getpid>
200e4f8: 01 00 00 00 nop
200e4fc: 40 00 02 7b call 200eee8 <kill>
200e500: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
200e504: 10 80 00 04 b 200e514 <pipe_write+0x1c4>
200e508: 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;
200e50c: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
200e510: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e514: 24 80 00 02 ble,a 200e51c <pipe_write+0x1cc>
200e518: b0 10 00 1c mov %i4, %i0
return written;
return ret;
}
200e51c: 81 c7 e0 08 ret
200e520: 81 e8 00 00 restore
02007b1c <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
2007b1c: 05 00 80 91 sethi %hi(0x2024400), %g2
2007b20: 84 10 a1 28 or %g2, 0x128, %g2 ! 2024528 <rtems_malloc_statistics>
2007b24: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2007b28: 86 00 e0 01 inc %g3
2007b2c: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
2007b30: 84 02 7f ff add %o1, -1, %g2
2007b34: 80 88 80 09 btst %g2, %o1
2007b38: 12 80 00 07 bne 2007b54 <posix_memalign+0x38> <== NEVER TAKEN
2007b3c: 80 a2 60 03 cmp %o1, 3
2007b40: 08 80 00 05 bleu 2007b54 <posix_memalign+0x38>
2007b44: 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 );
2007b48: 82 13 c0 00 mov %o7, %g1
2007b4c: 40 00 00 83 call 2007d58 <rtems_memalign>
2007b50: 9e 10 40 00 mov %g1, %o7
}
2007b54: 81 c3 e0 08 retl
2007b58: 90 10 20 16 mov 0x16, %o0
0200c3d8 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
200c3d8: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
200c3dc: 80 a0 60 00 cmp %g1, 0
200c3e0: 02 80 00 0f be 200c41c <pthread_attr_setschedpolicy+0x44>
200c3e4: 90 10 20 16 mov 0x16, %o0
200c3e8: c4 00 40 00 ld [ %g1 ], %g2
200c3ec: 80 a0 a0 00 cmp %g2, 0
200c3f0: 02 80 00 0b be 200c41c <pthread_attr_setschedpolicy+0x44>
200c3f4: 80 a2 60 04 cmp %o1, 4
return EINVAL;
switch ( policy ) {
200c3f8: 18 80 00 09 bgu 200c41c <pthread_attr_setschedpolicy+0x44>
200c3fc: 90 10 20 86 mov 0x86, %o0
200c400: 84 10 20 01 mov 1, %g2
200c404: 85 28 80 09 sll %g2, %o1, %g2
200c408: 80 88 a0 17 btst 0x17, %g2
200c40c: 02 80 00 04 be 200c41c <pthread_attr_setschedpolicy+0x44> <== NEVER TAKEN
200c410: 01 00 00 00 nop
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
200c414: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
200c418: 90 10 20 00 clr %o0
return 0;
default:
return ENOTSUP;
}
}
200c41c: 81 c3 e0 08 retl
02007ae0 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
2007ae0: 9d e3 bf 90 save %sp, -112, %sp
2007ae4: ba 10 00 18 mov %i0, %i5
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
2007ae8: 80 a7 60 00 cmp %i5, 0
2007aec: 02 80 00 20 be 2007b6c <pthread_barrier_init+0x8c>
2007af0: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( count == 0 )
2007af4: 80 a6 a0 00 cmp %i2, 0
2007af8: 02 80 00 1d be 2007b6c <pthread_barrier_init+0x8c>
2007afc: 80 a6 60 00 cmp %i1, 0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007b00: 32 80 00 06 bne,a 2007b18 <pthread_barrier_init+0x38>
2007b04: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
2007b08: 90 07 bf f8 add %fp, -8, %o0
2007b0c: 7f ff ff bd call 2007a00 <pthread_barrierattr_init>
2007b10: 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 )
2007b14: c2 06 40 00 ld [ %i1 ], %g1
2007b18: 80 a0 60 00 cmp %g1, 0
2007b1c: 02 80 00 14 be 2007b6c <pthread_barrier_init+0x8c>
2007b20: b0 10 20 16 mov 0x16, %i0
return EINVAL;
switch ( the_attr->process_shared ) {
2007b24: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007b28: 80 a0 60 00 cmp %g1, 0
2007b2c: 12 80 00 10 bne 2007b6c <pthread_barrier_init+0x8c> <== NEVER TAKEN
2007b30: 03 00 80 7c sethi %hi(0x201f000), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2007b34: c4 00 62 40 ld [ %g1 + 0x240 ], %g2 ! 201f240 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
2007b38: c0 27 bf f0 clr [ %fp + -16 ]
the_attributes.maximum_count = count;
2007b3c: f4 27 bf f4 st %i2, [ %fp + -12 ]
2007b40: 84 00 a0 01 inc %g2
2007b44: c4 20 62 40 st %g2, [ %g1 + 0x240 ]
return _Thread_Dispatch_disable_level;
2007b48: c2 00 62 40 ld [ %g1 + 0x240 ], %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 *)
2007b4c: 37 00 80 7d sethi %hi(0x201f400), %i3
2007b50: 40 00 08 70 call 2009d10 <_Objects_Allocate>
2007b54: 90 16 e2 00 or %i3, 0x200, %o0 ! 201f600 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
2007b58: b8 92 20 00 orcc %o0, 0, %i4
2007b5c: 12 80 00 06 bne 2007b74 <pthread_barrier_init+0x94>
2007b60: 90 07 20 10 add %i4, 0x10, %o0
_Thread_Enable_dispatch();
2007b64: 40 00 0d 59 call 200b0c8 <_Thread_Enable_dispatch>
2007b68: b0 10 20 0b mov 0xb, %i0
return EAGAIN;
2007b6c: 81 c7 e0 08 ret
2007b70: 81 e8 00 00 restore
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
2007b74: 40 00 05 d4 call 20092c4 <_CORE_barrier_Initialize>
2007b78: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007b7c: c4 17 20 0a lduh [ %i4 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007b80: b6 16 e2 00 or %i3, 0x200, %i3
2007b84: c6 06 e0 1c ld [ %i3 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007b88: c2 07 20 08 ld [ %i4 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007b8c: 85 28 a0 02 sll %g2, 2, %g2
2007b90: f8 20 c0 02 st %i4, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
2007b94: c0 27 20 0c clr [ %i4 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
2007b98: c2 27 40 00 st %g1, [ %i5 ]
_Thread_Enable_dispatch();
2007b9c: 40 00 0d 4b call 200b0c8 <_Thread_Enable_dispatch>
2007ba0: b0 10 20 00 clr %i0
return 0;
}
2007ba4: 81 c7 e0 08 ret
2007ba8: 81 e8 00 00 restore
02007368 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
2007368: 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 )
200736c: 80 a6 20 00 cmp %i0, 0
2007370: 02 80 00 15 be 20073c4 <pthread_cleanup_push+0x5c>
2007374: 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++;
2007378: 03 00 80 7a sethi %hi(0x201e800), %g1
200737c: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 201ea60 <_Thread_Dispatch_disable_level>
2007380: 84 00 a0 01 inc %g2
2007384: c4 20 62 60 st %g2, [ %g1 + 0x260 ]
return _Thread_Dispatch_disable_level;
2007388: c2 00 62 60 ld [ %g1 + 0x260 ], %g1
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
200738c: 40 00 11 e2 call 200bb14 <_Workspace_Allocate>
2007390: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
2007394: 92 92 20 00 orcc %o0, 0, %o1
2007398: 02 80 00 09 be 20073bc <pthread_cleanup_push+0x54> <== NEVER TAKEN
200739c: 01 00 00 00 nop
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
20073a0: 03 00 80 7b sethi %hi(0x201ec00), %g1
20073a4: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 201efac <_Per_CPU_Information+0xc>
handler_stack = &thread_support->Cancellation_Handlers;
20073a8: d0 00 61 5c ld [ %g1 + 0x15c ], %o0
handler->routine = routine;
20073ac: f0 22 60 08 st %i0, [ %o1 + 8 ]
handler->arg = arg;
20073b0: f2 22 60 0c st %i1, [ %o1 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
20073b4: 40 00 06 1f call 2008c30 <_Chain_Append>
20073b8: 90 02 20 e4 add %o0, 0xe4, %o0
}
_Thread_Enable_dispatch();
20073bc: 40 00 0d 99 call 200aa20 <_Thread_Enable_dispatch>
20073c0: 81 e8 00 00 restore
20073c4: 81 c7 e0 08 ret
20073c8: 81 e8 00 00 restore
0200836c <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
200836c: 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;
2008370: 80 a6 60 00 cmp %i1, 0
2008374: 12 80 00 04 bne 2008384 <pthread_cond_init+0x18>
2008378: ba 10 00 18 mov %i0, %i5
else the_attr = &_POSIX_Condition_variables_Default_attributes;
200837c: 33 00 80 78 sethi %hi(0x201e000), %i1
2008380: b2 16 61 74 or %i1, 0x174, %i1 ! 201e174 <_POSIX_Condition_variables_Default_attributes>
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
2008384: c2 06 60 04 ld [ %i1 + 4 ], %g1
2008388: 80 a0 60 01 cmp %g1, 1
200838c: 02 80 00 12 be 20083d4 <pthread_cond_init+0x68> <== NEVER TAKEN
2008390: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !the_attr->is_initialized )
2008394: c2 06 40 00 ld [ %i1 ], %g1
2008398: 80 a0 60 00 cmp %g1, 0
200839c: 02 80 00 0e be 20083d4 <pthread_cond_init+0x68>
20083a0: 03 00 80 81 sethi %hi(0x2020400), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
20083a4: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2020440 <_Thread_Dispatch_disable_level>
20083a8: 84 00 a0 01 inc %g2
20083ac: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
return _Thread_Dispatch_disable_level;
20083b0: c2 00 60 40 ld [ %g1 + 0x40 ], %g1
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
20083b4: 37 00 80 82 sethi %hi(0x2020800), %i3
20083b8: 40 00 0a 0e call 200abf0 <_Objects_Allocate>
20083bc: 90 16 e0 98 or %i3, 0x98, %o0 ! 2020898 <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
20083c0: b8 92 20 00 orcc %o0, 0, %i4
20083c4: 32 80 00 06 bne,a 20083dc <pthread_cond_init+0x70>
20083c8: c2 06 60 04 ld [ %i1 + 4 ], %g1
_Thread_Enable_dispatch();
20083cc: 40 00 0e f7 call 200bfa8 <_Thread_Enable_dispatch>
20083d0: b0 10 20 0c mov 0xc, %i0
return ENOMEM;
20083d4: 81 c7 e0 08 ret
20083d8: 81 e8 00 00 restore
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
20083dc: 90 07 20 18 add %i4, 0x18, %o0
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
20083e0: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
20083e4: 92 10 20 00 clr %o1
20083e8: 15 04 00 02 sethi %hi(0x10000800), %o2
20083ec: 96 10 20 74 mov 0x74, %o3
20083f0: 40 00 10 ef call 200c7ac <_Thread_queue_Initialize>
20083f4: c0 27 20 14 clr [ %i4 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20083f8: c4 17 20 0a lduh [ %i4 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20083fc: b6 16 e0 98 or %i3, 0x98, %i3
2008400: c6 06 e0 1c ld [ %i3 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008404: c2 07 20 08 ld [ %i4 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008408: 85 28 a0 02 sll %g2, 2, %g2
200840c: f8 20 c0 02 st %i4, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
2008410: c0 27 20 0c clr [ %i4 + 0xc ]
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
2008414: c2 27 40 00 st %g1, [ %i5 ]
_Thread_Enable_dispatch();
2008418: 40 00 0e e4 call 200bfa8 <_Thread_Enable_dispatch>
200841c: b0 10 20 00 clr %i0
return 0;
}
2008420: 81 c7 e0 08 ret
2008424: 81 e8 00 00 restore
020081d8 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
20081d8: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
20081dc: 80 a0 60 00 cmp %g1, 0
20081e0: 02 80 00 08 be 2008200 <pthread_condattr_destroy+0x28>
20081e4: 90 10 20 16 mov 0x16, %o0
20081e8: c4 00 40 00 ld [ %g1 ], %g2
20081ec: 80 a0 a0 00 cmp %g2, 0
20081f0: 02 80 00 04 be 2008200 <pthread_condattr_destroy+0x28> <== NEVER TAKEN
20081f4: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
20081f8: c0 20 40 00 clr [ %g1 ]
return 0;
20081fc: 90 10 20 00 clr %o0
}
2008200: 81 c3 e0 08 retl
020077b4 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
20077b4: 9d e3 bf 58 save %sp, -168, %sp
20077b8: ba 10 00 18 mov %i0, %i5
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
20077bc: 80 a6 a0 00 cmp %i2, 0
20077c0: 02 80 00 66 be 2007958 <pthread_create+0x1a4>
20077c4: b0 10 20 0e mov 0xe, %i0
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
20077c8: 80 a6 60 00 cmp %i1, 0
20077cc: 32 80 00 05 bne,a 20077e0 <pthread_create+0x2c>
20077d0: c2 06 40 00 ld [ %i1 ], %g1
20077d4: 33 00 80 81 sethi %hi(0x2020400), %i1
20077d8: b2 16 62 2c or %i1, 0x22c, %i1 ! 202062c <_POSIX_Threads_Default_attributes>
if ( !the_attr->is_initialized )
20077dc: c2 06 40 00 ld [ %i1 ], %g1
20077e0: 80 a0 60 00 cmp %g1, 0
20077e4: 02 80 00 5d be 2007958 <pthread_create+0x1a4>
20077e8: b0 10 20 16 mov 0x16, %i0
* 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) )
20077ec: c2 06 60 04 ld [ %i1 + 4 ], %g1
20077f0: 80 a0 60 00 cmp %g1, 0
20077f4: 02 80 00 07 be 2007810 <pthread_create+0x5c>
20077f8: 03 00 80 86 sethi %hi(0x2021800), %g1
20077fc: c4 06 60 08 ld [ %i1 + 8 ], %g2
2007800: c2 00 63 68 ld [ %g1 + 0x368 ], %g1
2007804: 80 a0 80 01 cmp %g2, %g1
2007808: 0a 80 00 79 bcs 20079ec <pthread_create+0x238>
200780c: 01 00 00 00 nop
* 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 ) {
2007810: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2007814: 80 a0 60 01 cmp %g1, 1
2007818: 02 80 00 06 be 2007830 <pthread_create+0x7c>
200781c: 80 a0 60 02 cmp %g1, 2
2007820: 12 80 00 4e bne 2007958 <pthread_create+0x1a4>
2007824: b0 10 20 16 mov 0x16, %i0
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
2007828: 10 80 00 09 b 200784c <pthread_create+0x98>
200782c: e0 06 60 14 ld [ %i1 + 0x14 ], %l0
* 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 ];
2007830: 03 00 80 8b sethi %hi(0x2022c00), %g1
2007834: c2 00 62 4c ld [ %g1 + 0x24c ], %g1 ! 2022e4c <_Per_CPU_Information+0xc>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
2007838: 90 07 bf dc add %fp, -36, %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 ];
200783c: d2 00 61 5c ld [ %g1 + 0x15c ], %o1
schedpolicy = api->schedpolicy;
2007840: e0 02 60 84 ld [ %o1 + 0x84 ], %l0
schedparam = api->schedparam;
2007844: 10 80 00 04 b 2007854 <pthread_create+0xa0>
2007848: 92 02 60 88 add %o1, 0x88, %o1
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
200784c: 90 07 bf dc add %fp, -36, %o0
2007850: 92 06 60 18 add %i1, 0x18, %o1
2007854: 40 00 25 44 call 2010d64 <memcpy>
2007858: 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 )
200785c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2007860: 80 a0 60 00 cmp %g1, 0
2007864: 12 80 00 3d bne 2007958 <pthread_create+0x1a4>
2007868: b0 10 20 86 mov 0x86, %i0
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
200786c: d0 07 bf dc ld [ %fp + -36 ], %o0
2007870: 40 00 19 05 call 200dc84 <_POSIX_Priority_Is_valid>
2007874: b0 10 20 16 mov 0x16, %i0
2007878: 80 8a 20 ff btst 0xff, %o0
200787c: 02 80 00 37 be 2007958 <pthread_create+0x1a4> <== NEVER TAKEN
2007880: 03 00 80 86 sethi %hi(0x2021800), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
2007884: e4 07 bf dc ld [ %fp + -36 ], %l2
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
2007888: e2 08 63 64 ldub [ %g1 + 0x364 ], %l1
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
200788c: 90 10 00 10 mov %l0, %o0
2007890: 92 07 bf dc add %fp, -36, %o1
2007894: 94 07 bf f8 add %fp, -8, %o2
2007898: 40 00 19 06 call 200dcb0 <_POSIX_Thread_Translate_sched_param>
200789c: 96 07 bf fc add %fp, -4, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
20078a0: b0 92 20 00 orcc %o0, 0, %i0
20078a4: 12 80 00 2d bne 2007958 <pthread_create+0x1a4>
20078a8: 27 00 80 8a sethi %hi(0x2022800), %l3
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
20078ac: 40 00 06 32 call 2009174 <_API_Mutex_Lock>
20078b0: d0 04 e1 a8 ld [ %l3 + 0x1a8 ], %o0 ! 20229a8 <_RTEMS_Allocator_Mutex>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
20078b4: 11 00 80 8a sethi %hi(0x2022800), %o0
20078b8: 40 00 08 de call 2009c30 <_Objects_Allocate>
20078bc: 90 12 23 40 or %o0, 0x340, %o0 ! 2022b40 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
20078c0: b8 92 20 00 orcc %o0, 0, %i4
20078c4: 32 80 00 04 bne,a 20078d4 <pthread_create+0x120>
20078c8: c2 06 60 08 ld [ %i1 + 8 ], %g1
_RTEMS_Unlock_allocator();
20078cc: 10 80 00 21 b 2007950 <pthread_create+0x19c>
20078d0: d0 04 e1 a8 ld [ %l3 + 0x1a8 ], %o0
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
20078d4: 05 00 80 86 sethi %hi(0x2021800), %g2
20078d8: d6 00 a3 68 ld [ %g2 + 0x368 ], %o3 ! 2021b68 <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(
20078dc: c0 27 bf d4 clr [ %fp + -44 ]
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
20078e0: 97 2a e0 01 sll %o3, 1, %o3
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
20078e4: 80 a2 c0 01 cmp %o3, %g1
20078e8: 1a 80 00 03 bcc 20078f4 <pthread_create+0x140>
20078ec: d4 06 60 04 ld [ %i1 + 4 ], %o2
20078f0: 96 10 00 01 mov %g1, %o3
20078f4: 82 10 20 01 mov 1, %g1
20078f8: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
20078fc: c2 07 bf f8 ld [ %fp + -8 ], %g1
2007900: 9a 0c 60 ff and %l1, 0xff, %o5
2007904: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
2007908: c2 07 bf fc ld [ %fp + -4 ], %g1
200790c: c0 23 a0 68 clr [ %sp + 0x68 ]
2007910: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2007914: 82 07 bf d4 add %fp, -44, %g1
2007918: 23 00 80 8a sethi %hi(0x2022800), %l1
200791c: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2007920: 90 14 63 40 or %l1, 0x340, %o0
2007924: 92 10 00 1c mov %i4, %o1
2007928: 98 10 20 01 mov 1, %o4
200792c: 40 00 0d e8 call 200b0cc <_Thread_Initialize>
2007930: 9a 23 40 12 sub %o5, %l2, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
2007934: 80 8a 20 ff btst 0xff, %o0
2007938: 12 80 00 0a bne 2007960 <pthread_create+0x1ac>
200793c: 90 14 63 40 or %l1, 0x340, %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
2007940: 40 00 09 95 call 2009f94 <_Objects_Free>
2007944: 92 10 00 1c mov %i4, %o1
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
2007948: 03 00 80 8a sethi %hi(0x2022800), %g1
200794c: d0 00 61 a8 ld [ %g1 + 0x1a8 ], %o0 ! 20229a8 <_RTEMS_Allocator_Mutex>
2007950: 40 00 06 1e call 20091c8 <_API_Mutex_Unlock>
2007954: b0 10 20 0b mov 0xb, %i0
return EAGAIN;
2007958: 81 c7 e0 08 ret
200795c: 81 e8 00 00 restore
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
2007960: e2 07 21 5c ld [ %i4 + 0x15c ], %l1
api->Attributes = *the_attr;
2007964: 92 10 00 19 mov %i1, %o1
2007968: 94 10 20 40 mov 0x40, %o2
200796c: 40 00 24 fe call 2010d64 <memcpy>
2007970: 90 10 00 11 mov %l1, %o0
api->detachstate = the_attr->detachstate;
2007974: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
2007978: 92 07 bf dc add %fp, -36, %o1
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
200797c: c2 24 60 40 st %g1, [ %l1 + 0x40 ]
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
2007980: 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;
2007984: e0 24 60 84 st %l0, [ %l1 + 0x84 ]
api->schedparam = schedparam;
2007988: 40 00 24 f7 call 2010d64 <memcpy>
200798c: 90 04 60 88 add %l1, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
2007990: 90 10 00 1c mov %i4, %o0
2007994: 92 10 20 01 mov 1, %o1
2007998: 94 10 00 1a mov %i2, %o2
200799c: 96 10 00 1b mov %i3, %o3
20079a0: 40 00 10 15 call 200b9f4 <_Thread_Start>
20079a4: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
20079a8: 80 a4 20 04 cmp %l0, 4
20079ac: 32 80 00 0a bne,a 20079d4 <pthread_create+0x220>
20079b0: c2 07 20 08 ld [ %i4 + 8 ], %g1
_Watchdog_Insert_ticks(
20079b4: 40 00 10 38 call 200ba94 <_Timespec_To_ticks>
20079b8: 90 04 60 90 add %l1, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20079bc: 92 04 60 a8 add %l1, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20079c0: d0 24 60 b4 st %o0, [ %l1 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20079c4: 11 00 80 8a sethi %hi(0x2022800), %o0
20079c8: 40 00 11 10 call 200be08 <_Watchdog_Insert>
20079cc: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 20229c0 <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
20079d0: c2 07 20 08 ld [ %i4 + 8 ], %g1
20079d4: c2 27 40 00 st %g1, [ %i5 ]
_RTEMS_Unlock_allocator();
20079d8: 03 00 80 8a sethi %hi(0x2022800), %g1
20079dc: 40 00 05 fb call 20091c8 <_API_Mutex_Unlock>
20079e0: d0 00 61 a8 ld [ %g1 + 0x1a8 ], %o0 ! 20229a8 <_RTEMS_Allocator_Mutex>
return 0;
20079e4: 81 c7 e0 08 ret
20079e8: 81 e8 00 00 restore
}
20079ec: 81 c7 e0 08 ret
20079f0: 81 e8 00 00 restore
0201a8c4 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
201a8c4: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
201a8c8: 80 a6 60 00 cmp %i1, 0
201a8cc: 02 80 00 06 be 201a8e4 <pthread_kill+0x20>
201a8d0: 90 10 00 18 mov %i0, %o0
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
201a8d4: b6 06 7f ff add %i1, -1, %i3
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201a8d8: 80 a6 e0 1f cmp %i3, 0x1f
201a8dc: 08 80 00 08 bleu 201a8fc <pthread_kill+0x38>
201a8e0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
201a8e4: 7f ff d3 e4 call 200f874 <__errno>
201a8e8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff>
201a8ec: 82 10 20 16 mov 0x16, %g1
201a8f0: c2 22 00 00 st %g1, [ %o0 ]
201a8f4: 81 c7 e0 08 ret
201a8f8: 81 e8 00 00 restore
the_thread = _Thread_Get( thread, &location );
201a8fc: 7f ff be 2e call 200a1b4 <_Thread_Get>
201a900: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
201a904: c2 07 bf fc ld [ %fp + -4 ], %g1
201a908: 80 a0 60 00 cmp %g1, 0
201a90c: 12 80 00 22 bne 201a994 <pthread_kill+0xd0> <== NEVER TAKEN
201a910: 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 ) {
201a914: 85 2e 60 02 sll %i1, 2, %g2
201a918: 87 2e 60 04 sll %i1, 4, %g3
201a91c: 86 20 c0 02 sub %g3, %g2, %g3
201a920: 05 00 80 78 sethi %hi(0x201e000), %g2
201a924: 84 10 a1 b0 or %g2, 0x1b0, %g2 ! 201e1b0 <_POSIX_signals_Vectors>
201a928: 84 00 80 03 add %g2, %g3, %g2
201a92c: c4 00 a0 08 ld [ %g2 + 8 ], %g2
201a930: 80 a0 a0 01 cmp %g2, 1
201a934: 02 80 00 14 be 201a984 <pthread_kill+0xc0>
201a938: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a93c: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
201a940: ba 10 20 01 mov 1, %i5
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a944: 92 10 00 19 mov %i1, %o1
201a948: b7 2f 40 1b sll %i5, %i3, %i3
201a94c: 94 10 20 00 clr %o2
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a950: b6 10 80 1b or %g2, %i3, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a954: 7f ff ff 89 call 201a778 <_POSIX_signals_Unblock_thread>
201a958: f6 20 60 d4 st %i3, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a95c: 03 00 80 78 sethi %hi(0x201e000), %g1
201a960: 82 10 61 50 or %g1, 0x150, %g1 ! 201e150 <_Per_CPU_Information>
201a964: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a968: 80 a0 a0 00 cmp %g2, 0
201a96c: 02 80 00 06 be 201a984 <pthread_kill+0xc0>
201a970: 01 00 00 00 nop
201a974: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a978: 80 a7 00 02 cmp %i4, %g2
201a97c: 22 80 00 02 be,a 201a984 <pthread_kill+0xc0>
201a980: fa 28 60 18 stb %i5, [ %g1 + 0x18 ]
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
201a984: 7f ff bd ff call 200a180 <_Thread_Enable_dispatch>
201a988: b0 10 20 00 clr %i0
return 0;
201a98c: 81 c7 e0 08 ret
201a990: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
201a994: 7f ff d3 b8 call 200f874 <__errno> <== NOT EXECUTED
201a998: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201a99c: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
201a9a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
201a9a4: 81 c7 e0 08 ret <== NOT EXECUTED
201a9a8: 81 e8 00 00 restore <== NOT EXECUTED
02009960 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
2009960: 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 );
2009964: 92 07 bf fc add %fp, -4, %o1
2009968: 40 00 00 37 call 2009a44 <_POSIX_Absolute_timeout_to_ticks>
200996c: 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 );
2009970: d4 07 bf fc ld [ %fp + -4 ], %o2
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
2009974: 82 1a 20 03 xor %o0, 3, %g1
2009978: 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 );
200997c: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
2009980: b8 60 3f ff subx %g0, -1, %i4
2009984: 90 10 00 18 mov %i0, %o0
2009988: 7f ff ff bd call 200987c <_POSIX_Mutex_Lock_support>
200998c: 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) ) {
2009990: 80 a7 20 00 cmp %i4, 0
2009994: 12 80 00 0d bne 20099c8 <pthread_mutex_timedlock+0x68>
2009998: b0 10 00 08 mov %o0, %i0
200999c: 80 a2 20 10 cmp %o0, 0x10
20099a0: 12 80 00 0a bne 20099c8 <pthread_mutex_timedlock+0x68>
20099a4: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
20099a8: 02 80 00 07 be 20099c4 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
20099ac: ba 07 7f ff add %i5, -1, %i5
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
20099b0: 80 a7 60 01 cmp %i5, 1
20099b4: 18 80 00 05 bgu 20099c8 <pthread_mutex_timedlock+0x68> <== NEVER TAKEN
20099b8: 01 00 00 00 nop
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
20099bc: 81 c7 e0 08 ret
20099c0: 91 e8 20 74 restore %g0, 0x74, %o0
20099c4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
}
return lock_status;
}
20099c8: 81 c7 e0 08 ret
20099cc: 81 e8 00 00 restore
0200707c <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
200707c: 82 10 00 08 mov %o0, %g1
if ( !attr )
2007080: 80 a0 60 00 cmp %g1, 0
2007084: 02 80 00 0b be 20070b0 <pthread_mutexattr_gettype+0x34>
2007088: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
200708c: c4 00 40 00 ld [ %g1 ], %g2
2007090: 80 a0 a0 00 cmp %g2, 0
2007094: 02 80 00 07 be 20070b0 <pthread_mutexattr_gettype+0x34>
2007098: 80 a2 60 00 cmp %o1, 0
return EINVAL;
if ( !type )
200709c: 02 80 00 05 be 20070b0 <pthread_mutexattr_gettype+0x34> <== NEVER TAKEN
20070a0: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
20070a4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
20070a8: 90 10 20 00 clr %o0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
20070ac: c2 22 40 00 st %g1, [ %o1 ]
return 0;
}
20070b0: 81 c3 e0 08 retl
02009550 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
2009550: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
2009554: 80 a0 60 00 cmp %g1, 0
2009558: 02 80 00 0a be 2009580 <pthread_mutexattr_setpshared+0x30>
200955c: 90 10 20 16 mov 0x16, %o0
2009560: c4 00 40 00 ld [ %g1 ], %g2
2009564: 80 a0 a0 00 cmp %g2, 0
2009568: 02 80 00 06 be 2009580 <pthread_mutexattr_setpshared+0x30>
200956c: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
2009570: 18 80 00 04 bgu 2009580 <pthread_mutexattr_setpshared+0x30><== NEVER TAKEN
2009574: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
2009578: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
200957c: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
2009580: 81 c3 e0 08 retl
020070e8 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
20070e8: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
20070ec: 80 a0 60 00 cmp %g1, 0
20070f0: 02 80 00 0a be 2007118 <pthread_mutexattr_settype+0x30>
20070f4: 90 10 20 16 mov 0x16, %o0
20070f8: c4 00 40 00 ld [ %g1 ], %g2
20070fc: 80 a0 a0 00 cmp %g2, 0
2007100: 02 80 00 06 be 2007118 <pthread_mutexattr_settype+0x30> <== NEVER TAKEN
2007104: 80 a2 60 03 cmp %o1, 3
return EINVAL;
switch ( type ) {
2007108: 18 80 00 04 bgu 2007118 <pthread_mutexattr_settype+0x30>
200710c: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
2007110: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
2007114: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
2007118: 81 c3 e0 08 retl
02007e38 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
2007e38: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
2007e3c: 80 a6 60 00 cmp %i1, 0
2007e40: 02 80 00 1c be 2007eb0 <pthread_once+0x78>
2007e44: ba 10 00 18 mov %i0, %i5
2007e48: 80 a6 20 00 cmp %i0, 0
2007e4c: 22 80 00 17 be,a 2007ea8 <pthread_once+0x70>
2007e50: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !once_control->init_executed ) {
2007e54: c2 06 20 04 ld [ %i0 + 4 ], %g1
2007e58: 80 a0 60 00 cmp %g1, 0
2007e5c: 12 80 00 13 bne 2007ea8 <pthread_once+0x70>
2007e60: b0 10 20 00 clr %i0
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2007e64: 90 10 21 00 mov 0x100, %o0
2007e68: 92 10 21 00 mov 0x100, %o1
2007e6c: 40 00 03 06 call 2008a84 <rtems_task_mode>
2007e70: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
2007e74: c2 07 60 04 ld [ %i5 + 4 ], %g1
2007e78: 80 a0 60 00 cmp %g1, 0
2007e7c: 12 80 00 07 bne 2007e98 <pthread_once+0x60> <== NEVER TAKEN
2007e80: d0 07 bf fc ld [ %fp + -4 ], %o0
once_control->is_initialized = true;
2007e84: 82 10 20 01 mov 1, %g1
2007e88: c2 27 40 00 st %g1, [ %i5 ]
once_control->init_executed = true;
(*init_routine)();
2007e8c: 9f c6 40 00 call %i1
2007e90: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2007e94: d0 07 bf fc ld [ %fp + -4 ], %o0
2007e98: 92 10 21 00 mov 0x100, %o1
2007e9c: 94 07 bf fc add %fp, -4, %o2
2007ea0: 40 00 02 f9 call 2008a84 <rtems_task_mode>
2007ea4: b0 10 20 00 clr %i0
2007ea8: 81 c7 e0 08 ret
2007eac: 81 e8 00 00 restore
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
2007eb0: b0 10 20 16 mov 0x16, %i0
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
2007eb4: 81 c7 e0 08 ret
2007eb8: 81 e8 00 00 restore
02007f64 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
2007f64: 9d e3 bf 90 save %sp, -112, %sp
2007f68: ba 10 00 18 mov %i0, %i5
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
2007f6c: 80 a7 60 00 cmp %i5, 0
2007f70: 02 80 00 1d be 2007fe4 <pthread_rwlock_init+0x80>
2007f74: b0 10 20 16 mov 0x16, %i0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007f78: 80 a6 60 00 cmp %i1, 0
2007f7c: 32 80 00 06 bne,a 2007f94 <pthread_rwlock_init+0x30>
2007f80: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
2007f84: 90 07 bf f4 add %fp, -12, %o0
2007f88: 40 00 01 ac call 2008638 <pthread_rwlockattr_init>
2007f8c: b2 07 bf f4 add %fp, -12, %i1
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
2007f90: c2 06 40 00 ld [ %i1 ], %g1
2007f94: 80 a0 60 00 cmp %g1, 0
2007f98: 02 80 00 13 be 2007fe4 <pthread_rwlock_init+0x80> <== NEVER TAKEN
2007f9c: b0 10 20 16 mov 0x16, %i0
return EINVAL;
switch ( the_attr->process_shared ) {
2007fa0: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007fa4: 80 a0 60 00 cmp %g1, 0
2007fa8: 12 80 00 0f bne 2007fe4 <pthread_rwlock_init+0x80> <== NEVER TAKEN
2007fac: 03 00 80 89 sethi %hi(0x2022400), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2007fb0: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2022730 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
2007fb4: c0 27 bf fc clr [ %fp + -4 ]
2007fb8: 84 00 a0 01 inc %g2
2007fbc: c4 20 63 30 st %g2, [ %g1 + 0x330 ]
return _Thread_Dispatch_disable_level;
2007fc0: c2 00 63 30 ld [ %g1 + 0x330 ], %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 *)
2007fc4: 37 00 80 8a sethi %hi(0x2022800), %i3
2007fc8: 40 00 0a 7b call 200a9b4 <_Objects_Allocate>
2007fcc: 90 16 e1 70 or %i3, 0x170, %o0 ! 2022970 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
2007fd0: b8 92 20 00 orcc %o0, 0, %i4
2007fd4: 12 80 00 06 bne 2007fec <pthread_rwlock_init+0x88>
2007fd8: 90 07 20 10 add %i4, 0x10, %o0
_Thread_Enable_dispatch();
2007fdc: 40 00 0f 9e call 200be54 <_Thread_Enable_dispatch>
2007fe0: b0 10 20 0b mov 0xb, %i0
return EAGAIN;
2007fe4: 81 c7 e0 08 ret
2007fe8: 81 e8 00 00 restore
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
2007fec: 40 00 08 ca call 200a314 <_CORE_RWLock_Initialize>
2007ff0: 92 07 bf fc add %fp, -4, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007ff4: c4 17 20 0a lduh [ %i4 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007ff8: b6 16 e1 70 or %i3, 0x170, %i3
2007ffc: c6 06 e0 1c ld [ %i3 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008000: c2 07 20 08 ld [ %i4 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008004: 85 28 a0 02 sll %g2, 2, %g2
2008008: f8 20 c0 02 st %i4, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
200800c: c0 27 20 0c clr [ %i4 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
2008010: c2 27 40 00 st %g1, [ %i5 ]
_Thread_Enable_dispatch();
2008014: 40 00 0f 90 call 200be54 <_Thread_Enable_dispatch>
2008018: b0 10 20 00 clr %i0
return 0;
}
200801c: 81 c7 e0 08 ret
2008020: 81 e8 00 00 restore
02008918 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008918: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
200891c: ba 10 20 16 mov 0x16, %i5
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
2008920: 80 a6 20 00 cmp %i0, 0
2008924: 02 80 00 2b be 20089d0 <pthread_rwlock_timedrdlock+0xb8>
2008928: 90 10 00 19 mov %i1, %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 );
200892c: 40 00 19 c2 call 200f034 <_POSIX_Absolute_timeout_to_ticks>
2008930: 92 07 bf fc add %fp, -4, %o1
2008934: d2 06 00 00 ld [ %i0 ], %o1
2008938: b8 10 00 08 mov %o0, %i4
200893c: 94 07 bf f8 add %fp, -8, %o2
2008940: 11 00 80 83 sethi %hi(0x2020c00), %o0
2008944: 40 00 0b 16 call 200b59c <_Objects_Get>
2008948: 90 12 23 40 or %o0, 0x340, %o0 ! 2020f40 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
200894c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2008950: 80 a0 60 00 cmp %g1, 0
2008954: 12 80 00 1f bne 20089d0 <pthread_rwlock_timedrdlock+0xb8>
2008958: d6 07 bf fc ld [ %fp + -4 ], %o3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
200895c: d2 06 00 00 ld [ %i0 ], %o1
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
2008960: 82 1f 20 03 xor %i4, 3, %g1
2008964: 90 02 20 10 add %o0, 0x10, %o0
2008968: 80 a0 00 01 cmp %g0, %g1
200896c: 98 10 20 00 clr %o4
2008970: b6 60 3f ff subx %g0, -1, %i3
2008974: 40 00 07 80 call 200a774 <_CORE_RWLock_Obtain_for_reading>
2008978: 94 10 00 1b mov %i3, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
200897c: 40 00 0e bb call 200c468 <_Thread_Enable_dispatch>
2008980: 01 00 00 00 nop
if ( !do_wait ) {
2008984: 80 a6 e0 00 cmp %i3, 0
2008988: 12 80 00 0d bne 20089bc <pthread_rwlock_timedrdlock+0xa4>
200898c: 03 00 80 84 sethi %hi(0x2021000), %g1
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
2008990: c2 00 62 8c ld [ %g1 + 0x28c ], %g1 ! 202128c <_Per_CPU_Information+0xc>
2008994: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008998: 80 a0 60 02 cmp %g1, 2
200899c: 32 80 00 09 bne,a 20089c0 <pthread_rwlock_timedrdlock+0xa8>
20089a0: 03 00 80 84 sethi %hi(0x2021000), %g1
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
20089a4: 80 a7 20 00 cmp %i4, 0
20089a8: 02 80 00 0a be 20089d0 <pthread_rwlock_timedrdlock+0xb8> <== NEVER TAKEN
20089ac: b8 07 3f ff add %i4, -1, %i4
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
20089b0: 80 a7 20 01 cmp %i4, 1
20089b4: 08 80 00 07 bleu 20089d0 <pthread_rwlock_timedrdlock+0xb8><== ALWAYS TAKEN
20089b8: ba 10 20 74 mov 0x74, %i5
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
20089bc: 03 00 80 84 sethi %hi(0x2021000), %g1
20089c0: c2 00 62 8c ld [ %g1 + 0x28c ], %g1 ! 202128c <_Per_CPU_Information+0xc>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
20089c4: 40 00 00 35 call 2008a98 <_POSIX_RWLock_Translate_core_RWLock_return_code>
20089c8: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
20089cc: ba 10 00 08 mov %o0, %i5
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
20089d0: 81 c7 e0 08 ret
20089d4: 91 e8 00 1d restore %g0, %i5, %o0
020089d8 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
20089d8: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
20089dc: ba 10 20 16 mov 0x16, %i5
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
20089e0: 80 a6 20 00 cmp %i0, 0
20089e4: 02 80 00 2b be 2008a90 <pthread_rwlock_timedwrlock+0xb8>
20089e8: 90 10 00 19 mov %i1, %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 );
20089ec: 40 00 19 92 call 200f034 <_POSIX_Absolute_timeout_to_ticks>
20089f0: 92 07 bf fc add %fp, -4, %o1
20089f4: d2 06 00 00 ld [ %i0 ], %o1
20089f8: b8 10 00 08 mov %o0, %i4
20089fc: 94 07 bf f8 add %fp, -8, %o2
2008a00: 11 00 80 83 sethi %hi(0x2020c00), %o0
2008a04: 40 00 0a e6 call 200b59c <_Objects_Get>
2008a08: 90 12 23 40 or %o0, 0x340, %o0 ! 2020f40 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
2008a0c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2008a10: 80 a0 60 00 cmp %g1, 0
2008a14: 12 80 00 1f bne 2008a90 <pthread_rwlock_timedwrlock+0xb8>
2008a18: d6 07 bf fc ld [ %fp + -4 ], %o3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
2008a1c: d2 06 00 00 ld [ %i0 ], %o1
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
2008a20: 82 1f 20 03 xor %i4, 3, %g1
2008a24: 90 02 20 10 add %o0, 0x10, %o0
2008a28: 80 a0 00 01 cmp %g0, %g1
2008a2c: 98 10 20 00 clr %o4
2008a30: b6 60 3f ff subx %g0, -1, %i3
2008a34: 40 00 07 84 call 200a844 <_CORE_RWLock_Obtain_for_writing>
2008a38: 94 10 00 1b mov %i3, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
2008a3c: 40 00 0e 8b call 200c468 <_Thread_Enable_dispatch>
2008a40: 01 00 00 00 nop
if ( !do_wait &&
2008a44: 80 a6 e0 00 cmp %i3, 0
2008a48: 12 80 00 0d bne 2008a7c <pthread_rwlock_timedwrlock+0xa4>
2008a4c: 03 00 80 84 sethi %hi(0x2021000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
2008a50: c2 00 62 8c ld [ %g1 + 0x28c ], %g1 ! 202128c <_Per_CPU_Information+0xc>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
2008a54: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008a58: 80 a0 60 02 cmp %g1, 2
2008a5c: 32 80 00 09 bne,a 2008a80 <pthread_rwlock_timedwrlock+0xa8>
2008a60: 03 00 80 84 sethi %hi(0x2021000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2008a64: 80 a7 20 00 cmp %i4, 0
2008a68: 02 80 00 0a be 2008a90 <pthread_rwlock_timedwrlock+0xb8> <== NEVER TAKEN
2008a6c: b8 07 3f ff add %i4, -1, %i4
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2008a70: 80 a7 20 01 cmp %i4, 1
2008a74: 08 80 00 07 bleu 2008a90 <pthread_rwlock_timedwrlock+0xb8><== ALWAYS TAKEN
2008a78: ba 10 20 74 mov 0x74, %i5
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
2008a7c: 03 00 80 84 sethi %hi(0x2021000), %g1
2008a80: c2 00 62 8c ld [ %g1 + 0x28c ], %g1 ! 202128c <_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(
2008a84: 40 00 00 05 call 2008a98 <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008a88: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
2008a8c: ba 10 00 08 mov %o0, %i5
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
2008a90: 81 c7 e0 08 ret
2008a94: 91 e8 00 1d restore %g0, %i5, %o0
02009218 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
2009218: 82 10 00 08 mov %o0, %g1
if ( !attr )
200921c: 80 a0 60 00 cmp %g1, 0
2009220: 02 80 00 0a be 2009248 <pthread_rwlockattr_setpshared+0x30>
2009224: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
2009228: c4 00 40 00 ld [ %g1 ], %g2
200922c: 80 a0 a0 00 cmp %g2, 0
2009230: 02 80 00 06 be 2009248 <pthread_rwlockattr_setpshared+0x30>
2009234: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
2009238: 18 80 00 04 bgu 2009248 <pthread_rwlockattr_setpshared+0x30><== NEVER TAKEN
200923c: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
2009240: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
2009244: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
2009248: 81 c3 e0 08 retl
0200a228 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
200a228: 9d e3 bf 90 save %sp, -112, %sp
200a22c: ba 10 00 18 mov %i0, %i5
int rc;
/*
* Check all the parameters
*/
if ( !param )
200a230: 80 a6 a0 00 cmp %i2, 0
200a234: 02 80 00 3d be 200a328 <pthread_setschedparam+0x100>
200a238: b0 10 20 16 mov 0x16, %i0
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
200a23c: 90 10 00 19 mov %i1, %o0
200a240: 92 10 00 1a mov %i2, %o1
200a244: 94 07 bf f4 add %fp, -12, %o2
200a248: 40 00 17 80 call 2010048 <_POSIX_Thread_Translate_sched_param>
200a24c: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
200a250: b0 92 20 00 orcc %o0, 0, %i0
200a254: 12 80 00 35 bne 200a328 <pthread_setschedparam+0x100>
200a258: 90 10 00 1d mov %i5, %o0
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
200a25c: 40 00 0c 1d call 200d2d0 <_Thread_Get>
200a260: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a264: c2 07 bf fc ld [ %fp + -4 ], %g1
200a268: 80 a0 60 00 cmp %g1, 0
200a26c: 12 80 00 31 bne 200a330 <pthread_setschedparam+0x108>
200a270: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200a274: fa 02 21 5c ld [ %o0 + 0x15c ], %i5
if ( api->schedpolicy == SCHED_SPORADIC )
200a278: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
200a27c: 80 a0 60 04 cmp %g1, 4
200a280: 32 80 00 05 bne,a 200a294 <pthread_setschedparam+0x6c>
200a284: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200a288: 40 00 10 2b call 200e334 <_Watchdog_Remove>
200a28c: 90 07 60 a8 add %i5, 0xa8, %o0
api->schedpolicy = policy;
200a290: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
api->schedparam = *param;
200a294: 90 07 60 88 add %i5, 0x88, %o0
200a298: 92 10 00 1a mov %i2, %o1
200a29c: 40 00 23 f6 call 2013274 <memcpy>
200a2a0: 94 10 20 1c mov 0x1c, %o2
the_thread->budget_algorithm = budget_algorithm;
200a2a4: c2 07 bf f4 ld [ %fp + -12 ], %g1
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
200a2a8: 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;
200a2ac: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
the_thread->budget_callout = budget_callout;
200a2b0: c2 07 bf f8 ld [ %fp + -8 ], %g1
switch ( api->schedpolicy ) {
200a2b4: 06 80 00 1b bl 200a320 <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a2b8: c2 27 20 7c st %g1, [ %i4 + 0x7c ]
200a2bc: 80 a6 60 02 cmp %i1, 2
200a2c0: 04 80 00 07 ble 200a2dc <pthread_setschedparam+0xb4>
200a2c4: 03 00 80 8c sethi %hi(0x2023000), %g1
200a2c8: 80 a6 60 04 cmp %i1, 4
200a2cc: 12 80 00 15 bne 200a320 <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a2d0: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
200a2d4: 10 80 00 0d b 200a308 <pthread_setschedparam+0xe0>
200a2d8: 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;
200a2dc: c2 00 61 14 ld [ %g1 + 0x114 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a2e0: 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;
200a2e4: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
200a2e8: 03 00 80 88 sethi %hi(0x2022000), %g1
200a2ec: d2 08 63 b4 ldub [ %g1 + 0x3b4 ], %o1 ! 20223b4 <rtems_maximum_priority>
200a2f0: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a2f4: 94 10 20 01 mov 1, %o2
200a2f8: 92 22 40 01 sub %o1, %g1, %o1
200a2fc: 40 00 0a c3 call 200ce08 <_Thread_Change_priority>
200a300: d2 27 20 18 st %o1, [ %i4 + 0x18 ]
the_thread,
the_thread->real_priority,
true
);
break;
200a304: 30 80 00 07 b,a 200a320 <pthread_setschedparam+0xf8>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
_Watchdog_Remove( &api->Sporadic_timer );
200a308: 90 07 60 a8 add %i5, 0xa8, %o0
200a30c: 40 00 10 0a call 200e334 <_Watchdog_Remove>
200a310: c2 27 60 a4 st %g1, [ %i5 + 0xa4 ]
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
200a314: 90 10 20 00 clr %o0
200a318: 7f ff ff 80 call 200a118 <_POSIX_Threads_Sporadic_budget_TSR>
200a31c: 92 10 00 1c mov %i4, %o1
break;
}
_Thread_Enable_dispatch();
200a320: 40 00 0b df call 200d29c <_Thread_Enable_dispatch>
200a324: 01 00 00 00 nop
return 0;
200a328: 81 c7 e0 08 ret
200a32c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
200a330: b0 10 20 03 mov 3, %i0
}
200a334: 81 c7 e0 08 ret
200a338: 81 e8 00 00 restore
02007b1c <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
2007b1c: 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() )
2007b20: 03 00 80 7b sethi %hi(0x201ec00), %g1
2007b24: 82 10 63 a0 or %g1, 0x3a0, %g1 ! 201efa0 <_Per_CPU_Information>
2007b28: c4 00 60 08 ld [ %g1 + 8 ], %g2
2007b2c: 80 a0 a0 00 cmp %g2, 0
2007b30: 12 80 00 19 bne 2007b94 <pthread_testcancel+0x78> <== NEVER TAKEN
2007b34: 01 00 00 00 nop
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007b38: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2007b3c: 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++;
2007b40: 03 00 80 7a sethi %hi(0x201e800), %g1
2007b44: c6 00 62 60 ld [ %g1 + 0x260 ], %g3 ! 201ea60 <_Thread_Dispatch_disable_level>
2007b48: 86 00 e0 01 inc %g3
2007b4c: c6 20 62 60 st %g3, [ %g1 + 0x260 ]
return _Thread_Dispatch_disable_level;
2007b50: c2 00 62 60 ld [ %g1 + 0x260 ], %g1
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
2007b54: c2 00 a0 d8 ld [ %g2 + 0xd8 ], %g1
2007b58: 80 a0 60 00 cmp %g1, 0
2007b5c: 12 80 00 05 bne 2007b70 <pthread_testcancel+0x54> <== NEVER TAKEN
2007b60: ba 10 20 00 clr %i5
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
2007b64: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1
2007b68: 80 a0 00 01 cmp %g0, %g1
2007b6c: ba 40 20 00 addx %g0, 0, %i5
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
2007b70: 40 00 0b ac call 200aa20 <_Thread_Enable_dispatch>
2007b74: 01 00 00 00 nop
if ( cancel )
2007b78: 80 8f 60 ff btst 0xff, %i5
2007b7c: 02 80 00 06 be 2007b94 <pthread_testcancel+0x78>
2007b80: 01 00 00 00 nop
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
2007b84: 03 00 80 7b sethi %hi(0x201ec00), %g1
2007b88: f0 00 63 ac ld [ %g1 + 0x3ac ], %i0 ! 201efac <_Per_CPU_Information+0xc>
2007b8c: 40 00 17 48 call 200d8ac <_POSIX_Thread_Exit>
2007b90: 93 e8 3f ff restore %g0, -1, %o1
2007b94: 81 c7 e0 08 ret
2007b98: 81 e8 00 00 restore
0200c9e4 <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
200c9e4: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
200c9e8: 90 10 20 10 mov 0x10, %o0
200c9ec: 7f ff e1 71 call 2004fb0 <malloc>
200c9f0: ba 10 00 18 mov %i0, %i5
if (rd == NULL) {
200c9f4: b0 92 20 00 orcc %o0, 0, %i0
200c9f8: 02 80 00 0d be 200ca2c <ramdisk_allocate+0x48> <== NEVER TAKEN
200c9fc: 80 a7 60 00 cmp %i5, 0
return NULL;
}
if (area_begin == NULL) {
200ca00: 32 80 00 0e bne,a 200ca38 <ramdisk_allocate+0x54>
200ca04: c0 2e 20 0d clrb [ %i0 + 0xd ]
area_begin = calloc(block_count, block_size);
200ca08: 90 10 00 1a mov %i2, %o0
200ca0c: 7f ff df 21 call 2004690 <calloc>
200ca10: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
200ca14: ba 92 20 00 orcc %o0, 0, %i5
200ca18: 12 80 00 07 bne 200ca34 <ramdisk_allocate+0x50> <== ALWAYS TAKEN
200ca1c: 82 10 20 01 mov 1, %g1
free(rd);
200ca20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200ca24: 7f ff df eb call 20049d0 <free> <== NOT EXECUTED
200ca28: b0 10 20 00 clr %i0 <== NOT EXECUTED
return NULL;
200ca2c: 81 c7 e0 08 ret <== NOT EXECUTED
200ca30: 81 e8 00 00 restore <== NOT EXECUTED
200ca34: c2 2e 20 0d stb %g1, [ %i0 + 0xd ]
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
200ca38: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = block_size;
200ca3c: f2 26 00 00 st %i1, [ %i0 ]
rd->block_num = block_count;
200ca40: f4 26 20 04 st %i2, [ %i0 + 4 ]
rd->area = area_begin;
200ca44: fa 26 20 08 st %i5, [ %i0 + 8 ]
rd->trace = trace;
200ca48: f6 2e 20 0e stb %i3, [ %i0 + 0xe ]
rd->initialized = true;
200ca4c: c2 2e 20 0c stb %g1, [ %i0 + 0xc ]
return rd;
}
200ca50: 81 c7 e0 08 ret
200ca54: 81 e8 00 00 restore
0200ca58 <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
200ca58: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
200ca5c: 80 a6 20 00 cmp %i0, 0
200ca60: 02 80 00 0a be 200ca88 <ramdisk_free+0x30> <== NEVER TAKEN
200ca64: 01 00 00 00 nop
if (rd->malloced) {
200ca68: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
200ca6c: 80 a0 60 00 cmp %g1, 0
200ca70: 02 80 00 04 be 200ca80 <ramdisk_free+0x28>
200ca74: 01 00 00 00 nop
free(rd->area);
200ca78: 7f ff df d6 call 20049d0 <free>
200ca7c: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
200ca80: 7f ff df d4 call 20049d0 <free>
200ca84: 81 e8 00 00 restore
200ca88: 81 c7 e0 08 ret <== NOT EXECUTED
200ca8c: 81 e8 00 00 restore <== NOT EXECUTED
02021044 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
2021044: 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();
2021048: 7f ff 9a 74 call 2007a18 <rtems_disk_io_initialize>
202104c: a4 10 00 18 mov %i0, %l2
if (rc != RTEMS_SUCCESSFUL)
2021050: b0 92 20 00 orcc %o0, 0, %i0
2021054: 12 80 00 43 bne 2021160 <ramdisk_initialize+0x11c> <== NEVER TAKEN
2021058: 23 00 81 ab sethi %hi(0x206ac00), %l1
* 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));
202105c: d0 04 62 58 ld [ %l1 + 0x258 ], %o0 ! 206ae58 <rtems_ramdisk_configuration_size>
2021060: 92 10 20 10 mov 0x10, %o1
2021064: 7f ff 9c e7 call 2008400 <calloc>
2021068: 37 00 81 ab sethi %hi(0x206ac00), %i3
r->trace = false;
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";
202106c: 29 0b d9 19 sethi %hi(0x2f646400), %l4
2021070: 2b 0b dc 99 sethi %hi(0x2f726400), %l5
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
2021074: 33 00 80 84 sethi %hi(0x2021000), %i1
* 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));
2021078: ba 10 00 08 mov %o0, %i5
r->trace = false;
202107c: 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;
2021080: b6 16 e2 5c or %i3, 0x25c, %i3
* 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++)
2021084: b8 10 20 00 clr %i4
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
2021088: a8 15 21 76 or %l4, 0x176, %l4
202108c: aa 15 60 61 or %l5, 0x61, %l5
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);
2021090: a0 07 bf f0 add %fp, -16, %l0
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
2021094: b2 16 61 68 or %i1, 0x168, %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++)
2021098: 10 80 00 2d b 202114c <ramdisk_initialize+0x108>
202109c: b4 10 20 01 mov 1, %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
20210a0: f8 2f bf f8 stb %i4, [ %fp + -8 ]
r->block_size = c->block_size;
20210a4: e6 06 c0 00 ld [ %i3 ], %l3
r->block_num = c->block_num;
20210a8: f0 06 e0 04 ld [ %i3 + 4 ], %i0
if (c->location == NULL)
20210ac: c2 06 e0 08 ld [ %i3 + 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;
20210b0: e6 27 40 00 st %l3, [ %i5 ]
r->block_num = c->block_num;
if (c->location == NULL)
20210b4: 80 a0 60 00 cmp %g1, 0
20210b8: 12 80 00 0d bne 20210ec <ramdisk_initialize+0xa8> <== NEVER TAKEN
20210bc: f0 27 60 04 st %i0, [ %i5 + 4 ]
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
20210c0: 92 10 00 13 mov %l3, %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;
20210c4: f4 2f 60 0d stb %i2, [ %i5 + 0xd ]
r->area = malloc(r->block_size * r->block_num);
20210c8: 7f ff 87 3d call 2002dbc <.umul>
20210cc: 90 10 00 18 mov %i0, %o0
20210d0: 7f ff 9f 2a call 2008d78 <malloc>
20210d4: 01 00 00 00 nop
if (r->area == NULL) /* No enough memory for this disk */
20210d8: 80 a2 20 00 cmp %o0, 0
20210dc: 02 80 00 18 be 202113c <ramdisk_initialize+0xf8> <== NEVER TAKEN
20210e0: d0 27 60 08 st %o0, [ %i5 + 8 ]
r->initialized = false;
continue;
}
else
{
r->initialized = true;
20210e4: 10 80 00 05 b 20210f8 <ramdisk_initialize+0xb4>
20210e8: f4 2f 60 0c stb %i2, [ %i5 + 0xc ]
}
}
else
{
r->malloced = false;
20210ec: c0 2f 60 0d clrb [ %i5 + 0xd ] <== NOT EXECUTED
r->initialized = true;
20210f0: f4 2f 60 0c stb %i2, [ %i5 + 0xc ] <== NOT EXECUTED
r->area = c->location;
20210f4: c2 27 60 08 st %g1, [ %i5 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
20210f8: e0 23 a0 5c st %l0, [ %sp + 0x5c ]
20210fc: 90 10 00 12 mov %l2, %o0
2021100: 92 10 00 1c mov %i4, %o1
2021104: 94 10 00 13 mov %l3, %o2
2021108: 96 10 00 18 mov %i0, %o3
202110c: 98 10 00 19 mov %i1, %o4
2021110: 7f ff 99 06 call 2007528 <rtems_disk_create_phys>
2021114: 9a 10 00 1d mov %i5, %o5
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
2021118: 80 a2 20 00 cmp %o0, 0
202111c: 22 80 00 0a be,a 2021144 <ramdisk_initialize+0x100> <== ALWAYS TAKEN
2021120: b8 07 20 01 inc %i4
{
if (r->malloced)
2021124: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1 <== NOT EXECUTED
2021128: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
202112c: 22 80 00 05 be,a 2021140 <ramdisk_initialize+0xfc> <== NOT EXECUTED
2021130: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
{
free(r->area);
2021134: 7f ff 9d 91 call 2008778 <free> <== NOT EXECUTED
2021138: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
202113c: c0 2f 60 0c clrb [ %i5 + 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++)
2021140: b8 07 20 01 inc %i4 <== NOT EXECUTED
2021144: b6 06 e0 0c add %i3, 0xc, %i3
2021148: ba 07 60 10 add %i5, 0x10, %i5
202114c: c2 04 62 58 ld [ %l1 + 0x258 ], %g1
2021150: 80 a7 00 01 cmp %i4, %g1
2021154: 2a bf ff d3 bcs,a 20210a0 <ramdisk_initialize+0x5c>
2021158: e8 3f bf f0 std %l4, [ %fp + -16 ]
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
202115c: b0 10 20 00 clr %i0
}
2021160: 81 c7 e0 08 ret
2021164: 81 e8 00 00 restore
0200c89c <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c89c: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c8a0: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c8a4: ba 10 00 1a mov %i2, %i5
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c8a8: 84 10 a2 07 or %g2, 0x207, %g2
200c8ac: 80 a6 40 02 cmp %i1, %g2
200c8b0: 02 80 00 3e be 200c9a8 <ramdisk_ioctl+0x10c>
200c8b4: f8 06 20 2c ld [ %i0 + 0x2c ], %i4
200c8b8: 05 30 06 10 sethi %hi(0xc0184000), %g2
200c8bc: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <RAM_END+0xbdd84201>
200c8c0: 80 a6 40 02 cmp %i1, %g2
200c8c4: 12 80 00 40 bne 200c9c4 <ramdisk_ioctl+0x128>
200c8c8: 01 00 00 00 nop
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
200c8cc: c2 06 80 00 ld [ %i2 ], %g1
200c8d0: 80 a0 60 00 cmp %g1, 0
200c8d4: 02 80 00 07 be 200c8f0 <ramdisk_ioctl+0x54>
200c8d8: b6 06 a0 18 add %i2, 0x18, %i3
200c8dc: 80 a0 60 01 cmp %g1, 1
200c8e0: 12 80 00 2c bne 200c990 <ramdisk_ioctl+0xf4> <== NEVER TAKEN
200c8e4: 01 00 00 00 nop
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
200c8e8: 10 80 00 14 b 200c938 <ramdisk_ioctl+0x9c>
200c8ec: 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;
200c8f0: 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++)
200c8f4: 10 80 00 0b b 200c920 <ramdisk_ioctl+0x84>
200c8f8: 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);
200c8fc: d2 07 00 00 ld [ %i4 ], %o1
200c900: 40 00 3e 77 call 201c2dc <.umul>
200c904: f0 06 e0 08 ld [ %i3 + 8 ], %i0
200c908: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c90c: 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++)
200c910: 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);
200c914: 90 10 00 18 mov %i0, %o0
200c918: 40 00 1d 5b call 2013e84 <memcpy>
200c91c: 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++)
200c920: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c924: 80 a6 80 01 cmp %i2, %g1
200c928: 2a bf ff f5 bcs,a 200c8fc <ramdisk_ioctl+0x60>
200c92c: 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);
200c930: 10 80 00 11 b 200c974 <ramdisk_ioctl+0xd8>
200c934: 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++)
200c938: 10 80 00 0a b 200c960 <ramdisk_ioctl+0xc4>
200c93c: 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);
200c940: d2 07 00 00 ld [ %i4 ], %o1
200c944: 40 00 3e 66 call 201c2dc <.umul>
200c948: b4 06 a0 01 inc %i2
200c94c: d2 06 e0 08 ld [ %i3 + 8 ], %o1
200c950: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c954: 90 06 40 08 add %i1, %o0, %o0
200c958: 40 00 1d 4b call 2013e84 <memcpy>
200c95c: 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++)
200c960: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c964: 80 a6 80 01 cmp %i2, %g1
200c968: 2a bf ff f6 bcs,a 200c940 <ramdisk_ioctl+0xa4>
200c96c: 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);
200c970: c2 07 60 04 ld [ %i5 + 4 ], %g1
200c974: 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;
200c978: c0 27 60 0c clr [ %i5 + 0xc ]
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
200c97c: 92 10 20 00 clr %o1
200c980: 9f c0 40 00 call %g1
200c984: 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);
200c988: 81 c7 e0 08 ret
200c98c: 81 e8 00 00 restore
default:
errno = EINVAL;
200c990: 40 00 1a e1 call 2013514 <__errno> <== NOT EXECUTED
200c994: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200c998: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200c99c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
200c9a0: 81 c7 e0 08 ret <== NOT EXECUTED
200c9a4: 81 e8 00 00 restore <== NOT EXECUTED
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
200c9a8: c2 0f 20 0f ldub [ %i4 + 0xf ], %g1
200c9ac: 80 a0 60 00 cmp %g1, 0
200c9b0: 02 80 00 07 be 200c9cc <ramdisk_ioctl+0x130>
200c9b4: 01 00 00 00 nop
ramdisk_free(rd);
200c9b8: 40 00 00 28 call 200ca58 <ramdisk_free>
200c9bc: 90 10 00 1c mov %i4, %o0
200c9c0: 30 80 00 03 b,a 200c9cc <ramdisk_ioctl+0x130>
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
200c9c4: 40 00 09 14 call 200ee14 <rtems_blkdev_ioctl>
200c9c8: 81 e8 00 00 restore
break;
}
errno = EINVAL;
200c9cc: 40 00 1a d2 call 2013514 <__errno>
200c9d0: b0 10 3f ff mov -1, %i0
200c9d4: 82 10 20 16 mov 0x16, %g1
200c9d8: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
200c9dc: 81 c7 e0 08 ret
200c9e0: 81 e8 00 00 restore
0200ca90 <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
200ca90: 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);
200ca94: 90 10 20 00 clr %o0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
200ca98: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
200ca9c: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
200caa0: 13 00 80 7e sethi %hi(0x201f800), %o1
200caa4: 94 07 bf fc add %fp, -4, %o2
200caa8: 92 12 60 18 or %o1, 0x18, %o1
200caac: 7f ff f2 95 call 2009500 <rtems_io_register_driver>
200cab0: b0 10 20 0d mov 0xd, %i0
if (sc != RTEMS_SUCCESSFUL) {
200cab4: 80 a2 20 00 cmp %o0, 0
200cab8: 12 80 00 1b bne 200cb24 <ramdisk_register+0x94> <== NEVER TAKEN
200cabc: 96 10 00 1a mov %i2, %o3
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
200cac0: 92 10 00 1d mov %i5, %o1
200cac4: 7f ff ff c8 call 200c9e4 <ramdisk_allocate>
200cac8: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
200cacc: a0 92 20 00 orcc %o0, 0, %l0
200cad0: 12 80 00 04 bne 200cae0 <ramdisk_register+0x50> <== ALWAYS TAKEN
200cad4: f4 07 bf fc ld [ %fp + -4 ], %i2
rtems_io_unregister_driver(major);
200cad8: 10 80 00 11 b 200cb1c <ramdisk_register+0x8c> <== NOT EXECUTED
200cadc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
200cae0: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
200cae4: 90 10 00 1a mov %i2, %o0
200cae8: 92 10 20 00 clr %o1
200caec: 94 10 00 1d mov %i5, %o2
200caf0: 96 10 00 19 mov %i1, %o3
200caf4: 19 00 80 32 sethi %hi(0x200c800), %o4
200caf8: 9a 10 00 10 mov %l0, %o5
200cafc: 7f ff db 87 call 2003918 <rtems_disk_create_phys>
200cb00: 98 13 20 9c or %o4, 0x9c, %o4
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
200cb04: 80 a2 20 00 cmp %o0, 0
200cb08: 22 80 00 09 be,a 200cb2c <ramdisk_register+0x9c> <== ALWAYS TAKEN
200cb0c: f4 27 00 00 st %i2, [ %i4 ]
ramdisk_free(rd);
200cb10: 7f ff ff d2 call 200ca58 <ramdisk_free> <== NOT EXECUTED
200cb14: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
200cb18: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
200cb1c: 7f ff f2 da call 2009684 <rtems_io_unregister_driver> <== NOT EXECUTED
200cb20: 01 00 00 00 nop <== NOT EXECUTED
return RTEMS_UNSATISFIED;
200cb24: 81 c7 e0 08 ret <== NOT EXECUTED
200cb28: 81 e8 00 00 restore <== NOT EXECUTED
}
*dev_ptr = dev;
200cb2c: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
200cb30: b0 10 20 00 clr %i0
}
200cb34: 81 c7 e0 08 ret
200cb38: 81 e8 00 00 restore
0201a24c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
201a24c: 9d e3 bf a0 save %sp, -96, %sp
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a250: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a254: c2 00 63 5c ld [ %g1 + 0x35c ], %g1 ! 201cf5c <rtems_libio_number_iops>
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
201a258: 92 10 00 19 mov %i1, %o1
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a25c: 80 a6 00 01 cmp %i0, %g1
201a260: 1a 80 00 18 bcc 201a2c0 <read+0x74>
201a264: 94 10 00 1a mov %i2, %o2
iop = rtems_libio_iop( fd );
201a268: bb 2e 20 03 sll %i0, 3, %i5
201a26c: 03 00 80 76 sethi %hi(0x201d800), %g1
201a270: b1 2e 20 06 sll %i0, 6, %i0
201a274: b0 07 40 18 add %i5, %i0, %i0
201a278: fa 00 62 98 ld [ %g1 + 0x298 ], %i5
201a27c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open( iop );
201a280: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
201a284: 80 88 61 00 btst 0x100, %g1
201a288: 02 80 00 0e be 201a2c0 <read+0x74>
201a28c: 01 00 00 00 nop
rtems_libio_check_buffer( buffer );
201a290: 80 a6 60 00 cmp %i1, 0
201a294: 12 80 00 06 bne 201a2ac <read+0x60> <== ALWAYS TAKEN
201a298: 80 a6 a0 00 cmp %i2, 0
201a29c: 7f ff d5 76 call 200f874 <__errno> <== NOT EXECUTED
201a2a0: 01 00 00 00 nop <== NOT EXECUTED
201a2a4: 10 80 00 0a b 201a2cc <read+0x80> <== NOT EXECUTED
201a2a8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
201a2ac: 02 80 00 15 be 201a300 <read+0xb4>
201a2b0: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
201a2b4: 80 88 60 02 btst 2, %g1
201a2b8: 32 80 00 08 bne,a 201a2d8 <read+0x8c>
201a2bc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
201a2c0: 7f ff d5 6d call 200f874 <__errno>
201a2c4: 01 00 00 00 nop
201a2c8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a2cc: c2 22 00 00 st %g1, [ %o0 ]
201a2d0: 81 c7 e0 08 ret
201a2d4: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
201a2d8: c2 00 60 08 ld [ %g1 + 8 ], %g1
201a2dc: 9f c0 40 00 call %g1
201a2e0: 90 10 00 1d mov %i5, %o0
if ( rc > 0 )
201a2e4: b0 92 20 00 orcc %o0, 0, %i0
201a2e8: 04 80 00 06 ble 201a300 <read+0xb4>
201a2ec: 85 3e 20 1f sra %i0, 0x1f, %g2
iop->offset += rc;
201a2f0: d8 1f 60 10 ldd [ %i5 + 0x10 ], %o4
201a2f4: 86 83 40 18 addcc %o5, %i0, %g3
201a2f8: 84 43 00 02 addx %o4, %g2, %g2
201a2fc: c4 3f 60 10 std %g2, [ %i5 + 0x10 ]
return rc;
}
201a300: 81 c7 e0 08 ret
201a304: 81 e8 00 00 restore
02004b70 <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)
{
2004b70: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
2004b74: c0 27 bf f8 clr [ %fp + -8 ]
* 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)
{
2004b78: ba 10 00 18 mov %i0, %i5
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))
2004b7c: 80 a6 a0 00 cmp %i2, 0
2004b80: 02 80 00 1e be 2004bf8 <read_extended_partition+0x88> <== NEVER TAKEN
2004b84: b0 10 20 19 mov 0x19, %i0
2004b88: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2004b8c: 80 a0 60 00 cmp %g1, 0
2004b90: 02 80 00 1a be 2004bf8 <read_extended_partition+0x88> <== NEVER TAKEN
2004b94: 90 10 00 1d mov %i5, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
2004b98: e0 06 a0 04 ld [ %i2 + 4 ], %l0
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
2004b9c: 92 10 00 10 mov %l0, %o1
2004ba0: 7f ff ff 97 call 20049fc <get_sector>
2004ba4: 94 07 bf f8 add %fp, -8, %o2
if (rc != RTEMS_SUCCESSFUL)
2004ba8: b0 92 20 00 orcc %o0, 0, %i0
2004bac: 02 80 00 06 be 2004bc4 <read_extended_partition+0x54> <== ALWAYS TAKEN
2004bb0: d0 07 bf f8 ld [ %fp + -8 ], %o0
{
if (sector)
2004bb4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004bb8: 12 80 00 1b bne 2004c24 <read_extended_partition+0xb4> <== NOT EXECUTED
2004bbc: 01 00 00 00 nop <== NOT EXECUTED
2004bc0: 30 80 00 49 b,a 2004ce4 <read_extended_partition+0x174> <== 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) &&
2004bc4: c4 0a 22 02 ldub [ %o0 + 0x202 ], %g2
2004bc8: 80 a0 a0 55 cmp %g2, 0x55
2004bcc: 12 80 00 06 bne 2004be4 <read_extended_partition+0x74> <== NEVER TAKEN
2004bd0: 82 10 20 00 clr %g1
* 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)
2004bd4: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
2004bd8: 82 18 60 aa xor %g1, 0xaa, %g1
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) &&
2004bdc: 80 a0 00 01 cmp %g0, %g1
2004be0: 82 60 3f ff subx %g0, -1, %g1
if (sector)
free(sector);
return rc;
}
if (!msdos_signature_check(sector))
2004be4: 80 a0 60 00 cmp %g1, 0
2004be8: 12 80 00 06 bne 2004c00 <read_extended_partition+0x90> <== ALWAYS TAKEN
2004bec: b6 02 21 d2 add %o0, 0x1d2, %i3
{
free(sector);
2004bf0: 40 00 03 9c call 2005a60 <free> <== NOT EXECUTED
2004bf4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
2004bf8: 81 c7 e0 08 ret <== NOT EXECUTED
2004bfc: 81 e8 00 00 restore <== NOT EXECUTED
2004c00: 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)
2004c04: a2 06 a0 10 add %i2, 0x10, %l1
2004c08: 90 06 ff f0 add %i3, -16, %o0
2004c0c: 7f ff ff a2 call 2004a94 <data_to_part_desc.part.1>
2004c10: 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)
2004c14: b0 92 20 00 orcc %o0, 0, %i0
2004c18: 02 80 00 07 be 2004c34 <read_extended_partition+0xc4> <== ALWAYS TAKEN
2004c1c: d4 07 bf fc ld [ %fp + -4 ], %o2
{
free(sector);
2004c20: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
2004c24: 40 00 03 8f call 2005a60 <free> <== NOT EXECUTED
2004c28: 01 00 00 00 nop <== NOT EXECUTED
return rc;
2004c2c: 81 c7 e0 08 ret <== NOT EXECUTED
2004c30: 81 e8 00 00 restore <== NOT EXECUTED
}
if (new_part_desc == NULL)
2004c34: 80 a2 a0 00 cmp %o2, 0
2004c38: 22 80 00 26 be,a 2004cd0 <read_extended_partition+0x160>
2004c3c: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
2004c40: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004c44: c4 0a a0 01 ldub [ %o2 + 1 ], %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;
2004c48: 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));
2004c4c: 86 18 a0 85 xor %g2, 0x85, %g3
2004c50: 84 18 a0 05 xor %g2, 5, %g2
2004c54: 80 a0 00 03 cmp %g0, %g3
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
2004c58: f4 22 a0 14 st %i2, [ %o2 + 0x14 ]
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004c5c: 86 60 3f ff subx %g0, -1, %g3
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;
2004c60: c2 22 a0 10 st %g1, [ %o2 + 0x10 ]
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004c64: 80 a0 00 02 cmp %g0, %g2
2004c68: 84 60 3f ff subx %g0, -1, %g2
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
2004c6c: 80 90 c0 02 orcc %g3, %g2, %g0
2004c70: 02 80 00 0a be 2004c98 <read_extended_partition+0x128>
2004c74: c4 02 a0 04 ld [ %o2 + 4 ], %g2
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
2004c78: 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;
2004c7c: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
2004c80: c4 22 a0 04 st %g2, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
2004c84: 90 10 00 1d mov %i5, %o0
2004c88: 7f ff ff ba call 2004b70 <read_extended_partition>
2004c8c: 92 10 00 19 mov %i1, %o1
{
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;
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004c90: 10 80 00 10 b 2004cd0 <read_extended_partition+0x160>
2004c94: b8 07 20 04 add %i4, 4, %i4
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;
2004c98: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
2004c9c: 88 00 e0 0a add %g3, 0xa, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
2004ca0: 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;
2004ca4: 89 29 20 02 sll %g4, 2, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
2004ca8: 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;
2004cac: d4 20 40 04 st %o2, [ %g1 + %g4 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
2004cb0: 82 04 00 02 add %l0, %g2, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004cb4: 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;
2004cb8: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004cbc: 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;
2004cc0: 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;
2004cc4: 82 00 80 01 add %g2, %g1, %g1
2004cc8: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
2004ccc: 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++)
2004cd0: 80 a7 00 11 cmp %i4, %l1
2004cd4: 12 bf ff cd bne 2004c08 <read_extended_partition+0x98>
2004cd8: b6 06 e0 10 add %i3, 0x10, %i3
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004cdc: 40 00 03 61 call 2005a60 <free>
2004ce0: d0 07 bf f8 ld [ %fp + -8 ], %o0
return RTEMS_SUCCESSFUL;
}
2004ce4: 81 c7 e0 08 ret
2004ce8: 81 e8 00 00 restore
02005494 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
2005494: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
2005498: 03 00 80 76 sethi %hi(0x201d800), %g1
200549c: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 201daac <rtems_libio_number_iops>
20054a0: 80 a6 00 01 cmp %i0, %g1
20054a4: 1a 80 00 0f bcc 20054e0 <readv+0x4c>
20054a8: 01 00 00 00 nop
iop = rtems_libio_iop( fd );
20054ac: b9 2e 20 03 sll %i0, 3, %i4
20054b0: 03 00 80 79 sethi %hi(0x201e400), %g1
20054b4: b1 2e 20 06 sll %i0, 6, %i0
20054b8: b0 07 00 18 add %i4, %i0, %i0
20054bc: f8 00 61 e8 ld [ %g1 + 0x1e8 ], %i4
20054c0: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
20054c4: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
20054c8: 80 88 61 00 btst 0x100, %g1
20054cc: 02 80 00 05 be 20054e0 <readv+0x4c>
20054d0: 01 00 00 00 nop
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
20054d4: 80 88 60 02 btst 2, %g1
20054d8: 12 80 00 06 bne 20054f0 <readv+0x5c> <== ALWAYS TAKEN
20054dc: 80 a6 60 00 cmp %i1, 0
20054e0: 40 00 2c b1 call 20107a4 <__errno>
20054e4: 01 00 00 00 nop
20054e8: 10 80 00 1c b 2005558 <readv+0xc4>
20054ec: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
20054f0: 02 80 00 17 be 200554c <readv+0xb8>
20054f4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
20054f8: 80 a6 a0 00 cmp %i2, 0
20054fc: 04 80 00 14 ble 200554c <readv+0xb8>
2005500: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
2005504: 80 a6 a4 00 cmp %i2, 0x400
2005508: 14 80 00 11 bg 200554c <readv+0xb8> <== NEVER TAKEN
200550c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
2005510: 84 10 00 19 mov %i1, %g2
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
2005514: 86 10 20 01 mov 1, %g3
2005518: 82 10 20 00 clr %g1
200551c: 10 80 00 03 b 2005528 <readv+0x94>
2005520: 88 10 20 00 clr %g4
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
2005524: 88 10 00 1b mov %i3, %g4
/*
* 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 )
2005528: fa 00 80 00 ld [ %g2 ], %i5
200552c: 80 a7 60 00 cmp %i5, 0
2005530: 02 80 00 07 be 200554c <readv+0xb8>
2005534: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
2005538: fa 00 a0 04 ld [ %g2 + 4 ], %i5
200553c: b6 07 40 04 add %i5, %g4, %i3
if ( total < old )
2005540: 80 a6 c0 04 cmp %i3, %g4
2005544: 16 80 00 08 bge 2005564 <readv+0xd0>
2005548: 80 a0 00 1d cmp %g0, %i5
rtems_set_errno_and_return_minus_one( EINVAL );
200554c: 40 00 2c 96 call 20107a4 <__errno>
2005550: 01 00 00 00 nop
2005554: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2005558: c2 22 00 00 st %g1, [ %o0 ]
200555c: 81 c7 e0 08 ret
2005560: 91 e8 3f ff restore %g0, -1, %o0
* 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++ ) {
2005564: 82 00 60 01 inc %g1
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
2005568: 88 40 3f ff addx %g0, -1, %g4
* 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++ ) {
200556c: 84 00 a0 08 add %g2, 8, %g2
2005570: 80 a0 40 1a cmp %g1, %i2
2005574: 12 bf ff ec bne 2005524 <readv+0x90>
2005578: 86 08 c0 04 and %g3, %g4, %g3
/*
* 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 ) {
200557c: 80 88 e0 ff btst 0xff, %g3
2005580: 12 80 00 1c bne 20055f0 <readv+0x15c>
2005584: b0 10 20 00 clr %i0
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
2005588: b5 28 60 03 sll %g1, 3, %i2
200558c: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
2005590: c2 07 20 2c ld [ %i4 + 0x2c ], %g1
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
2005594: 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)(
2005598: c2 00 60 08 ld [ %g1 + 8 ], %g1
200559c: d2 06 40 1d ld [ %i1 + %i5 ], %o1
20055a0: d4 06 e0 04 ld [ %i3 + 4 ], %o2
20055a4: 9f c0 40 00 call %g1
20055a8: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
20055ac: 80 a2 20 00 cmp %o0, 0
20055b0: 26 80 00 10 bl,a 20055f0 <readv+0x15c> <== NEVER TAKEN
20055b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
20055b8: 02 80 00 07 be 20055d4 <readv+0x140> <== NEVER TAKEN
20055bc: a1 3a 20 1f sra %o0, 0x1f, %l0
iop->offset += bytes;
20055c0: c4 1f 20 10 ldd [ %i4 + 0x10 ], %g2
20055c4: 86 80 c0 08 addcc %g3, %o0, %g3
total += bytes;
20055c8: b0 06 00 08 add %i0, %o0, %i0
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
20055cc: 84 40 80 10 addx %g2, %l0, %g2
20055d0: c4 3f 20 10 std %g2, [ %i4 + 0x10 ]
total += bytes;
}
if (bytes != iov[ v ].iov_len)
20055d4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
20055d8: 80 a2 00 01 cmp %o0, %g1
20055dc: 12 80 00 05 bne 20055f0 <readv+0x15c> <== NEVER TAKEN
20055e0: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
20055e4: 80 a7 40 1a cmp %i5, %i2
20055e8: 32 bf ff eb bne,a 2005594 <readv+0x100>
20055ec: c2 07 20 2c ld [ %i4 + 0x2c ], %g1
20055f0: 81 c7 e0 08 ret
20055f4: 81 e8 00 00 restore
020045d0 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
20045d0: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
20045d4: 03 00 80 76 sethi %hi(0x201d800), %g1
20045d8: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 201dab0 <rtems_malloc_statistics>
20045dc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
20045e0: 84 00 a0 01 inc %g2
20045e4: 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())) {
20045e8: 03 00 80 77 sethi %hi(0x201dc00), %g1
20045ec: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 ! 201dd68 <_System_state_Current>
20045f0: 80 a0 60 03 cmp %g1, 3
20045f4: 12 80 00 0d bne 2004628 <realloc+0x58>
20045f8: 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 )
20045fc: 03 00 80 77 sethi %hi(0x201dc00), %g1
2004600: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 201dc10 <_Thread_Dispatch_disable_level>
2004604: 80 a0 60 00 cmp %g1, 0
2004608: 32 80 00 3a bne,a 20046f0 <realloc+0x120> <== NEVER TAKEN
200460c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
2004610: 03 00 80 78 sethi %hi(0x201e000), %g1
2004614: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 201e158 <_Per_CPU_Information+0x8>
2004618: 80 a0 60 00 cmp %g1, 0
200461c: 32 80 00 35 bne,a 20046f0 <realloc+0x120> <== NEVER TAKEN
2004620: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
/*
* Continue with realloc().
*/
if ( !ptr )
2004624: 80 a6 20 00 cmp %i0, 0
2004628: 12 80 00 04 bne 2004638 <realloc+0x68>
200462c: 80 a6 60 00 cmp %i1, 0
return malloc( size );
2004630: 7f ff fd 20 call 2003ab0 <malloc>
2004634: 91 e8 00 19 restore %g0, %i1, %o0
if ( !size ) {
2004638: 32 80 00 06 bne,a 2004650 <realloc+0x80> <== ALWAYS TAKEN
200463c: 3b 00 80 73 sethi %hi(0x201cc00), %i5
free( ptr );
2004640: 7f ff fc 34 call 2003710 <free> <== NOT EXECUTED
2004644: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
return (void *) 0;
2004648: 81 c7 e0 08 ret <== NOT EXECUTED
200464c: 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) ) {
2004650: d0 07 63 18 ld [ %i5 + 0x318 ], %o0
2004654: 92 10 00 18 mov %i0, %o1
2004658: 40 00 13 c5 call 200956c <_Protected_heap_Get_block_size>
200465c: 94 07 bf fc add %fp, -4, %o2
2004660: 80 8a 20 ff btst 0xff, %o0
2004664: 32 80 00 08 bne,a 2004684 <realloc+0xb4>
2004668: d0 07 63 18 ld [ %i5 + 0x318 ], %o0
errno = EINVAL;
200466c: 40 00 2c 82 call 200f874 <__errno>
2004670: b0 10 20 00 clr %i0
2004674: 82 10 20 16 mov 0x16, %g1
2004678: c2 22 00 00 st %g1, [ %o0 ]
200467c: 81 c7 e0 08 ret
2004680: 81 e8 00 00 restore
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
2004684: 92 10 00 18 mov %i0, %o1
2004688: 40 00 13 c9 call 20095ac <_Protected_heap_Resize_block>
200468c: 94 10 00 19 mov %i1, %o2
2004690: 80 8a 20 ff btst 0xff, %o0
2004694: 12 80 00 1a bne 20046fc <realloc+0x12c>
2004698: 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 );
200469c: 7f ff fd 05 call 2003ab0 <malloc>
20046a0: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
20046a4: 03 00 80 76 sethi %hi(0x201d800), %g1
20046a8: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 201dab0 <rtems_malloc_statistics>
20046ac: 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 );
20046b0: ba 10 00 08 mov %o0, %i5
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
20046b4: 84 00 bf ff add %g2, -1, %g2
if ( !new_area ) {
20046b8: 80 a2 20 00 cmp %o0, 0
20046bc: 02 80 00 0f be 20046f8 <realloc+0x128>
20046c0: c4 20 60 04 st %g2, [ %g1 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
20046c4: c2 07 bf fc ld [ %fp + -4 ], %g1
20046c8: 80 a6 40 01 cmp %i1, %g1
20046cc: 08 80 00 03 bleu 20046d8 <realloc+0x108> <== NEVER TAKEN
20046d0: 94 10 00 19 mov %i1, %o2
20046d4: 94 10 00 01 mov %g1, %o2
20046d8: 92 10 00 18 mov %i0, %o1
20046dc: 40 00 2e c2 call 20101e4 <memcpy>
20046e0: 90 10 00 1d mov %i5, %o0
free( ptr );
20046e4: 90 10 00 18 mov %i0, %o0
20046e8: 7f ff fc 0a call 2003710 <free>
20046ec: b0 10 00 1d mov %i5, %i0
return new_area;
20046f0: 81 c7 e0 08 ret
20046f4: 81 e8 00 00 restore
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
20046f8: b0 10 20 00 clr %i0
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
20046fc: 81 c7 e0 08 ret
2004700: 81 e8 00 00 restore
020080f8 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
20080f8: 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);
20080fc: 3b 00 80 80 sethi %hi(0x2020000), %i5
2008100: 40 00 02 86 call 2008b18 <pthread_mutex_lock>
2008104: 90 17 60 24 or %i5, 0x24, %o0 ! 2020024 <aio_request_queue>
if (result != 0) {
2008108: b8 92 20 00 orcc %o0, 0, %i4
200810c: 02 80 00 06 be 2008124 <rtems_aio_enqueue+0x2c> <== ALWAYS TAKEN
2008110: 01 00 00 00 nop
free (req);
2008114: 7f ff ee e5 call 2003ca8 <free> <== NOT EXECUTED
2008118: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return result;
200811c: 81 c7 e0 08 ret <== NOT EXECUTED
2008120: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
2008124: 40 00 04 8c call 2009354 <pthread_self>
2008128: ba 17 60 24 or %i5, 0x24, %i5
200812c: 92 07 bf fc add %fp, -4, %o1
2008130: 40 00 03 9a call 2008f98 <pthread_getschedparam>
2008134: 94 07 bf dc add %fp, -36, %o2
req->caller_thread = pthread_self ();
2008138: 40 00 04 87 call 2009354 <pthread_self>
200813c: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2008140: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2008144: c6 07 bf dc ld [ %fp + -36 ], %g3
2008148: 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 ();
200814c: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2008150: 84 20 c0 02 sub %g3, %g2, %g2
2008154: c4 26 20 0c st %g2, [ %i0 + 0xc ]
req->policy = policy;
2008158: c4 07 bf fc ld [ %fp + -4 ], %g2
200815c: c4 26 20 08 st %g2, [ %i0 + 8 ]
req->aiocbp->error_code = EINPROGRESS;
2008160: 84 10 20 77 mov 0x77, %g2
2008164: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
2008168: c4 07 60 68 ld [ %i5 + 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;
200816c: c0 20 60 38 clr [ %g1 + 0x38 ]
if ((aio_request_queue.idle_threads == 0) &&
2008170: 80 a0 a0 00 cmp %g2, 0
2008174: 12 80 00 33 bne 2008240 <rtems_aio_enqueue+0x148> <== NEVER TAKEN
2008178: d2 00 40 00 ld [ %g1 ], %o1
200817c: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
2008180: 80 a0 60 04 cmp %g1, 4
2008184: 14 80 00 30 bg 2008244 <rtems_aio_enqueue+0x14c>
2008188: 11 00 80 80 sethi %hi(0x2020000), %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);
200818c: 90 07 60 48 add %i5, 0x48, %o0
2008190: 7f ff ff 7e call 2007f88 <rtems_aio_search_fd>
2008194: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2008198: 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);
200819c: b6 10 00 08 mov %o0, %i3
if (r_chain->new_fd == 1) {
20081a0: 80 a0 60 01 cmp %g1, 1
20081a4: 12 80 00 1d bne 2008218 <rtems_aio_enqueue+0x120>
20081a8: 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);
20081ac: 90 10 00 1a mov %i2, %o0
20081b0: 40 00 08 fa call 200a598 <_Chain_Insert>
20081b4: 92 10 00 18 mov %i0, %o1
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
20081b8: 90 06 e0 1c add %i3, 0x1c, %o0
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;
20081bc: c0 26 e0 18 clr [ %i3 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
20081c0: 40 00 02 00 call 20089c0 <pthread_mutex_init>
20081c4: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
20081c8: 90 06 e0 20 add %i3, 0x20, %o0
20081cc: 40 00 01 09 call 20085f0 <pthread_cond_init>
20081d0: 92 10 20 00 clr %o1
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
20081d4: 96 10 00 1b mov %i3, %o3
20081d8: 90 07 bf f8 add %fp, -8, %o0
20081dc: 92 07 60 08 add %i5, 8, %o1
20081e0: 15 00 80 1e sethi %hi(0x2007800), %o2
20081e4: 40 00 02 dd call 2008d58 <pthread_create>
20081e8: 94 12 a3 d8 or %o2, 0x3d8, %o2 ! 2007bd8 <rtems_aio_handle>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
20081ec: b6 92 20 00 orcc %o0, 0, %i3
20081f0: 22 80 00 07 be,a 200820c <rtems_aio_enqueue+0x114> <== ALWAYS TAKEN
20081f4: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
20081f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20081fc: 40 00 02 67 call 2008b98 <pthread_mutex_unlock> <== NOT EXECUTED
2008200: b8 10 00 1b mov %i3, %i4 <== NOT EXECUTED
return result;
2008204: 81 c7 e0 08 ret <== NOT EXECUTED
2008208: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
}
++aio_request_queue.active_threads;
200820c: 82 00 60 01 inc %g1
2008210: 10 80 00 40 b 2008310 <rtems_aio_enqueue+0x218>
2008214: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
2008218: ba 02 20 1c add %o0, 0x1c, %i5
200821c: 40 00 02 3f call 2008b18 <pthread_mutex_lock>
2008220: 90 10 00 1d mov %i5, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
2008224: 90 10 00 1a mov %i2, %o0
2008228: 7f ff ff 0a call 2007e50 <rtems_aio_insert_prio>
200822c: 92 10 00 18 mov %i0, %o1
pthread_cond_signal (&r_chain->cond);
2008230: 40 00 01 1f call 20086ac <pthread_cond_signal>
2008234: 90 06 e0 20 add %i3, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
2008238: 10 80 00 11 b 200827c <rtems_aio_enqueue+0x184>
200823c: 90 10 00 1d mov %i5, %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,
2008240: 11 00 80 80 sethi %hi(0x2020000), %o0 <== NOT EXECUTED
2008244: 94 10 20 00 clr %o2
2008248: 7f ff ff 50 call 2007f88 <rtems_aio_search_fd>
200824c: 90 12 20 6c or %o0, 0x6c, %o0
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
2008250: ba 92 20 00 orcc %o0, 0, %i5
2008254: 02 80 00 0e be 200828c <rtems_aio_enqueue+0x194>
2008258: b6 07 60 1c add %i5, 0x1c, %i3
{
pthread_mutex_lock (&r_chain->mutex);
200825c: 40 00 02 2f call 2008b18 <pthread_mutex_lock>
2008260: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
2008264: 90 07 60 08 add %i5, 8, %o0
2008268: 7f ff fe fa call 2007e50 <rtems_aio_insert_prio>
200826c: 92 10 00 18 mov %i0, %o1
pthread_cond_signal (&r_chain->cond);
2008270: 40 00 01 0f call 20086ac <pthread_cond_signal>
2008274: 90 07 60 20 add %i5, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
2008278: 90 10 00 1b mov %i3, %o0
200827c: 40 00 02 47 call 2008b98 <pthread_mutex_unlock>
2008280: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
2008284: 10 80 00 24 b 2008314 <rtems_aio_enqueue+0x21c>
2008288: 11 00 80 80 sethi %hi(0x2020000), %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);
200828c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2008290: 11 00 80 80 sethi %hi(0x2020000), %o0
2008294: d2 00 40 00 ld [ %g1 ], %o1
2008298: 90 12 20 78 or %o0, 0x78, %o0
200829c: 7f ff ff 3b call 2007f88 <rtems_aio_search_fd>
20082a0: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
20082a4: 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);
20082a8: ba 10 00 08 mov %o0, %i5
20082ac: 92 10 00 18 mov %i0, %o1
if (r_chain->new_fd == 1) {
20082b0: 80 a0 60 01 cmp %g1, 1
20082b4: 12 80 00 0d bne 20082e8 <rtems_aio_enqueue+0x1f0>
20082b8: 90 02 20 08 add %o0, 8, %o0
20082bc: 40 00 08 b7 call 200a598 <_Chain_Insert>
20082c0: 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);
20082c4: 90 07 60 1c add %i5, 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;
20082c8: c0 27 60 18 clr [ %i5 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
20082cc: 40 00 01 bd call 20089c0 <pthread_mutex_init>
20082d0: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
20082d4: 90 07 60 20 add %i5, 0x20, %o0
20082d8: 40 00 00 c6 call 20085f0 <pthread_cond_init>
20082dc: 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)
20082e0: 10 80 00 05 b 20082f4 <rtems_aio_enqueue+0x1fc>
20082e4: 11 00 80 80 sethi %hi(0x2020000), %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);
20082e8: 7f ff fe da call 2007e50 <rtems_aio_insert_prio>
20082ec: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
20082f0: 11 00 80 80 sethi %hi(0x2020000), %o0
20082f4: 90 12 20 24 or %o0, 0x24, %o0 ! 2020024 <aio_request_queue>
20082f8: c2 02 20 68 ld [ %o0 + 0x68 ], %g1
20082fc: 80 a0 60 00 cmp %g1, 0
2008300: 24 80 00 05 ble,a 2008314 <rtems_aio_enqueue+0x21c> <== ALWAYS TAKEN
2008304: 11 00 80 80 sethi %hi(0x2020000), %o0
pthread_cond_signal (&aio_request_queue.new_req);
2008308: 40 00 00 e9 call 20086ac <pthread_cond_signal> <== NOT EXECUTED
200830c: 90 02 20 04 add %o0, 4, %o0 ! 2020004 <rtems_malloc_statistics+0x1c><== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
2008310: 11 00 80 80 sethi %hi(0x2020000), %o0
2008314: 40 00 02 21 call 2008b98 <pthread_mutex_unlock>
2008318: 90 12 20 24 or %o0, 0x24, %o0 ! 2020024 <aio_request_queue>
return 0;
}
200831c: b0 10 00 1c mov %i4, %i0
2008320: 81 c7 e0 08 ret
2008324: 81 e8 00 00 restore
02007bd8 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
2007bd8: 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);
2007bdc: 3b 00 80 80 sethi %hi(0x2020000), %i5
2007be0: ba 17 60 24 or %i5, 0x24, %i5 ! 2020024 <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)) {
2007be4: b2 07 60 58 add %i5, 0x58, %i1
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 &&
2007be8: b4 07 60 4c add %i5, 0x4c, %i2
--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,
2007bec: b6 07 60 04 add %i5, 4, %i3
/* 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);
2007bf0: a0 06 20 1c add %i0, 0x1c, %l0
2007bf4: 40 00 03 c9 call 2008b18 <pthread_mutex_lock>
2007bf8: 90 10 00 10 mov %l0, %o0
if (result != 0)
2007bfc: 80 a2 20 00 cmp %o0, 0
2007c00: 12 80 00 91 bne 2007e44 <rtems_aio_handle+0x26c> <== NEVER TAKEN
2007c04: 82 06 20 0c add %i0, 0xc, %g1
2007c08: 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)) {
2007c0c: 80 a7 00 01 cmp %i4, %g1
2007c10: 02 80 00 3b be 2007cfc <rtems_aio_handle+0x124>
2007c14: 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);
2007c18: 40 00 05 cf call 2009354 <pthread_self>
2007c1c: 01 00 00 00 nop
2007c20: 92 07 bf fc add %fp, -4, %o1
2007c24: 40 00 04 dd call 2008f98 <pthread_getschedparam>
2007c28: 94 07 bf d8 add %fp, -40, %o2
param.sched_priority = req->priority;
2007c2c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
2007c30: 40 00 05 c9 call 2009354 <pthread_self>
2007c34: c2 27 bf d8 st %g1, [ %fp + -40 ]
2007c38: d2 07 20 08 ld [ %i4 + 8 ], %o1
2007c3c: 40 00 05 ca call 2009364 <pthread_setschedparam>
2007c40: 94 07 bf d8 add %fp, -40, %o2
2007c44: 40 00 0a 3d call 200a538 <_Chain_Extract>
2007c48: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
2007c4c: 40 00 03 d3 call 2008b98 <pthread_mutex_unlock>
2007c50: 90 10 00 10 mov %l0, %o0
switch (req->aiocbp->aio_lio_opcode) {
2007c54: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2007c58: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
2007c5c: 80 a0 a0 02 cmp %g2, 2
2007c60: 22 80 00 10 be,a 2007ca0 <rtems_aio_handle+0xc8>
2007c64: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007c68: 80 a0 a0 03 cmp %g2, 3
2007c6c: 02 80 00 15 be 2007cc0 <rtems_aio_handle+0xe8> <== NEVER TAKEN
2007c70: 80 a0 a0 01 cmp %g2, 1
2007c74: 32 80 00 19 bne,a 2007cd8 <rtems_aio_handle+0x100> <== NEVER TAKEN
2007c78: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
2007c7c: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007c80: d0 00 40 00 ld [ %g1 ], %o0
2007c84: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007c88: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007c8c: 96 10 00 02 mov %g2, %o3
2007c90: 40 00 2a d3 call 20127dc <pread>
2007c94: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007c98: 10 80 00 0d b 2007ccc <rtems_aio_handle+0xf4>
2007c9c: 80 a2 3f ff cmp %o0, -1
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
2007ca0: d0 00 40 00 ld [ %g1 ], %o0
2007ca4: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007ca8: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007cac: 96 10 00 02 mov %g2, %o3
2007cb0: 40 00 2b 09 call 20128d4 <pwrite>
2007cb4: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007cb8: 10 80 00 05 b 2007ccc <rtems_aio_handle+0xf4>
2007cbc: 80 a2 3f ff cmp %o0, -1
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
2007cc0: 40 00 1a 78 call 200e6a0 <fsync> <== NOT EXECUTED
2007cc4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
2007cc8: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2007ccc: 32 80 00 09 bne,a 2007cf0 <rtems_aio_handle+0x118> <== ALWAYS TAKEN
2007cd0: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
req->aiocbp->return_value = -1;
2007cd4: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
2007cd8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
2007cdc: 40 00 27 b1 call 2011ba0 <__errno> <== NOT EXECUTED
2007ce0: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
2007ce4: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2007ce8: 10 bf ff c2 b 2007bf0 <rtems_aio_handle+0x18> <== NOT EXECUTED
2007cec: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
2007cf0: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
2007cf4: 10 bf ff bf b 2007bf0 <rtems_aio_handle+0x18>
2007cf8: 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);
2007cfc: 40 00 03 a7 call 2008b98 <pthread_mutex_unlock>
2007d00: 90 10 00 10 mov %l0, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
2007d04: 40 00 03 85 call 2008b18 <pthread_mutex_lock>
2007d08: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_empty (chain))
2007d0c: c2 06 20 08 ld [ %i0 + 8 ], %g1
2007d10: 80 a0 40 1c cmp %g1, %i4
2007d14: 12 80 00 48 bne 2007e34 <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007d18: 92 07 bf f4 add %fp, -12, %o1
{
clock_gettime (CLOCK_REALTIME, &timeout);
2007d1c: 40 00 01 ce call 2008454 <clock_gettime>
2007d20: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
2007d24: c2 07 bf f4 ld [ %fp + -12 ], %g1
timeout.tv_nsec = 0;
2007d28: c0 27 bf f8 clr [ %fp + -8 ]
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007d2c: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007d30: 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;
2007d34: c2 27 bf f4 st %g1, [ %fp + -12 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007d38: 90 10 00 1c mov %i4, %o0
2007d3c: 92 10 00 1d mov %i5, %o1
2007d40: 40 00 02 78 call 2008720 <pthread_cond_timedwait>
2007d44: 94 07 bf f4 add %fp, -12, %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) {
2007d48: 80 a2 20 74 cmp %o0, 0x74
2007d4c: 12 80 00 3a bne 2007e34 <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007d50: 01 00 00 00 nop
2007d54: 40 00 09 f9 call 200a538 <_Chain_Extract>
2007d58: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
2007d5c: 40 00 02 ca call 2008884 <pthread_mutex_destroy>
2007d60: 90 10 00 10 mov %l0, %o0
pthread_cond_destroy (&r_chain->cond);
2007d64: 40 00 01 ef call 2008520 <pthread_cond_destroy>
2007d68: 90 10 00 1c mov %i4, %o0
free (r_chain);
2007d6c: 7f ff ef cf call 2003ca8 <free>
2007d70: 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)) {
2007d74: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
2007d78: 80 a0 40 19 cmp %g1, %i1
2007d7c: 12 80 00 1b bne 2007de8 <rtems_aio_handle+0x210>
2007d80: 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);
2007d84: 92 07 bf f4 add %fp, -12, %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;
2007d88: 82 00 60 01 inc %g1
2007d8c: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
--aio_request_queue.active_threads;
2007d90: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007d94: 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;
2007d98: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007d9c: 40 00 01 ae call 2008454 <clock_gettime>
2007da0: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
timeout.tv_sec += 3;
2007da4: c2 07 bf f4 ld [ %fp + -12 ], %g1
timeout.tv_nsec = 0;
2007da8: c0 27 bf f8 clr [ %fp + -8 ]
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;
2007dac: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007db0: 90 10 00 1b mov %i3, %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;
2007db4: c2 27 bf f4 st %g1, [ %fp + -12 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007db8: 92 10 00 1d mov %i5, %o1
2007dbc: 40 00 02 59 call 2008720 <pthread_cond_timedwait>
2007dc0: 94 07 bf f4 add %fp, -12, %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) {
2007dc4: 80 a2 20 74 cmp %o0, 0x74
2007dc8: 12 80 00 08 bne 2007de8 <rtems_aio_handle+0x210> <== NEVER TAKEN
2007dcc: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
2007dd0: 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;
2007dd4: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
2007dd8: 40 00 03 70 call 2008b98 <pthread_mutex_unlock>
2007ddc: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
return NULL;
2007de0: 81 c7 e0 08 ret
2007de4: 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;
2007de8: 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;
2007dec: 82 00 7f ff add %g1, -1, %g1
2007df0: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
++aio_request_queue.active_threads;
2007df4: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
2007df8: 90 10 00 18 mov %i0, %o0
2007dfc: 82 00 60 01 inc %g1
2007e00: 40 00 09 ce call 200a538 <_Chain_Extract>
2007e04: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
2007e08: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
2007e0c: 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 &&
2007e10: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
2007e14: 80 a0 c0 02 cmp %g3, %g2
2007e18: 16 80 00 04 bge 2007e28 <rtems_aio_handle+0x250>
2007e1c: 80 a0 40 1a cmp %g1, %i2
2007e20: 32 bf ff fc bne,a 2007e10 <rtems_aio_handle+0x238> <== ALWAYS TAKEN
2007e24: 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 );
2007e28: d0 00 60 04 ld [ %g1 + 4 ], %o0
2007e2c: 40 00 09 db call 200a598 <_Chain_Insert>
2007e30: 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);
2007e34: 40 00 03 59 call 2008b98 <pthread_mutex_unlock>
2007e38: 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);
2007e3c: 10 bf ff 6e b 2007bf4 <rtems_aio_handle+0x1c>
2007e40: a0 06 20 1c add %i0, 0x1c, %l0
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007e44: b0 10 20 00 clr %i0 <== NOT EXECUTED
2007e48: 81 c7 e0 08 ret <== NOT EXECUTED
2007e4c: 81 e8 00 00 restore <== NOT EXECUTED
02007ea8 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
2007ea8: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
2007eac: 3b 00 80 80 sethi %hi(0x2020000), %i5
2007eb0: 40 00 03 90 call 2008cf0 <pthread_attr_init>
2007eb4: 90 17 60 2c or %i5, 0x2c, %o0 ! 202002c <aio_request_queue+0x8>
if (result != 0)
2007eb8: b0 92 20 00 orcc %o0, 0, %i0
2007ebc: 12 80 00 31 bne 2007f80 <rtems_aio_init+0xd8> <== NEVER TAKEN
2007ec0: 90 17 60 2c or %i5, 0x2c, %o0
return result;
result =
2007ec4: 40 00 03 97 call 2008d20 <pthread_attr_setdetachstate>
2007ec8: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
2007ecc: 80 a2 20 00 cmp %o0, 0
2007ed0: 22 80 00 05 be,a 2007ee4 <rtems_aio_init+0x3c> <== ALWAYS TAKEN
2007ed4: 11 00 80 80 sethi %hi(0x2020000), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007ed8: 40 00 03 7a call 2008cc0 <pthread_attr_destroy> <== NOT EXECUTED
2007edc: 90 17 60 2c or %i5, 0x2c, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
2007ee0: 11 00 80 80 sethi %hi(0x2020000), %o0 <== NOT EXECUTED
2007ee4: 92 10 20 00 clr %o1
2007ee8: 40 00 02 b6 call 20089c0 <pthread_mutex_init>
2007eec: 90 12 20 24 or %o0, 0x24, %o0
if (result != 0)
2007ef0: 80 a2 20 00 cmp %o0, 0
2007ef4: 22 80 00 06 be,a 2007f0c <rtems_aio_init+0x64> <== ALWAYS TAKEN
2007ef8: 11 00 80 80 sethi %hi(0x2020000), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007efc: 11 00 80 80 sethi %hi(0x2020000), %o0 <== NOT EXECUTED
2007f00: 40 00 03 70 call 2008cc0 <pthread_attr_destroy> <== NOT EXECUTED
2007f04: 90 12 20 2c or %o0, 0x2c, %o0 ! 202002c <aio_request_queue+0x8><== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
2007f08: 11 00 80 80 sethi %hi(0x2020000), %o0 <== NOT EXECUTED
2007f0c: 92 10 20 00 clr %o1
2007f10: 40 00 01 b8 call 20085f0 <pthread_cond_init>
2007f14: 90 12 20 28 or %o0, 0x28, %o0
if (result != 0) {
2007f18: b0 92 20 00 orcc %o0, 0, %i0
2007f1c: 02 80 00 09 be 2007f40 <rtems_aio_init+0x98> <== ALWAYS TAKEN
2007f20: 03 00 80 80 sethi %hi(0x2020000), %g1
pthread_mutex_destroy (&aio_request_queue.mutex);
2007f24: 11 00 80 80 sethi %hi(0x2020000), %o0 <== NOT EXECUTED
2007f28: 40 00 02 57 call 2008884 <pthread_mutex_destroy> <== NOT EXECUTED
2007f2c: 90 12 20 24 or %o0, 0x24, %o0 ! 2020024 <aio_request_queue><== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
2007f30: 11 00 80 80 sethi %hi(0x2020000), %o0 <== NOT EXECUTED
2007f34: 40 00 03 63 call 2008cc0 <pthread_attr_destroy> <== NOT EXECUTED
2007f38: 90 12 20 2c or %o0, 0x2c, %o0 ! 202002c <aio_request_queue+0x8><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2007f3c: 03 00 80 80 sethi %hi(0x2020000), %g1 <== NOT EXECUTED
2007f40: 82 10 60 24 or %g1, 0x24, %g1 ! 2020024 <aio_request_queue>
2007f44: 84 00 60 4c add %g1, 0x4c, %g2
2007f48: c4 20 60 48 st %g2, [ %g1 + 0x48 ]
head->previous = NULL;
tail->previous = head;
2007f4c: 84 00 60 48 add %g1, 0x48, %g2
2007f50: 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;
2007f54: 84 00 60 58 add %g1, 0x58, %g2
2007f58: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
head->previous = NULL;
tail->previous = head;
2007f5c: 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;
2007f60: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
2007f64: 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;
2007f68: 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;
2007f6c: 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;
2007f70: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007f74: 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;
2007f78: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007f7c: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
2007f80: 81 c7 e0 08 ret
2007f84: 81 e8 00 00 restore
02007e50 <rtems_aio_insert_prio>:
* NONE
*/
static void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
2007e50: 9d e3 bf a0 save %sp, -96, %sp
2007e54: 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 );
2007e58: 86 06 20 04 add %i0, 4, %g3
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
2007e5c: 80 a0 40 03 cmp %g1, %g3
2007e60: 02 80 00 10 be 2007ea0 <rtems_aio_insert_prio+0x50> <== NEVER TAKEN
2007e64: 84 10 00 19 mov %i1, %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;
2007e68: c8 00 60 14 ld [ %g1 + 0x14 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007e6c: de 06 60 14 ld [ %i1 + 0x14 ], %o7
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;
2007e70: c8 01 20 18 ld [ %g4 + 0x18 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007e74: 10 80 00 04 b 2007e84 <rtems_aio_insert_prio+0x34>
2007e78: de 03 e0 18 ld [ %o7 + 0x18 ], %o7
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
2007e7c: c8 00 60 14 ld [ %g1 + 0x14 ], %g4 <== NOT EXECUTED
2007e80: 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 &&
2007e84: 80 a3 c0 04 cmp %o7, %g4
2007e88: 04 80 00 04 ble 2007e98 <rtems_aio_insert_prio+0x48> <== ALWAYS TAKEN
2007e8c: 80 a0 40 03 cmp %g1, %g3
2007e90: 32 bf ff fb bne,a 2007e7c <rtems_aio_insert_prio+0x2c> <== NOT EXECUTED
2007e94: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
2007e98: f0 00 60 04 ld [ %g1 + 4 ], %i0
2007e9c: b2 10 00 02 mov %g2, %i1
2007ea0: 40 00 09 be call 200a598 <_Chain_Insert>
2007ea4: 81 e8 00 00 restore
02008084 <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)
{
2008084: 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;
2008088: 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 );
200808c: 82 06 20 04 add %i0, 4, %g1
if (rtems_chain_is_empty (chain))
2008090: 80 a7 40 01 cmp %i5, %g1
2008094: 12 80 00 09 bne 20080b8 <rtems_aio_remove_req+0x34>
2008098: b0 10 20 02 mov 2, %i0
200809c: 81 c7 e0 08 ret
20080a0: 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) {
20080a4: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
20080a8: 32 80 00 05 bne,a 20080bc <rtems_aio_remove_req+0x38> <== NOT EXECUTED
20080ac: 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;
20080b0: 81 c7 e0 08 ret <== NOT EXECUTED
20080b4: 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) {
20080b8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
20080bc: 80 a0 80 19 cmp %g2, %i1
20080c0: 32 bf ff f9 bne,a 20080a4 <rtems_aio_remove_req+0x20> <== NEVER TAKEN
20080c4: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
20080c8: 40 00 09 1c call 200a538 <_Chain_Extract>
20080cc: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
20080d0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
20080d4: 84 10 20 8c mov 0x8c, %g2
20080d8: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
20080dc: 84 10 3f ff mov -1, %g2
free (current);
20080e0: 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;
20080e4: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
free (current);
20080e8: 7f ff ee f0 call 2003ca8 <free>
20080ec: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
20080f0: 81 c7 e0 08 ret
20080f4: 81 e8 00 00 restore
0200d17c <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
200d17c: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
200d180: 03 00 80 85 sethi %hi(0x2021400), %g1
200d184: 82 10 60 c4 or %g1, 0xc4, %g1 ! 20214c4 <bdbuf_cache>
200d188: c4 08 60 30 ldub [ %g1 + 0x30 ], %g2
200d18c: 80 a0 a0 00 cmp %g2, 0
200d190: 22 80 00 10 be,a 200d1d0 <rtems_bdbuf_add_to_modified_list_after_access+0x54><== ALWAYS TAKEN
200d194: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
200d198: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 <== NOT EXECUTED
200d19c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
200d1a0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200d1a4: 32 80 00 0b bne,a 200d1d0 <rtems_bdbuf_add_to_modified_list_after_access+0x54><== NOT EXECUTED
200d1a8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200d1ac: 7f ff fe fa call 200cd94 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200d1b0: 01 00 00 00 nop <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
200d1b4: 7f ff fe 8f call 200cbf0 <rtems_bdbuf_lock_sync> <== NOT EXECUTED
200d1b8: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_unlock_sync ();
200d1bc: 7f ff ff 01 call 200cdc0 <rtems_bdbuf_unlock_sync> <== NOT EXECUTED
200d1c0: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200d1c4: 7f ff fe 7e call 200cbbc <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200d1c8: 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
200d1cc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
200d1d0: 80 a0 60 05 cmp %g1, 5
200d1d4: 22 80 00 06 be,a 200d1ec <rtems_bdbuf_add_to_modified_list_after_access+0x70>
200d1d8: 03 00 80 7a sethi %hi(0x201e800), %g1
200d1dc: 80 a0 60 03 cmp %g1, 3
200d1e0: 12 80 00 06 bne 200d1f8 <rtems_bdbuf_add_to_modified_list_after_access+0x7c>
200d1e4: 82 10 20 07 mov 7, %g1
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
200d1e8: 03 00 80 7a sethi %hi(0x201e800), %g1
200d1ec: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 201e990 <rtems_bdbuf_configuration+0x10>
200d1f0: 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;
200d1f4: 82 10 20 07 mov 7, %g1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
200d1f8: 11 00 80 85 sethi %hi(0x2021400), %o0
200d1fc: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200d200: 90 12 21 10 or %o0, 0x110, %o0
200d204: 7f ff f1 d6 call 200995c <_Chain_Append>
200d208: 92 10 00 18 mov %i0, %o1
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
200d20c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d210: 80 a0 60 00 cmp %g1, 0
200d214: 02 80 00 05 be 200d228 <rtems_bdbuf_add_to_modified_list_after_access+0xac>
200d218: 03 00 80 85 sethi %hi(0x2021400), %g1
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200d21c: 31 00 80 85 sethi %hi(0x2021400), %i0
200d220: 7f ff ff c9 call 200d144 <rtems_bdbuf_wake>
200d224: 91 ee 21 28 restore %i0, 0x128, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
200d228: c2 00 61 38 ld [ %g1 + 0x138 ], %g1
200d22c: 80 a0 60 00 cmp %g1, 0
200d230: 02 80 00 04 be 200d240 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
200d234: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200d238: 7f ff fe ed call 200cdec <rtems_bdbuf_wake_swapper>
200d23c: 81 e8 00 00 restore
200d240: 81 c7 e0 08 ret
200d244: 81 e8 00 00 restore
0200ceec <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)
{
200ceec: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
200cef0: c2 06 00 00 ld [ %i0 ], %g1
200cef4: 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 ();
200cef8: 7f ff ff e1 call 200ce7c <rtems_bdbuf_disable_preemption>
200cefc: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
200cf00: 7f ff ff a5 call 200cd94 <rtems_bdbuf_unlock_cache>
200cf04: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
200cf08: d0 06 20 04 ld [ %i0 + 4 ], %o0
200cf0c: 92 10 20 00 clr %o1
200cf10: 7f ff ef 91 call 2008d54 <rtems_semaphore_obtain>
200cf14: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
200cf18: 80 a2 20 06 cmp %o0, 6
200cf1c: 12 80 00 05 bne 200cf30 <rtems_bdbuf_anonymous_wait+0x44> <== ALWAYS TAKEN
200cf20: 80 a2 20 0d cmp %o0, 0xd
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
200cf24: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200cf28: 10 80 00 05 b 200cf3c <rtems_bdbuf_anonymous_wait+0x50> <== NOT EXECUTED
200cf2c: 90 12 20 12 or %o0, 0x12, %o0 ! 42000012 <RAM_END+0x3fc00012><== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
200cf30: 02 80 00 05 be 200cf44 <rtems_bdbuf_anonymous_wait+0x58> <== ALWAYS TAKEN
200cf34: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
200cf38: 90 12 20 10 or %o0, 0x10, %o0 ! 42000010 <RAM_END+0x3fc00010><== NOT EXECUTED
200cf3c: 7f ff f1 32 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cf40: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200cf44: 7f ff ff 1e call 200cbbc <rtems_bdbuf_lock_cache>
200cf48: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
200cf4c: 7f ff ff da call 200ceb4 <rtems_bdbuf_restore_preemption>
200cf50: 90 10 00 1d mov %i5, %o0
--waiters->count;
200cf54: c2 06 00 00 ld [ %i0 ], %g1
200cf58: 82 00 7f ff add %g1, -1, %g1
200cf5c: c2 26 00 00 st %g1, [ %i0 ]
}
200cf60: 81 c7 e0 08 ret
200cf64: 81 e8 00 00 restore
0200ce7c <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
200ce7c: 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);
200ce80: 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;
200ce84: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
200ce88: 92 10 21 00 mov 0x100, %o1
200ce8c: 40 00 0f 93 call 2010cd8 <rtems_task_mode>
200ce90: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
200ce94: 80 a2 20 00 cmp %o0, 0
200ce98: 22 80 00 05 be,a 200ceac <rtems_bdbuf_disable_preemption+0x30><== ALWAYS TAKEN
200ce9c: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
200cea0: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200cea4: 7f ff f1 58 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cea8: 90 12 20 0f or %o0, 0xf, %o0 ! 4200000f <RAM_END+0x3fc0000f><== NOT EXECUTED
return prev_mode;
}
200ceac: 81 c7 e0 08 ret
200ceb0: 81 e8 00 00 restore
0200cc24 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
200cc24: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
200cc28: 91 2e 20 10 sll %i0, 0x10, %o0 <== NOT EXECUTED
200cc2c: 7f ff f1 f6 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cc30: 90 16 40 08 or %i1, %o0, %o0 <== NOT EXECUTED
0200e668 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e668: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dd, block, &media_block, &bds_per_group);
200e66c: 90 10 00 18 mov %i0, %o0
rtems_status_code
rtems_bdbuf_get (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e670: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
200e674: c0 27 bf f8 clr [ %fp + -8 ]
size_t bds_per_group = 0;
200e678: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_bdbuf_obtain_disk (dd, block, &media_block, &bds_per_group);
200e67c: 92 10 00 19 mov %i1, %o1
200e680: 94 07 bf f8 add %fp, -8, %o2
200e684: 7f ff fa 7a call 200d06c <rtems_bdbuf_obtain_disk>
200e688: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL)
200e68c: b0 92 20 00 orcc %o0, 0, %i0
200e690: 12 80 00 1d bne 200e704 <rtems_bdbuf_get+0x9c> <== NEVER TAKEN
200e694: 01 00 00 00 nop
return sc;
rtems_bdbuf_lock_cache ();
200e698: 7f ff f9 49 call 200cbbc <rtems_bdbuf_lock_cache>
200e69c: 01 00 00 00 nop
*/
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, bds_per_group);
200e6a0: d2 07 bf f8 ld [ %fp + -8 ], %o1
200e6a4: d4 07 bf fc ld [ %fp + -4 ], %o2
200e6a8: 7f ff fe 76 call 200e080 <rtems_bdbuf_get_buffer_for_access>
200e6ac: 90 10 00 1d mov %i5, %o0
200e6b0: ba 10 00 08 mov %o0, %i5
switch (bd->state)
200e6b4: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200e6b8: 80 a2 20 02 cmp %o0, 2
200e6bc: 02 80 00 08 be 200e6dc <rtems_bdbuf_get+0x74>
200e6c0: 80 a2 20 07 cmp %o0, 7
200e6c4: 02 80 00 0c be 200e6f4 <rtems_bdbuf_get+0x8c>
200e6c8: 80 a2 20 01 cmp %o0, 1
200e6cc: 12 80 00 0c bne 200e6fc <rtems_bdbuf_get+0x94> <== NEVER TAKEN
200e6d0: 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;
200e6d4: 10 80 00 03 b 200e6e0 <rtems_bdbuf_get+0x78>
200e6d8: 82 10 20 05 mov 5, %g1
200e6dc: 82 10 20 03 mov 3, %g1
{
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
rtems_bdbuf_unlock_cache ();
200e6e0: 7f ff f9 ad call 200cd94 <rtems_bdbuf_unlock_cache>
200e6e4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
200e6e8: fa 26 80 00 st %i5, [ %i2 ]
200e6ec: 81 c7 e0 08 ret
200e6f0: 81 e8 00 00 restore
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e6f4: 10 bf ff fb b 200e6e0 <rtems_bdbuf_get+0x78>
200e6f8: 82 10 20 04 mov 4, %g1
* 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);
200e6fc: 7f ff f9 4a call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200e700: 92 12 60 1e or %o1, 0x1e, %o1 <== NOT EXECUTED
rtems_bdbuf_unlock_cache ();
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
200e704: 81 c7 e0 08 ret <== NOT EXECUTED
200e708: 81 e8 00 00 restore <== NOT EXECUTED
0200e080 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
200e080: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e084: 39 00 80 85 sethi %hi(0x2021400), %i4
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
200e088: ba 10 00 18 mov %i0, %i5
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e08c: b8 17 20 c4 or %i4, 0xc4, %i4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e090: 27 00 80 32 sethi %hi(0x200c800), %l3
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);
200e094: a4 07 20 6c add %i4, 0x6c, %l2
}
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);
200e098: a2 07 20 64 add %i4, 0x64, %l1
200e09c: a0 07 20 58 add %i4, 0x58, %l0
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200e0a0: b6 07 20 50 add %i4, 0x50, %i3
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e0a4: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
200e0a8: 92 10 00 1d mov %i5, %o1
200e0ac: 7f ff fb d7 call 200d008 <rtems_bdbuf_avl_search.isra.0>
200e0b0: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
200e0b4: b0 92 20 00 orcc %o0, 0, %i0
200e0b8: 02 80 00 37 be 200e194 <rtems_bdbuf_get_buffer_for_access+0x114>
200e0bc: 90 10 00 1d mov %i5, %o0
{
if (bd->group->bds_per_group != bds_per_group)
200e0c0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
200e0c4: c2 00 60 08 ld [ %g1 + 8 ], %g1
200e0c8: 80 a0 40 1a cmp %g1, %i2
200e0cc: 02 80 00 43 be 200e1d8 <rtems_bdbuf_get_buffer_for_access+0x158>
200e0d0: a8 10 20 08 mov 8, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e0d4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200e0d8: 80 a2 20 0a cmp %o0, 0xa
200e0dc: 18 80 00 20 bgu 200e15c <rtems_bdbuf_get_buffer_for_access+0xdc><== NEVER TAKEN
200e0e0: 13 10 80 00 sethi %hi(0x42000000), %o1
200e0e4: 82 14 e3 64 or %l3, 0x364, %g1
200e0e8: 91 2a 20 02 sll %o0, 2, %o0
200e0ec: c2 00 40 08 ld [ %g1 + %o0 ], %g1
200e0f0: 81 c0 40 00 jmp %g1
200e0f4: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
200e0f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e0fc: 40 00 0c 1f call 2011178 <_Chain_Extract> <== NOT EXECUTED
200e100: e8 26 20 20 st %l4, [ %i0 + 0x20 ] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
200e104: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
200e108: 7f ff ee 15 call 200995c <_Chain_Append> <== NOT EXECUTED
200e10c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
200e110: 7f ff fb 37 call 200cdec <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
200e114: 01 00 00 00 nop <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e118: 10 bf ff f0 b 200e0d8 <rtems_bdbuf_get_buffer_for_access+0x58><== NOT EXECUTED
200e11c: d0 06 20 20 ld [ %i0 + 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)
200e120: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200e124: 80 a0 60 00 cmp %g1, 0
200e128: 02 80 00 0f be 200e164 <rtems_bdbuf_get_buffer_for_access+0xe4><== NEVER TAKEN
200e12c: 01 00 00 00 nop
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
rtems_bdbuf_wake_swapper ();
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
200e130: 10 80 00 26 b 200e1c8 <rtems_bdbuf_get_buffer_for_access+0x148>
200e134: 11 00 80 85 sethi %hi(0x2021400), %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);
200e138: 90 10 00 18 mov %i0, %o0
200e13c: 10 80 00 04 b 200e14c <rtems_bdbuf_get_buffer_for_access+0xcc>
200e140: 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);
200e144: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e148: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
200e14c: 7f ff fb 87 call 200cf68 <rtems_bdbuf_wait>
200e150: 01 00 00 00 nop
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e154: 10 bf ff e1 b 200e0d8 <rtems_bdbuf_get_buffer_for_access+0x58>
200e158: 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_8);
200e15c: 10 80 00 3f b 200e258 <rtems_bdbuf_get_buffer_for_access+0x1d8><== NOT EXECUTED
200e160: 92 12 60 06 or %o1, 6, %o1 <== NOT EXECUTED
{
if (bd->group->bds_per_group != bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200e164: 7f ff fd 13 call 200d5b0 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
200e168: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e16c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e170: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
200e174: 11 00 80 85 sethi %hi(0x2021400), %o0 <== NOT EXECUTED
200e178: 40 00 0c 09 call 201119c <_Chain_Insert> <== NOT EXECUTED
200e17c: 90 12 21 04 or %o0, 0x104, %o0 ! 2021504 <bdbuf_cache+0x40><== NOT EXECUTED
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200e180: 11 00 80 85 sethi %hi(0x2021400), %o0 <== NOT EXECUTED
200e184: 7f ff fb f0 call 200d144 <rtems_bdbuf_wake> <== NOT EXECUTED
200e188: 90 12 21 38 or %o0, 0x138, %o0 ! 2021538 <bdbuf_cache+0x74><== NOT EXECUTED
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e18c: 10 bf ff c7 b 200e0a8 <rtems_bdbuf_get_buffer_for_access+0x28><== NOT EXECUTED
200e190: d0 07 20 3c ld [ %i4 + 0x3c ], %o0 <== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block, bds_per_group);
200e194: 92 10 00 19 mov %i1, %o1
200e198: 7f ff fe d4 call 200dce8 <rtems_bdbuf_get_buffer_from_lru_list>
200e19c: 94 10 00 1a mov %i2, %o2
if (bd == NULL)
200e1a0: b0 92 20 00 orcc %o0, 0, %i0
200e1a4: 32 80 00 0e bne,a 200e1dc <rtems_bdbuf_get_buffer_for_access+0x15c>
200e1a8: 3b 00 80 85 sethi %hi(0x2021400), %i5
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200e1ac: c2 07 20 4c ld [ %i4 + 0x4c ], %g1
200e1b0: 80 a0 40 1b cmp %g1, %i3
200e1b4: 22 80 00 05 be,a 200e1c8 <rtems_bdbuf_get_buffer_for_access+0x148>
200e1b8: 11 00 80 85 sethi %hi(0x2021400), %o0
rtems_bdbuf_wake_swapper ();
200e1bc: 7f ff fb 0c call 200cdec <rtems_bdbuf_wake_swapper>
200e1c0: 01 00 00 00 nop
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
200e1c4: 11 00 80 85 sethi %hi(0x2021400), %o0
200e1c8: 7f ff fb 49 call 200ceec <rtems_bdbuf_anonymous_wait>
200e1cc: 90 12 21 38 or %o0, 0x138, %o0 ! 2021538 <bdbuf_cache+0x74>
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e1d0: 10 bf ff b6 b 200e0a8 <rtems_bdbuf_get_buffer_for_access+0x28>
200e1d4: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
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);
200e1d8: 3b 00 80 85 sethi %hi(0x2021400), %i5
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e1dc: 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);
200e1e0: ba 17 61 30 or %i5, 0x130, %i5
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);
200e1e4: b8 07 7f f8 add %i5, -8, %i4
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e1e8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200e1ec: 82 02 3f ff add %o0, -1, %g1
200e1f0: 80 a0 60 09 cmp %g1, 9
200e1f4: 18 80 00 18 bgu 200e254 <rtems_bdbuf_get_buffer_for_access+0x1d4><== NEVER TAKEN
200e1f8: 13 10 80 00 sethi %hi(0x42000000), %o1
200e1fc: 84 16 e3 3c or %i3, 0x33c, %g2
200e200: 83 28 60 02 sll %g1, 2, %g1
200e204: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200e208: 81 c0 40 00 jmp %g1
200e20c: 01 00 00 00 nop
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200e210: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
200e214: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200e218: 84 00 bf ff add %g2, -1, %g2
200e21c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
200e220: 40 00 0b d6 call 2011178 <_Chain_Extract>
200e224: 90 10 00 18 mov %i0, %o0
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200e228: 10 80 00 0f b 200e264 <rtems_bdbuf_get_buffer_for_access+0x1e4>
200e22c: c2 06 20 28 ld [ %i0 + 0x28 ], %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);
200e230: 90 10 00 18 mov %i0, %o0
200e234: 10 80 00 04 b 200e244 <rtems_bdbuf_get_buffer_for_access+0x1c4>
200e238: 92 10 00 1c mov %i4, %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);
200e23c: 90 10 00 18 mov %i0, %o0
200e240: 92 10 00 1d mov %i5, %o1
200e244: 7f ff fb 49 call 200cf68 <rtems_bdbuf_wait>
200e248: 01 00 00 00 nop
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e24c: 10 bf ff e8 b 200e1ec <rtems_bdbuf_get_buffer_for_access+0x16c>
200e250: 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_7);
200e254: 92 12 60 05 or %o1, 5, %o1 <== NOT EXECUTED
200e258: 7f ff fa 73 call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200e25c: 01 00 00 00 nop <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200e260: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
200e264: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200e268: 84 00 a0 01 inc %g2
200e26c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
200e270: 81 c7 e0 08 ret
200e274: 81 e8 00 00 restore
0200dce8 <rtems_bdbuf_get_buffer_from_lru_list>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
200dce8: 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;
200dcec: 2b 00 80 85 sethi %hi(0x2021400), %l5
200dcf0: ba 10 00 18 mov %i0, %i5
200dcf4: a6 15 60 c4 or %l5, 0xc4, %l3
200dcf8: f6 04 e0 40 ld [ %l3 + 0x40 ], %i3
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200dcfc: a2 04 e0 44 add %l3, 0x44, %l1
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
200dd00: a8 04 e0 40 add %l3, 0x40, %l4
200dd04: 10 80 00 d7 b 200e060 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
200dd08: a6 04 e0 74 add %l3, 0x74, %l3
bd->group->bds_per_group, bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
200dd0c: 80 a0 60 00 cmp %g1, 0
200dd10: 32 80 00 d4 bne,a 200e060 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
200dd14: f6 06 c0 00 ld [ %i3 ], %i3
{
if (bd->group->bds_per_group == bds_per_group)
200dd18: f8 06 e0 28 ld [ %i3 + 0x28 ], %i4
200dd1c: d2 07 20 08 ld [ %i4 + 8 ], %o1
200dd20: 80 a2 40 1a cmp %o1, %i2
200dd24: 32 80 00 07 bne,a 200dd40 <rtems_bdbuf_get_buffer_from_lru_list+0x58>
200dd28: c2 07 20 0c ld [ %i4 + 0xc ], %g1
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200dd2c: 90 10 00 1b mov %i3, %o0
200dd30: 7f ff fe 20 call 200d5b0 <rtems_bdbuf_remove_from_tree_and_lru_list>
200dd34: b0 10 00 1b mov %i3, %i0
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
200dd38: 10 80 00 30 b 200ddf8 <rtems_bdbuf_get_buffer_from_lru_list+0x110>
200dd3c: 80 a6 20 00 cmp %i0, 0
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
empty_bd = bd;
}
else if (bd->group->users == 0)
200dd40: 80 a0 60 00 cmp %g1, 0
200dd44: 32 80 00 c7 bne,a 200e060 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
200dd48: f6 06 c0 00 ld [ %i3 ], %i3
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;
200dd4c: d0 04 7f dc ld [ %l1 + -36 ], %o0
200dd50: 40 00 39 9d call 201c3c4 <.udiv>
200dd54: f0 07 20 10 ld [ %i4 + 0x10 ], %i0
for (b = 0, bd = group->bdbuf;
200dd58: a0 10 20 00 clr %l0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200dd5c: 83 2a 20 03 sll %o0, 3, %g1
200dd60: a5 2a 20 06 sll %o0, 6, %l2
200dd64: 10 80 00 05 b 200dd78 <rtems_bdbuf_get_buffer_from_lru_list+0x90>
200dd68: a4 24 80 01 sub %l2, %g1, %l2
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200dd6c: 7f ff fe 11 call 200d5b0 <rtems_bdbuf_remove_from_tree_and_lru_list>
200dd70: 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)
200dd74: b0 06 00 12 add %i0, %l2, %i0
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;
200dd78: c2 07 20 08 ld [ %i4 + 8 ], %g1
200dd7c: 80 a4 00 01 cmp %l0, %g1
200dd80: 0a bf ff fb bcs 200dd6c <rtems_bdbuf_get_buffer_from_lru_list+0x84>
200dd84: 90 10 00 18 mov %i0, %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;
200dd88: 82 15 60 c4 or %l5, 0xc4, %g1
200dd8c: 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;
200dd90: f4 27 20 08 st %i2, [ %i4 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
200dd94: 40 00 39 8c call 201c3c4 <.udiv>
200dd98: 92 10 00 1a mov %i2, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
200dd9c: e0 07 20 10 ld [ %i4 + 0x10 ], %l0
200dda0: 83 2a 20 03 sll %o0, 3, %g1
200dda4: a5 2a 20 06 sll %o0, 6, %l2
200dda8: b0 10 20 01 mov 1, %i0
200ddac: a4 24 80 01 sub %l2, %g1, %l2
200ddb0: 10 80 00 07 b 200ddcc <rtems_bdbuf_get_buffer_from_lru_list+0xe4>
200ddb4: a0 04 00 12 add %l0, %l2, %l0
200ddb8: 92 10 00 10 mov %l0, %o1
200ddbc: 90 10 00 14 mov %l4, %o0
200ddc0: 40 00 0c f7 call 201119c <_Chain_Insert>
200ddc4: b0 06 20 01 inc %i0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200ddc8: a0 04 00 12 add %l0, %l2, %l0
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;
200ddcc: c2 07 20 08 ld [ %i4 + 8 ], %g1
200ddd0: 80 a6 00 01 cmp %i0, %g1
200ddd4: 2a bf ff f9 bcs,a 200ddb8 <rtems_bdbuf_get_buffer_from_lru_list+0xd0>
200ddd8: c0 24 20 20 clr [ %l0 + 0x20 ]
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
200dddc: 80 a6 20 01 cmp %i0, 1
200dde0: 28 80 00 05 bleu,a 200ddf4 <rtems_bdbuf_get_buffer_from_lru_list+0x10c>
200dde4: f0 07 20 10 ld [ %i4 + 0x10 ], %i0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200dde8: 7f ff fc d7 call 200d144 <rtems_bdbuf_wake>
200ddec: 90 10 00 13 mov %l3, %o0
return group->bdbuf;
200ddf0: f0 07 20 10 ld [ %i4 + 0x10 ], %i0
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
200ddf4: 80 a6 20 00 cmp %i0, 0
200ddf8: 22 80 00 9a be,a 200e060 <rtems_bdbuf_get_buffer_from_lru_list+0x378><== NEVER TAKEN
200ddfc: f6 06 c0 00 ld [ %i3 ], %i3 <== NOT EXECUTED
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
200de00: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
200de04: c0 26 20 08 clr [ %i0 + 8 ]
bd->avl.right = NULL;
200de08: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
200de0c: 05 00 80 85 sethi %hi(0x2021400), %g2
200de10: 84 10 a0 c4 or %g2, 0xc4, %g2 ! 20214c4 <bdbuf_cache>
200de14: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
200de18: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
200de1c: c0 26 20 24 clr [ %i0 + 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;
200de20: 88 07 bf 80 add %fp, -128, %g4
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200de24: 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)
200de28: 80 a0 60 00 cmp %g1, 0
200de2c: 12 80 00 1d bne 200dea0 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
200de30: 86 10 20 01 mov 1, %g3
{
*root = node;
200de34: f0 20 a0 3c st %i0, [ %g2 + 0x3c ]
node->avl.left = NULL;
200de38: c0 26 20 08 clr [ %i0 + 8 ]
node->avl.right = NULL;
200de3c: c0 26 20 0c clr [ %i0 + 0xc ]
node->avl.bal = 0;
200de40: 10 80 00 84 b 200e050 <rtems_bdbuf_get_buffer_from_lru_list+0x368>
200de44: c0 2e 20 11 clrb [ %i0 + 0x11 ]
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
200de48: 32 80 00 0f bne,a 200de84 <rtems_bdbuf_get_buffer_from_lru_list+0x19c><== NEVER TAKEN
200de4c: c4 00 60 08 ld [ %g1 + 8 ], %g2 <== NOT EXECUTED
200de50: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
200de54: 80 a0 80 19 cmp %g2, %i1
200de58: 1a 80 00 08 bcc 200de78 <rtems_bdbuf_get_buffer_from_lru_list+0x190>
200de5c: 01 00 00 00 nop
{
p->avl.cache = 1;
q = p->avl.right;
200de60: c4 00 60 0c ld [ %g1 + 0xc ], %g2
if (q == NULL)
200de64: 80 a0 a0 00 cmp %g2, 0
200de68: 12 80 00 0c bne 200de98 <rtems_bdbuf_get_buffer_from_lru_list+0x1b0>
200de6c: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
{
q = node;
p->avl.right = q = node;
200de70: 10 80 00 12 b 200deb8 <rtems_bdbuf_get_buffer_from_lru_list+0x1d0>
200de74: f0 20 60 0c st %i0, [ %g1 + 0xc ]
break;
}
}
else if ((p->dd != dd) || (p->block != block))
200de78: 02 80 00 7f be 200e074 <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== NEVER TAKEN
200de7c: 11 10 80 00 sethi %hi(0x42000000), %o0
{
p->avl.cache = -1;
q = p->avl.left;
200de80: c4 00 60 08 ld [ %g1 + 8 ], %g2
if (q == NULL)
200de84: 80 a0 a0 00 cmp %g2, 0
200de88: 12 80 00 04 bne 200de98 <rtems_bdbuf_get_buffer_from_lru_list+0x1b0>
200de8c: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
200de90: 10 80 00 0a b 200deb8 <rtems_bdbuf_get_buffer_from_lru_list+0x1d0>
200de94: f0 20 60 08 st %i0, [ %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)
200de98: 88 10 00 1b mov %i3, %g4
200de9c: 82 10 00 02 mov %g2, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200dea0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
200dea4: c2 21 00 00 st %g1, [ %g4 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200dea8: 80 a0 80 1d cmp %g2, %i5
200deac: 0a bf ff ed bcs 200de60 <rtems_bdbuf_get_buffer_from_lru_list+0x178><== NEVER TAKEN
200deb0: b6 01 20 04 add %g4, 4, %i3
200deb4: 30 bf ff e5 b,a 200de48 <rtems_bdbuf_get_buffer_from_lru_list+0x160>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
200deb8: c0 26 20 0c clr [ %i0 + 0xc ]
200debc: c0 26 20 08 clr [ %i0 + 8 ]
q->avl.bal = 0;
200dec0: c0 2e 20 11 clrb [ %i0 + 0x11 ]
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
200dec4: b8 10 20 01 mov 1, %i4
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200dec8: 10 80 00 03 b 200ded4 <rtems_bdbuf_get_buffer_from_lru_list+0x1ec>
200decc: b6 07 bf 80 add %fp, -128, %i3
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200ded0: 82 10 00 03 mov %g3, %g1
{
if (p->avl.cache == -1)
200ded4: c4 48 60 10 ldsb [ %g1 + 0x10 ], %g2
200ded8: fa 08 60 11 ldub [ %g1 + 0x11 ], %i5
200dedc: 80 a0 bf ff cmp %g2, -1
{
switch (p->avl.bal)
200dee0: bb 2f 60 18 sll %i5, 0x18, %i5
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
200dee4: 12 80 00 23 bne 200df70 <rtems_bdbuf_get_buffer_from_lru_list+0x288>
200dee8: bb 3f 60 18 sra %i5, 0x18, %i5
{
switch (p->avl.bal)
200deec: 80 a7 60 00 cmp %i5, 0
200def0: 22 80 00 48 be,a 200e010 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
200def4: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
200def8: 80 a7 60 01 cmp %i5, 1
200defc: 02 80 00 25 be 200df90 <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
200df00: 80 a7 7f ff cmp %i5, -1
200df04: 32 80 00 44 bne,a 200e014 <rtems_bdbuf_get_buffer_from_lru_list+0x32c><== NEVER TAKEN
200df08: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
200df0c: c6 00 60 08 ld [ %g1 + 8 ], %g3
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
200df10: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
200df14: 80 a0 bf ff cmp %g2, -1
200df18: 12 80 00 05 bne 200df2c <rtems_bdbuf_get_buffer_from_lru_list+0x244>
200df1c: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
{
p->avl.left = p1->avl.right;
200df20: c4 20 60 08 st %g2, [ %g1 + 8 ]
p1->avl.right = p;
200df24: 10 80 00 24 b 200dfb4 <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
200df28: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200df2c: f4 00 a0 08 ld [ %g2 + 8 ], %i2
p2->avl.left = p1;
200df30: c6 20 a0 08 st %g3, [ %g2 + 8 ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200df34: f4 20 e0 0c st %i2, [ %g3 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200df38: f4 00 a0 0c ld [ %g2 + 0xc ], %i2
p2->avl.right = p;
200df3c: c2 20 a0 0c st %g1, [ %g2 + 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;
200df40: f4 20 60 08 st %i2, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
200df44: f4 48 a0 11 ldsb [ %g2 + 0x11 ], %i2
200df48: b4 38 00 1a xnor %g0, %i2, %i2
200df4c: 80 a0 00 1a cmp %g0, %i2
200df50: b4 60 3f ff subx %g0, -1, %i2
200df54: f4 28 60 11 stb %i2, [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200df58: c2 48 a0 11 ldsb [ %g2 + 0x11 ], %g1
200df5c: 80 a0 60 01 cmp %g1, 1
200df60: 32 80 00 28 bne,a 200e000 <rtems_bdbuf_get_buffer_from_lru_list+0x318>
200df64: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200df68: 10 80 00 26 b 200e000 <rtems_bdbuf_get_buffer_from_lru_list+0x318>
200df6c: fa 28 e0 11 stb %i5, [ %g3 + 0x11 ]
break;
}
}
else
{
switch (p->avl.bal)
200df70: 80 a7 60 00 cmp %i5, 0
200df74: 22 80 00 27 be,a 200e010 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
200df78: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
200df7c: 80 a7 60 01 cmp %i5, 1
200df80: 02 80 00 06 be 200df98 <rtems_bdbuf_get_buffer_from_lru_list+0x2b0>
200df84: 80 a7 7f ff cmp %i5, -1
200df88: 32 80 00 23 bne,a 200e014 <rtems_bdbuf_get_buffer_from_lru_list+0x32c><== NEVER TAKEN
200df8c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
{
case -1:
p->avl.bal = 0;
200df90: 10 80 00 1e b 200e008 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200df94: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
200df98: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (p1->avl.bal == 1) /* simple RR-turn */
200df9c: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
200dfa0: 80 a0 a0 01 cmp %g2, 1
200dfa4: 12 80 00 07 bne 200dfc0 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
200dfa8: c4 00 e0 08 ld [ %g3 + 8 ], %g2
{
p->avl.right = p1->avl.left;
200dfac: c4 20 60 0c st %g2, [ %g1 + 0xc ]
p1->avl.left = p;
200dfb0: c2 20 e0 08 st %g1, [ %g3 + 8 ]
p->avl.bal = 0;
200dfb4: c0 28 60 11 clrb [ %g1 + 0x11 ]
200dfb8: 10 80 00 12 b 200e000 <rtems_bdbuf_get_buffer_from_lru_list+0x318>
200dfbc: 84 10 00 03 mov %g3, %g2
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200dfc0: fa 00 a0 0c ld [ %g2 + 0xc ], %i5
p2->avl.right = p1;
200dfc4: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200dfc8: fa 20 e0 08 st %i5, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200dfcc: fa 00 a0 08 ld [ %g2 + 8 ], %i5
p2->avl.left = p;
200dfd0: c2 20 a0 08 st %g1, [ %g2 + 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;
200dfd4: fa 20 60 0c st %i5, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200dfd8: fa 48 a0 11 ldsb [ %g2 + 0x11 ], %i5
200dfdc: ba 1f 60 01 xor %i5, 1, %i5
200dfe0: 80 a0 00 1d cmp %g0, %i5
200dfe4: ba 40 3f ff addx %g0, -1, %i5
200dfe8: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
200dfec: c2 48 a0 11 ldsb [ %g2 + 0x11 ], %g1
200dff0: 80 a0 7f ff cmp %g1, -1
200dff4: 32 80 00 03 bne,a 200e000 <rtems_bdbuf_get_buffer_from_lru_list+0x318>
200dff8: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200dffc: f8 28 e0 11 stb %i4, [ %g3 + 0x11 ]
p = p2;
}
p->avl.bal = 0;
200e000: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200e004: 82 10 00 02 mov %g2, %g1
modified = false;
200e008: 10 80 00 03 b 200e014 <rtems_bdbuf_get_buffer_from_lru_list+0x32c>
200e00c: 84 10 20 00 clr %g2
break;
}
}
else
{
switch (p->avl.bal)
200e010: 84 10 20 01 mov 1, %g2
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200e014: 80 a1 00 1b cmp %g4, %i3
200e018: 28 80 00 09 bleu,a 200e03c <rtems_bdbuf_get_buffer_from_lru_list+0x354>
200e01c: 05 00 80 85 sethi %hi(0x2021400), %g2
{
p = *--buf_prev;
200e020: c6 01 3f fc ld [ %g4 + -4 ], %g3
if (p->avl.cache == -1)
200e024: fa 48 e0 10 ldsb [ %g3 + 0x10 ], %i5
200e028: 80 a7 7f ff cmp %i5, -1
200e02c: 32 80 00 06 bne,a 200e044 <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
200e030: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
{
p->avl.left = q;
200e034: 10 80 00 04 b 200e044 <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
200e038: c2 20 e0 08 st %g1, [ %g3 + 8 ]
p->avl.right = q;
}
}
else
{
*root = p;
200e03c: 10 80 00 05 b 200e050 <rtems_bdbuf_get_buffer_from_lru_list+0x368>
200e040: c2 20 a1 00 st %g1, [ %g2 + 0x100 ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200e044: 80 88 a0 ff btst 0xff, %g2
200e048: 12 bf ff a2 bne 200ded0 <rtems_bdbuf_get_buffer_from_lru_list+0x1e8>
200e04c: 88 01 3f fc add %g4, -4, %g4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e050: 82 10 20 01 mov 1, %g1
200e054: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dd, block);
return empty_bd;
200e058: 81 c7 e0 08 ret
200e05c: 81 e8 00 00 restore
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200e060: 80 a6 c0 11 cmp %i3, %l1
200e064: 32 bf ff 2a bne,a 200dd0c <rtems_bdbuf_get_buffer_from_lru_list+0x24>
200e068: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
node = rtems_chain_next (node);
}
return NULL;
}
200e06c: 81 c7 e0 08 ret
200e070: 91 e8 20 00 restore %g0, 0, %o0
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);
200e074: 7f ff ec e4 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200e078: 90 12 20 1b or %o0, 0x1b, %o0 <== NOT EXECUTED
0200e278 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
200e278: 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())
200e27c: 03 00 80 87 sethi %hi(0x2021c00), %g1
200e280: c2 00 62 78 ld [ %g1 + 0x278 ], %g1 ! 2021e78 <_Per_CPU_Information+0x8>
200e284: 80 a0 60 00 cmp %g1, 0
200e288: 12 80 00 16 bne 200e2e0 <rtems_bdbuf_init+0x68> <== NEVER TAKEN
200e28c: 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)
200e290: 35 00 80 7a sethi %hi(0x201e800), %i2
200e294: b4 16 a1 80 or %i2, 0x180, %i2 ! 201e980 <rtems_bdbuf_configuration>
200e298: f2 06 a0 24 ld [ %i2 + 0x24 ], %i1
200e29c: f8 06 a0 20 ld [ %i2 + 0x20 ], %i4
200e2a0: 90 10 00 19 mov %i1, %o0
200e2a4: 92 10 00 1c mov %i4, %o1
200e2a8: 40 00 38 f3 call 201c674 <.urem>
200e2ac: b0 10 20 0a mov 0xa, %i0
200e2b0: 80 a2 20 00 cmp %o0, 0
200e2b4: 12 80 00 eb bne 200e660 <rtems_bdbuf_init+0x3e8> <== NEVER TAKEN
200e2b8: 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 ();
200e2bc: 7f ff fa f0 call 200ce7c <rtems_bdbuf_disable_preemption>
200e2c0: 3b 00 80 85 sethi %hi(0x2021400), %i5
if (bdbuf_cache.initialised)
200e2c4: ba 17 60 c4 or %i5, 0xc4, %i5 ! 20214c4 <bdbuf_cache>
200e2c8: c2 0f 60 84 ldub [ %i5 + 0x84 ], %g1
200e2cc: 80 a0 60 00 cmp %g1, 0
200e2d0: 02 80 00 06 be 200e2e8 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
200e2d4: b6 10 00 08 mov %o0, %i3
{
rtems_bdbuf_restore_preemption (prev_mode);
200e2d8: 7f ff fa f7 call 200ceb4 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
200e2dc: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
200e2e0: 81 c7 e0 08 ret <== NOT EXECUTED
200e2e4: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
200e2e8: 92 10 20 00 clr %o1
200e2ec: 94 10 20 88 mov 0x88, %o2
200e2f0: 40 00 17 21 call 2013f74 <memset>
200e2f4: 90 10 00 1d mov %i5, %o0
bdbuf_cache.initialised = true;
200e2f8: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
200e2fc: 90 10 00 1b mov %i3, %o0
200e300: 7f ff fa ed call 200ceb4 <rtems_bdbuf_restore_preemption>
200e304: c2 2f 60 84 stb %g1, [ %i5 + 0x84 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e308: 82 07 60 0c add %i5, 0xc, %g1
200e30c: c2 27 60 08 st %g1, [ %i5 + 8 ]
head->previous = NULL;
tail->previous = head;
200e310: 82 07 60 08 add %i5, 8, %g1
200e314: 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;
200e318: 82 07 60 44 add %i5, 0x44, %g1
200e31c: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
head->previous = NULL;
tail->previous = head;
200e320: 82 07 60 40 add %i5, 0x40, %g1
200e324: 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;
200e328: 82 07 60 50 add %i5, 0x50, %g1
200e32c: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
head->previous = NULL;
tail->previous = head;
200e330: 82 07 60 4c add %i5, 0x4c, %g1
200e334: 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;
200e338: 82 07 60 5c add %i5, 0x5c, %g1
200e33c: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
head->previous = NULL;
tail->previous = head;
200e340: 82 07 60 58 add %i5, 0x58, %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;
200e344: 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;
200e348: c0 27 60 0c clr [ %i5 + 0xc ]
200e34c: c0 27 60 44 clr [ %i5 + 0x44 ]
200e350: c0 27 60 50 clr [ %i5 + 0x50 ]
200e354: c0 27 60 5c clr [ %i5 + 0x5c ]
tail->previous = head;
200e358: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
200e35c: 37 10 91 10 sethi %hi(0x42444000), %i3
200e360: 92 10 20 01 mov 1, %o1
200e364: 90 16 e3 6c or %i3, 0x36c, %o0
200e368: 94 10 20 54 mov 0x54, %o2
200e36c: 96 10 20 00 clr %o3
200e370: 7f ff e9 df call 2008aec <rtems_semaphore_create>
200e374: 98 07 60 28 add %i5, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
200e378: 80 a2 20 00 cmp %o0, 0
200e37c: 12 80 00 99 bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e380: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
rtems_bdbuf_lock_cache ();
200e384: 7f ff fa 0e call 200cbbc <rtems_bdbuf_lock_cache>
200e388: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
200e38c: 90 16 e3 73 or %i3, 0x373, %o0
200e390: 92 10 20 01 mov 1, %o1
200e394: 94 10 20 54 mov 0x54, %o2
200e398: 96 10 20 00 clr %o3
200e39c: 7f ff e9 d4 call 2008aec <rtems_semaphore_create>
200e3a0: 98 07 60 2c add %i5, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
200e3a4: 80 a2 20 00 cmp %o0, 0
200e3a8: 12 80 00 8e bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e3ac: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
200e3b0: 90 16 e3 61 or %i3, 0x361, %o0
200e3b4: 92 10 20 00 clr %o1
200e3b8: 94 10 20 24 mov 0x24, %o2
200e3bc: 96 10 20 00 clr %o3
200e3c0: 7f ff e9 cb call 2008aec <rtems_semaphore_create>
200e3c4: 98 07 60 68 add %i5, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e3c8: 80 a2 20 00 cmp %o0, 0
200e3cc: 12 80 00 85 bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e3d0: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
200e3d4: 90 16 e3 74 or %i3, 0x374, %o0
200e3d8: 92 10 20 00 clr %o1
200e3dc: 94 10 20 24 mov 0x24, %o2
200e3e0: 96 10 20 00 clr %o3
200e3e4: 7f ff e9 c2 call 2008aec <rtems_semaphore_create>
200e3e8: 98 07 60 70 add %i5, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e3ec: 80 a2 20 00 cmp %o0, 0
200e3f0: 12 80 00 7c bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e3f4: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
200e3f8: 90 16 e3 62 or %i3, 0x362, %o0
200e3fc: 92 10 20 00 clr %o1
200e400: 94 10 20 24 mov 0x24, %o2
200e404: 96 10 20 00 clr %o3
200e408: 7f ff e9 b9 call 2008aec <rtems_semaphore_create>
200e40c: 98 07 60 78 add %i5, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e410: 80 a2 20 00 cmp %o0, 0
200e414: 12 80 00 73 bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e418: 03 00 80 85 sethi %hi(0x2021400), %g1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
200e41c: d0 06 a0 1c ld [ %i2 + 0x1c ], %o0
200e420: 40 00 37 e9 call 201c3c4 <.udiv>
200e424: 92 10 00 1c mov %i4, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200e428: 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;
200e42c: b6 10 00 08 mov %o0, %i3
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
200e430: 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;
200e434: 40 00 37 e4 call 201c3c4 <.udiv>
200e438: 90 10 00 19 mov %i1, %o0
200e43c: 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 =
200e440: 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;
200e444: 40 00 37 e0 call 201c3c4 <.udiv>
200e448: 90 10 00 1b mov %i3, %o0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e44c: 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 =
200e450: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200e454: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e458: 7f ff d8 8e call 2004690 <calloc>
200e45c: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
200e460: 80 a2 20 00 cmp %o0, 0
200e464: 02 80 00 5e be 200e5dc <rtems_bdbuf_init+0x364> <== NEVER TAKEN
200e468: 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),
200e46c: 90 10 20 14 mov 0x14, %o0
200e470: 7f ff d8 88 call 2004690 <calloc>
200e474: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
200e478: 80 a2 20 00 cmp %o0, 0
200e47c: 02 80 00 58 be 200e5dc <rtems_bdbuf_init+0x364> <== NEVER TAKEN
200e480: 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)
200e484: 92 10 00 1c mov %i4, %o1
200e488: 40 00 37 95 call 201c2dc <.umul>
200e48c: 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,
200e490: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
200e494: 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,
200e498: 11 00 80 85 sethi %hi(0x2021400), %o0
200e49c: 40 00 06 ab call 200ff48 <rtems_memalign>
200e4a0: 90 12 20 dc or %o0, 0xdc, %o0 ! 20214dc <bdbuf_cache+0x18>
200e4a4: 80 a2 20 00 cmp %o0, 0
200e4a8: 12 80 00 4e bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e4ac: 03 00 80 85 sethi %hi(0x2021400), %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,
200e4b0: 3b 00 80 85 sethi %hi(0x2021400), %i5
200e4b4: b4 10 20 00 clr %i2
200e4b8: ba 17 60 c4 or %i5, 0xc4, %i5
200e4bc: f0 07 60 80 ld [ %i5 + 0x80 ], %i0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200e4c0: f6 07 60 14 ld [ %i5 + 0x14 ], %i3
200e4c4: f2 07 60 18 ld [ %i5 + 0x18 ], %i1
/*
* 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,
200e4c8: 10 80 00 12 b 200e510 <rtems_bdbuf_init+0x298>
200e4cc: a2 07 60 40 add %i5, 0x40, %l1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
200e4d0: 92 10 00 1b mov %i3, %o1
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;
200e4d4: c0 26 e0 14 clr [ %i3 + 0x14 ]
bd->group = group;
200e4d8: f0 26 e0 28 st %i0, [ %i3 + 0x28 ]
200e4dc: 7f ff ed 20 call 200995c <_Chain_Append>
200e4e0: f2 26 e0 1c st %i1, [ %i3 + 0x1c ]
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
200e4e4: e0 07 60 20 ld [ %i5 + 0x20 ], %l0
200e4e8: 90 10 00 1a mov %i2, %o0
200e4ec: 92 10 00 10 mov %l0, %o1
200e4f0: 40 00 38 61 call 201c674 <.urem>
200e4f4: a0 04 3f ff add %l0, -1, %l0
200e4f8: 80 a2 00 10 cmp %o0, %l0
200e4fc: 22 80 00 02 be,a 200e504 <rtems_bdbuf_init+0x28c>
200e500: 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)
200e504: b4 06 a0 01 inc %i2
200e508: b6 06 e0 38 add %i3, 0x38, %i3
200e50c: b2 06 40 1c add %i1, %i4, %i1
/*
* 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,
200e510: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e514: 80 a6 80 01 cmp %i2, %g1
200e518: 0a bf ff ee bcs 200e4d0 <rtems_bdbuf_init+0x258>
200e51c: 90 10 00 11 mov %l1, %o0
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e520: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
group = bdbuf_cache.groups,
200e524: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
200e528: 85 28 e0 03 sll %g3, 3, %g2
group++;
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
200e52c: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
b < bdbuf_cache.group_count;
200e530: f8 07 60 7c ld [ %i5 + 0x7c ], %i4
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
200e534: bb 28 e0 06 sll %g3, 6, %i5
200e538: ba 27 40 02 sub %i5, %g2, %i5
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
200e53c: 10 80 00 06 b 200e554 <rtems_bdbuf_init+0x2dc>
200e540: 84 10 20 00 clr %g2
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e544: c6 20 60 08 st %g3, [ %g1 + 8 ]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
200e548: 84 00 a0 01 inc %g2
group++,
200e54c: 82 00 60 14 add %g1, 0x14, %g1
bd += bdbuf_cache.max_bds_per_group)
200e550: 88 01 00 1d add %g4, %i5, %g4
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
200e554: 80 a0 80 1c cmp %g2, %i4
200e558: 32 bf ff fb bne,a 200e544 <rtems_bdbuf_init+0x2cc>
200e55c: c8 20 60 10 st %g4, [ %g1 + 0x10 ]
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
200e560: 03 00 80 85 sethi %hi(0x2021400), %g1
200e564: 84 10 20 01 mov 1, %g2
200e568: c4 28 60 c8 stb %g2, [ %g1 + 0xc8 ]
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
bdbuf_config.swapout_priority ?
200e56c: 03 00 80 7a sethi %hi(0x201e800), %g1
200e570: d2 00 61 88 ld [ %g1 + 0x188 ], %o1 ! 201e988 <rtems_bdbuf_configuration+0x8>
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
200e574: 80 a2 60 00 cmp %o1, 0
200e578: 22 80 00 02 be,a 200e580 <rtems_bdbuf_init+0x308> <== NEVER TAKEN
200e57c: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
200e580: 11 10 94 d5 sethi %hi(0x42535400), %o0
200e584: 15 00 00 08 sethi %hi(0x2000), %o2
200e588: 90 12 23 50 or %o0, 0x350, %o0
200e58c: 96 10 24 00 mov 0x400, %o3
200e590: 98 10 20 00 clr %o4
200e594: 3b 00 80 85 sethi %hi(0x2021400), %i5
200e598: 7f ff ea 66 call 2008f30 <rtems_task_create>
200e59c: 9a 17 60 c4 or %i5, 0xc4, %o5 ! 20214c4 <bdbuf_cache>
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
200e5a0: 80 a2 20 00 cmp %o0, 0
200e5a4: 12 80 00 0f bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e5a8: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
sc = rtems_task_start (bdbuf_cache.swapout,
200e5ac: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
200e5b0: 13 00 80 36 sethi %hi(0x200d800), %o1
200e5b4: 94 17 60 c4 or %i5, 0xc4, %o2
200e5b8: 7f ff ea eb call 2009164 <rtems_task_start>
200e5bc: 92 12 61 1c or %o1, 0x11c, %o1
rtems_bdbuf_swapout_task,
(rtems_task_argument) &bdbuf_cache);
if (sc != RTEMS_SUCCESSFUL)
200e5c0: 80 a2 20 00 cmp %o0, 0
200e5c4: 12 80 00 07 bne 200e5e0 <rtems_bdbuf_init+0x368> <== NEVER TAKEN
200e5c8: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
rtems_bdbuf_unlock_cache ();
200e5cc: 7f ff f9 f2 call 200cd94 <rtems_bdbuf_unlock_cache>
200e5d0: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200e5d4: 81 c7 e0 08 ret
200e5d8: 81 e8 00 00 restore
error:
if (bdbuf_cache.swapout != 0)
200e5dc: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
200e5e0: d0 00 60 c4 ld [ %g1 + 0xc4 ], %o0 ! 20214c4 <bdbuf_cache><== NOT EXECUTED
200e5e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e5e8: 02 80 00 04 be 200e5f8 <rtems_bdbuf_init+0x380> <== NOT EXECUTED
200e5ec: 3b 00 80 85 sethi %hi(0x2021400), %i5 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
200e5f0: 7f ff ea 9b call 200905c <rtems_task_delete> <== NOT EXECUTED
200e5f4: 01 00 00 00 nop <== NOT EXECUTED
free (bdbuf_cache.buffers);
200e5f8: ba 17 60 c4 or %i5, 0xc4, %i5 <== NOT EXECUTED
200e5fc: 7f ff d8 f5 call 20049d0 <free> <== NOT EXECUTED
200e600: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
200e604: 7f ff d8 f3 call 20049d0 <free> <== NOT EXECUTED
200e608: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
200e60c: 7f ff d8 f1 call 20049d0 <free> <== NOT EXECUTED
200e610: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
200e614: 7f ff e9 a1 call 2008c98 <rtems_semaphore_delete> <== NOT EXECUTED
200e618: d0 07 60 78 ld [ %i5 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
200e61c: 7f ff e9 9f call 2008c98 <rtems_semaphore_delete> <== NOT EXECUTED
200e620: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
200e624: 7f ff e9 9d call 2008c98 <rtems_semaphore_delete> <== NOT EXECUTED
200e628: d0 07 60 70 ld [ %i5 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
200e62c: 7f ff e9 9b call 2008c98 <rtems_semaphore_delete> <== NOT EXECUTED
200e630: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
200e634: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
200e638: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e63c: 02 80 00 07 be 200e658 <rtems_bdbuf_init+0x3e0> <== NOT EXECUTED
200e640: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200e644: 7f ff f9 d4 call 200cd94 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e648: 01 00 00 00 nop <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
200e64c: 7f ff e9 93 call 2008c98 <rtems_semaphore_delete> <== NOT EXECUTED
200e650: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
200e654: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
200e658: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
200e65c: c0 28 61 48 clrb [ %g1 + 0x148 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
200e660: 81 c7 e0 08 ret <== NOT EXECUTED
200e664: 81 e8 00 00 restore <== NOT EXECUTED
0200cbbc <rtems_bdbuf_lock_cache>:
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
200cbbc: 9d e3 bf a0 save %sp, -96, %sp
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
200cbc0: 03 00 80 85 sethi %hi(0x2021400), %g1
200cbc4: d0 00 60 ec ld [ %g1 + 0xec ], %o0 ! 20214ec <bdbuf_cache+0x28>
200cbc8: 92 10 20 00 clr %o1
200cbcc: 7f ff f0 62 call 2008d54 <rtems_semaphore_obtain>
200cbd0: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200cbd4: 80 a2 20 00 cmp %o0, 0
200cbd8: 02 80 00 04 be 200cbe8 <rtems_bdbuf_lock_cache+0x2c> <== ALWAYS TAKEN
200cbdc: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (fatal_error_code);
200cbe0: 7f ff f2 09 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cbe4: 90 12 20 0d or %o0, 0xd, %o0 ! 4200000d <RAM_END+0x3fc0000d><== NOT EXECUTED
200cbe8: 81 c7 e0 08 ret
200cbec: 81 e8 00 00 restore
0200cbf0 <rtems_bdbuf_lock_sync>:
/**
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
200cbf0: 9d e3 bf a0 save %sp, -96, %sp
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
200cbf4: 03 00 80 85 sethi %hi(0x2021400), %g1
200cbf8: d0 00 60 f0 ld [ %g1 + 0xf0 ], %o0 ! 20214f0 <bdbuf_cache+0x2c>
200cbfc: 92 10 20 00 clr %o1
200cc00: 7f ff f0 55 call 2008d54 <rtems_semaphore_obtain>
200cc04: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200cc08: 80 a2 20 00 cmp %o0, 0
200cc0c: 02 80 00 04 be 200cc1c <rtems_bdbuf_lock_sync+0x2c> <== ALWAYS TAKEN
200cc10: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (fatal_error_code);
200cc14: 7f ff f1 fc call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cc18: 90 12 20 0b or %o0, 0xb, %o0 ! 4200000b <RAM_END+0x3fc0000b><== NOT EXECUTED
200cc1c: 81 c7 e0 08 ret
200cc20: 81 e8 00 00 restore
0200d06c <rtems_bdbuf_obtain_disk>:
static rtems_status_code
rtems_bdbuf_obtain_disk (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
200d06c: 9d e3 bf a0 save %sp, -96, %sp
if (!bdbuf_cache.initialised)
200d070: 03 00 80 85 sethi %hi(0x2021400), %g1
200d074: c2 08 61 48 ldub [ %g1 + 0x148 ], %g1 ! 2021548 <bdbuf_cache+0x84>
static rtems_status_code
rtems_bdbuf_obtain_disk (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
200d078: ba 10 00 18 mov %i0, %i5
200d07c: 92 10 00 19 mov %i1, %o1
if (!bdbuf_cache.initialised)
200d080: 80 a0 60 00 cmp %g1, 0
200d084: 02 80 00 2e be 200d13c <rtems_bdbuf_obtain_disk+0xd0> <== NEVER TAKEN
200d088: b0 10 20 16 mov 0x16, %i0
return RTEMS_NOT_CONFIGURED;
if (media_block_ptr != NULL)
200d08c: 80 a6 a0 00 cmp %i2, 0
200d090: 02 80 00 11 be 200d0d4 <rtems_bdbuf_obtain_disk+0x68>
200d094: 80 a6 e0 00 cmp %i3, 0
rtems_bdbuf_media_block (rtems_blkdev_bnum block,
size_t block_size,
size_t media_block_size)
{
return (rtems_blkdev_bnum)
((((uint64_t) block) * block_size) / media_block_size);
200d098: d6 07 60 20 ld [ %i5 + 0x20 ], %o3
200d09c: 94 10 20 00 clr %o2
200d0a0: 40 00 3e 21 call 201c924 <__muldi3>
200d0a4: 90 10 20 00 clr %o0
200d0a8: d6 07 60 24 ld [ %i5 + 0x24 ], %o3
200d0ac: 40 00 40 2a call 201d154 <__udivdi3>
200d0b0: 94 10 20 00 clr %o2
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
200d0b4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200d0b8: 80 a2 40 01 cmp %o1, %g1
200d0bc: 1a 80 00 20 bcc 200d13c <rtems_bdbuf_obtain_disk+0xd0> <== NEVER TAKEN
200d0c0: b0 10 20 0a mov 0xa, %i0
{
return RTEMS_INVALID_NUMBER;
}
*media_block_ptr = mb + dd->start;
200d0c4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200d0c8: 92 02 40 01 add %o1, %g1, %o1
200d0cc: d2 26 80 00 st %o1, [ %i2 ]
}
if (bds_per_group_ptr != NULL)
200d0d0: 80 a6 e0 00 cmp %i3, 0
200d0d4: 02 80 00 1a be 200d13c <rtems_bdbuf_obtain_disk+0xd0>
200d0d8: b0 10 20 00 clr %i0
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
200d0dc: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
200d0e0: 03 00 80 7a sethi %hi(0x201e800), %g1
200d0e4: 82 10 61 80 or %g1, 0x180, %g1 ! 201e980 <rtems_bdbuf_configuration>
200d0e8: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
200d0ec: 80 a2 00 02 cmp %o0, %g2
200d0f0: 18 80 00 13 bgu 200d13c <rtems_bdbuf_obtain_disk+0xd0> <== NEVER TAKEN
200d0f4: b0 10 20 0a mov 0xa, %i0
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
200d0f8: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
200d0fc: 40 00 3c b2 call 201c3c4 <.udiv>
200d100: 90 02 3f ff add %o0, -1, %o0
for (bds_per_size = 1;
200d104: 92 10 20 01 mov 1, %o1
200d108: 90 02 20 01 inc %o0
200d10c: 80 a2 40 08 cmp %o1, %o0
200d110: 2a bf ff ff bcs,a 200d10c <rtems_bdbuf_obtain_disk+0xa0>
200d114: 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;
200d118: 03 00 80 85 sethi %hi(0x2021400), %g1
200d11c: d0 00 60 e4 ld [ %g1 + 0xe4 ], %o0 ! 20214e4 <bdbuf_cache+0x20>
200d120: 40 00 3c a9 call 201c3c4 <.udiv>
200d124: b0 10 20 0a mov 0xa, %i0
if (bds_per_group_ptr != NULL)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
200d128: 80 a2 20 00 cmp %o0, 0
200d12c: 02 80 00 04 be 200d13c <rtems_bdbuf_obtain_disk+0xd0> <== NEVER TAKEN
200d130: 01 00 00 00 nop
{
return RTEMS_INVALID_NUMBER;
}
*bds_per_group_ptr = bds_per_group;
200d134: d0 26 c0 00 st %o0, [ %i3 ]
}
return RTEMS_SUCCESSFUL;
200d138: b0 10 20 00 clr %i0
}
200d13c: 81 c7 e0 08 ret
200d140: 81 e8 00 00 restore
0200ec6c <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (const rtems_disk_device *dd)
{
200ec6c: 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;
200ec70: 82 07 bf f8 add %fp, -8, %g1
200ec74: b4 07 bf f4 add %fp, -12, %i2
200ec78: c2 27 bf f4 st %g1, [ %fp + -12 ]
head->previous = NULL;
200ec7c: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
200ec80: f4 27 bf fc st %i2, [ %fp + -4 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
200ec84: 7f ff f7 ce call 200cbbc <rtems_bdbuf_lock_cache>
200ec88: 37 00 80 85 sethi %hi(0x2021400), %i3
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;
200ec8c: b6 16 e0 c4 or %i3, 0xc4, %i3 ! 20214c4 <bdbuf_cache>
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200ec90: 23 00 80 32 sethi %hi(0x200c800), %l1
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;
200ec94: fa 06 e0 3c ld [ %i3 + 0x3c ], %i5
*prev = NULL;
200ec98: c0 27 bf 74 clr [ %fp + -140 ]
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;
200ec9c: b8 07 bf 74 add %fp, -140, %i4
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200eca0: a2 14 63 90 or %l1, 0x390, %l1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eca4: a0 10 20 06 mov 6, %l0
200eca8: b2 10 20 0a mov 0xa, %i1
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);
200ecac: 10 80 00 37 b 200ed88 <rtems_bdbuf_purge_dev+0x11c>
200ecb0: b6 06 e0 6c add %i3, 0x6c, %i3
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
200ecb4: 80 a0 40 18 cmp %g1, %i0
200ecb8: 32 80 00 1e bne,a 200ed30 <rtems_bdbuf_purge_dev+0xc4> <== NEVER TAKEN
200ecbc: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
{
switch (cur->state)
200ecc0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200ecc4: 80 a0 60 0a cmp %g1, 0xa
200ecc8: 18 80 00 17 bgu 200ed24 <rtems_bdbuf_purge_dev+0xb8> <== NEVER TAKEN
200eccc: 11 10 80 00 sethi %hi(0x42000000), %o0
200ecd0: 83 28 60 02 sll %g1, 2, %g1
200ecd4: c2 04 40 01 ld [ %l1 + %g1 ], %g1
200ecd8: 81 c0 40 00 jmp %g1
200ecdc: 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);
200ece0: 7f ff f9 19 call 200d144 <rtems_bdbuf_wake>
200ece4: 90 10 00 1b mov %i3, %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200ece8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
200ecec: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200ecf0: 84 00 bf ff add %g2, -1, %g2
200ecf4: c4 20 60 0c st %g2, [ %g1 + 0xc ]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
200ecf8: 40 00 09 20 call 2011178 <_Chain_Extract>
200ecfc: 90 10 00 1d mov %i5, %o0
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
200ed00: 90 10 00 1a mov %i2, %o0
200ed04: 7f ff eb 16 call 200995c <_Chain_Append>
200ed08: 92 10 00 1d mov %i5, %o1
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
}
}
if (cur->avl.left != NULL)
200ed0c: 10 80 00 09 b 200ed30 <rtems_bdbuf_purge_dev+0xc4>
200ed10: c2 07 60 08 ld [ %i5 + 8 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ed14: 10 80 00 06 b 200ed2c <rtems_bdbuf_purge_dev+0xc0>
200ed18: f2 27 60 20 st %i1, [ %i5 + 0x20 ]
200ed1c: 10 80 00 04 b 200ed2c <rtems_bdbuf_purge_dev+0xc0>
200ed20: e0 27 60 20 st %l0, [ %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);
200ed24: 7f ff e9 b8 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200ed28: 90 12 20 01 or %o0, 1, %o0 <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
200ed2c: c2 07 60 08 ld [ %i5 + 8 ], %g1
200ed30: 80 a0 60 00 cmp %g1, 0
200ed34: 32 80 00 07 bne,a 200ed50 <rtems_bdbuf_purge_dev+0xe4>
200ed38: fa 27 20 04 st %i5, [ %i4 + 4 ]
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
200ed3c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200ed40: 80 a0 60 00 cmp %g1, 0
200ed44: 22 80 00 07 be,a 200ed60 <rtems_bdbuf_purge_dev+0xf4>
200ed48: c2 07 00 00 ld [ %i4 ], %g1
{
/* Right */
++prev;
*prev = cur;
200ed4c: fa 27 20 04 st %i5, [ %i4 + 4 ]
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
200ed50: 10 80 00 0d b 200ed84 <rtems_bdbuf_purge_dev+0x118>
200ed54: b8 07 20 04 add %i4, 4, %i4
{
while (*prev != NULL && cur == (*prev)->avl.right)
{
/* Up */
cur = *prev;
--prev;
200ed58: ba 10 00 01 mov %g1, %i5
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
200ed5c: c2 07 00 00 ld [ %i4 ], %g1
200ed60: 80 a0 60 00 cmp %g1, 0
200ed64: 22 80 00 09 be,a 200ed88 <rtems_bdbuf_purge_dev+0x11c>
200ed68: ba 10 00 01 mov %g1, %i5
200ed6c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200ed70: 80 a7 40 02 cmp %i5, %g2
200ed74: 22 bf ff f9 be,a 200ed58 <rtems_bdbuf_purge_dev+0xec>
200ed78: b8 07 3f fc add %i4, -4, %i4
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
200ed7c: 10 80 00 24 b 200ee0c <rtems_bdbuf_purge_dev+0x1a0>
200ed80: 82 10 00 02 mov %g2, %g1
}
if (cur->avl.left != NULL)
{
/* Left */
++prev;
200ed84: ba 10 00 01 mov %g1, %i5
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
200ed88: 80 a7 60 00 cmp %i5, 0
200ed8c: 32 bf ff ca bne,a 200ecb4 <rtems_bdbuf_purge_dev+0x48>
200ed90: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
200ed94: 39 00 80 85 sethi %hi(0x2021400), %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ed98: b6 10 20 01 mov 1, %i3
200ed9c: 10 80 00 0e b 200edd4 <rtems_bdbuf_purge_dev+0x168>
200eda0: b8 17 21 04 or %i4, 0x104, %i4
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
200eda4: 80 a0 60 00 cmp %g1, 0
200eda8: 22 80 00 02 be,a 200edb0 <rtems_bdbuf_purge_dev+0x144>
200edac: ba 10 20 01 mov 1, %i5
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
200edb0: 80 a0 60 00 cmp %g1, 0
200edb4: 12 80 00 08 bne 200edd4 <rtems_bdbuf_purge_dev+0x168>
200edb8: f6 26 a0 20 st %i3, [ %i2 + 0x20 ]
{
rtems_bdbuf_remove_from_tree (bd);
200edbc: 7f ff f9 23 call 200d248 <rtems_bdbuf_remove_from_tree>
200edc0: 90 10 00 1a mov %i2, %o0
200edc4: 90 10 00 1c mov %i4, %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200edc8: c0 26 a0 20 clr [ %i2 + 0x20 ]
200edcc: 40 00 08 f4 call 201119c <_Chain_Insert>
200edd0: 92 10 00 1a mov %i2, %o1
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
200edd4: 7f ff ea ed call 2009988 <_Chain_Get>
200edd8: 90 07 bf f4 add %fp, -12, %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 (purge_list)) != NULL)
200eddc: b4 92 20 00 orcc %o0, 0, %i2
200ede0: 32 bf ff f1 bne,a 200eda4 <rtems_bdbuf_purge_dev+0x138>
200ede4: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
200ede8: 80 8f 60 ff btst 0xff, %i5
200edec: 02 80 00 04 be 200edfc <rtems_bdbuf_purge_dev+0x190>
200edf0: 11 00 80 85 sethi %hi(0x2021400), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200edf4: 7f ff f8 d4 call 200d144 <rtems_bdbuf_wake>
200edf8: 90 12 21 38 or %o0, 0x138, %o0 ! 2021538 <bdbuf_cache+0x74>
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_gather_for_purge (&purge_list, dd);
rtems_bdbuf_purge_list (&purge_list);
rtems_bdbuf_unlock_cache ();
200edfc: 7f ff f7 e6 call 200cd94 <rtems_bdbuf_unlock_cache>
200ee00: 01 00 00 00 nop
}
200ee04: 81 c7 e0 08 ret
200ee08: 81 e8 00 00 restore
}
if (cur->avl.left != NULL)
{
/* Left */
++prev;
200ee0c: 10 bf ff df b 200ed88 <rtems_bdbuf_purge_dev+0x11c>
200ee10: ba 10 00 01 mov %g1, %i5
0200e70c <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e70c: 9d e3 bf 98 save %sp, -104, %sp
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dd, block, &media_block, &bds_per_group);
200e710: 90 10 00 18 mov %i0, %o0
rtems_status_code
rtems_bdbuf_read (const rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e714: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
200e718: c0 27 bf f8 clr [ %fp + -8 ]
size_t bds_per_group = 0;
200e71c: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_bdbuf_obtain_disk (dd, block, &media_block, &bds_per_group);
200e720: 92 10 00 19 mov %i1, %o1
200e724: 94 07 bf f8 add %fp, -8, %o2
200e728: 7f ff fa 51 call 200d06c <rtems_bdbuf_obtain_disk>
200e72c: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL)
200e730: b0 92 20 00 orcc %o0, 0, %i0
200e734: 12 80 00 7c bne 200e924 <rtems_bdbuf_read+0x218> <== NEVER TAKEN
200e738: 03 00 80 7a sethi %hi(0x201e800), %g1
/*
* 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) +
200e73c: f6 00 61 80 ld [ %g1 + 0x180 ], %i3 ! 201e980 <rtems_bdbuf_configuration>
200e740: b6 06 e0 01 inc %i3
200e744: 83 2e e0 04 sll %i3, 4, %g1
200e748: 82 00 60 20 add %g1, 0x20, %g1
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dd->dev);
rtems_bdbuf_lock_cache ();
200e74c: 7f ff f9 1c call 200cbbc <rtems_bdbuf_lock_cache>
200e750: 9c 23 80 01 sub %sp, %g1, %sp
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
200e754: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
200e758: e6 07 60 20 ld [ %i5 + 0x20 ], %l3
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dd->dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
200e75c: f2 07 bf f8 ld [ %fp + -8 ], %i1
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
200e760: 40 00 37 19 call 201c3c4 <.udiv>
200e764: 90 10 00 13 mov %l3, %o0
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
200e768: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e76c: e4 07 60 1c ld [ %i5 + 0x1c ], %l2
/*
* 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) +
200e770: b8 03 a0 60 add %sp, 0x60, %i4
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
200e774: a4 04 80 01 add %l2, %g1, %l2
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dd->dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
200e778: e8 07 bf fc ld [ %fp + -4 ], %l4
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
200e77c: a4 24 80 19 sub %l2, %i1, %l2
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
200e780: 80 a4 80 1b cmp %l2, %i3
200e784: 08 80 00 03 bleu 200e790 <rtems_bdbuf_read+0x84>
200e788: ae 10 00 08 mov %o0, %l7
200e78c: a4 10 00 1b mov %i3, %l2
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
200e790: 03 00 80 33 sethi %hi(0x200cc00), %g1
200e794: 82 10 62 1c or %g1, 0x21c, %g1 ! 200ce1c <rtems_bdbuf_transfer_done>
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
200e798: c0 27 00 00 clr [ %i4 ]
req->req_done = rtems_bdbuf_transfer_done;
200e79c: c2 27 20 04 st %g1, [ %i4 + 4 ]
req->done_arg = req;
req->io_task = rtems_task_self ();
200e7a0: 40 00 09 ac call 2010e50 <rtems_task_self>
200e7a4: f8 27 20 08 st %i4, [ %i4 + 8 ]
req->status = RTEMS_RESOURCE_IN_USE;
200e7a8: 82 10 20 0c mov 0xc, %g1
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
200e7ac: d0 27 20 14 st %o0, [ %i4 + 0x14 ]
req->status = RTEMS_RESOURCE_IN_USE;
200e7b0: c2 27 20 0c st %g1, [ %i4 + 0xc ]
req->bufnum = 0;
200e7b4: c0 27 20 10 clr [ %i4 + 0x10 ]
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block, bds_per_group);
200e7b8: 90 10 00 1d mov %i5, %o0
200e7bc: 92 10 00 19 mov %i1, %o1
200e7c0: 7f ff fe 30 call 200e080 <rtems_bdbuf_get_buffer_for_access>
200e7c4: 94 10 00 14 mov %l4, %o2
*bd_ptr = bd;
req->bufs [0].user = bd;
200e7c8: d0 27 20 24 st %o0, [ %i4 + 0x24 ]
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
200e7cc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block, bds_per_group);
200e7d0: b6 10 00 08 mov %o0, %i3
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
200e7d4: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block, bds_per_group);
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
200e7d8: f2 27 20 18 st %i1, [ %i4 + 0x18 ]
req->bufs [0].length = block_size;
200e7dc: e6 27 20 1c st %l3, [ %i4 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
200e7e0: 80 a2 20 02 cmp %o0, 2
200e7e4: 02 80 00 2e be 200e89c <rtems_bdbuf_read+0x190>
200e7e8: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200e7ec: 80 a2 20 07 cmp %o0, 7
200e7f0: 02 80 00 2b be 200e89c <rtems_bdbuf_read+0x190>
200e7f4: 13 10 80 00 sethi %hi(0x42000000), %o1
200e7f8: 80 a2 20 01 cmp %o0, 1
200e7fc: 12 80 00 46 bne 200e914 <rtems_bdbuf_read+0x208> <== NEVER TAKEN
200e800: 92 12 60 1d or %o1, 0x1d, %o1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e804: 82 10 20 09 mov 9, %g1
200e808: a0 10 00 1c mov %i4, %l0
200e80c: c2 26 e0 20 st %g1, [ %i3 + 0x20 ]
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
200e810: a2 10 20 01 mov 1, %l1
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e814: 2d 00 80 85 sethi %hi(0x2021400), %l6
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e818: 10 80 00 1d b 200e88c <rtems_bdbuf_read+0x180>
200e81c: aa 10 20 09 mov 9, %l5
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e820: d0 00 60 3c ld [ %g1 + 0x3c ], %o0
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
200e824: b2 06 40 17 add %i1, %l7, %i1
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e828: 92 10 00 1d mov %i5, %o1
200e82c: 7f ff f9 f7 call 200d008 <rtems_bdbuf_avl_search.isra.0>
200e830: 94 10 00 19 mov %i1, %o2
if (bd == NULL)
200e834: 80 a2 20 00 cmp %o0, 0
200e838: 32 80 00 19 bne,a 200e89c <rtems_bdbuf_read+0x190> <== NEVER TAKEN
200e83c: e2 27 20 10 st %l1, [ %i4 + 0x10 ] <== NOT EXECUTED
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block, bds_per_group);
200e840: 90 10 00 1d mov %i5, %o0
200e844: 92 10 00 19 mov %i1, %o1
200e848: 94 10 00 14 mov %l4, %o2
200e84c: 7f ff fd 27 call 200dce8 <rtems_bdbuf_get_buffer_from_lru_list>
200e850: a0 04 20 10 add %l0, 0x10, %l0
if (bd != NULL)
200e854: 80 a2 20 00 cmp %o0, 0
200e858: 22 80 00 11 be,a 200e89c <rtems_bdbuf_read+0x190> <== ALWAYS TAKEN
200e85c: e2 27 20 10 st %l1, [ %i4 + 0x10 ]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200e860: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
200e864: a2 04 60 01 inc %l1 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200e868: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
200e86c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
200e870: c4 20 60 0c st %g2, [ %g1 + 0xc ] <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e874: ea 22 20 20 st %l5, [ %o0 + 0x20 ] <== NOT EXECUTED
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
200e878: d0 24 20 24 st %o0, [ %l0 + 0x24 ] <== NOT EXECUTED
req->bufs [transfer_index].block = media_block;
200e87c: f2 24 20 18 st %i1, [ %l0 + 0x18 ] <== NOT EXECUTED
req->bufs [transfer_index].length = block_size;
200e880: e6 24 20 1c st %l3, [ %l0 + 0x1c ] <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
200e884: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
200e888: c2 24 20 20 st %g1, [ %l0 + 0x20 ] <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
200e88c: 80 a4 40 12 cmp %l1, %l2
200e890: 0a bf ff e4 bcs 200e820 <rtems_bdbuf_read+0x114>
200e894: 82 15 a0 c4 or %l6, 0xc4, %g1
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200e898: e2 27 20 10 st %l1, [ %i4 + 0x10 ]
media_block + dd->start, block, (unsigned) dd->dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
200e89c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
200e8a0: 80 a0 60 00 cmp %g1, 0
200e8a4: 22 80 00 10 be,a 200e8e4 <rtems_bdbuf_read+0x1d8>
200e8a8: d0 06 e0 20 ld [ %i3 + 0x20 ], %o0
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
200e8ac: 90 10 00 1d mov %i5, %o0
200e8b0: 92 10 00 1c mov %i4, %o1
200e8b4: 7f ff fb 68 call 200d654 <rtems_bdbuf_execute_transfer_request>
200e8b8: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
200e8bc: 80 a2 20 00 cmp %o0, 0
200e8c0: 32 80 00 1b bne,a 200e92c <rtems_bdbuf_read+0x220>
200e8c4: c0 26 80 00 clr [ %i2 ]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
200e8c8: 40 00 0a 2c call 2011178 <_Chain_Extract>
200e8cc: 90 10 00 1b mov %i3, %o0
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200e8d0: c2 06 e0 28 ld [ %i3 + 0x28 ], %g1
200e8d4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200e8d8: 84 00 a0 01 inc %g2
200e8dc: c4 20 60 0c st %g2, [ %g1 + 0xc ]
}
}
if (sc == RTEMS_SUCCESSFUL)
{
switch (bd->state)
200e8e0: d0 06 e0 20 ld [ %i3 + 0x20 ], %o0
200e8e4: 80 a2 20 02 cmp %o0, 2
200e8e8: 02 80 00 07 be 200e904 <rtems_bdbuf_read+0x1f8>
200e8ec: 13 10 80 00 sethi %hi(0x42000000), %o1
200e8f0: 80 a2 20 07 cmp %o0, 7
200e8f4: 12 80 00 08 bne 200e914 <rtems_bdbuf_read+0x208> <== NEVER TAKEN
200e8f8: 92 12 60 02 or %o1, 2, %o1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e8fc: 10 80 00 03 b 200e908 <rtems_bdbuf_read+0x1fc>
200e900: 82 10 20 04 mov 4, %g1
200e904: 82 10 20 03 mov 3, %g1
200e908: c2 26 e0 20 st %g1, [ %i3 + 0x20 ]
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
200e90c: 10 80 00 04 b 200e91c <rtems_bdbuf_read+0x210>
200e910: f6 26 80 00 st %i3, [ %i2 ]
break;
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
200e914: 7f ff f8 c4 call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200e918: 01 00 00 00 nop <== NOT EXECUTED
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
rtems_bdbuf_unlock_cache ();
200e91c: 7f ff f9 1e call 200cd94 <rtems_bdbuf_unlock_cache>
200e920: 01 00 00 00 nop
return sc;
}
200e924: 81 c7 e0 08 ret
200e928: 81 e8 00 00 restore
}
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
200e92c: 10 bf ff fc b 200e91c <rtems_bdbuf_read+0x210>
200e930: b0 10 00 08 mov %o0, %i0
0200e934 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
200e934: 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 (!bdbuf_cache.initialised)
200e938: 39 00 80 85 sethi %hi(0x2021400), %i4
200e93c: b8 17 20 c4 or %i4, 0xc4, %i4 ! 20214c4 <bdbuf_cache>
200e940: c2 0f 20 84 ldub [ %i4 + 0x84 ], %g1
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
200e944: ba 10 00 18 mov %i0, %i5
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
200e948: 80 a0 60 00 cmp %g1, 0
200e94c: 02 80 00 31 be 200ea10 <rtems_bdbuf_release+0xdc> <== NEVER TAKEN
200e950: b0 10 20 16 mov 0x16, %i0
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
200e954: 80 a7 60 00 cmp %i5, 0
200e958: 02 80 00 12 be 200e9a0 <rtems_bdbuf_release+0x6c> <== NEVER TAKEN
200e95c: 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();
200e960: 7f ff f8 97 call 200cbbc <rtems_bdbuf_lock_cache>
200e964: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200e968: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200e96c: 80 a2 20 04 cmp %o0, 4
200e970: 02 80 00 21 be 200e9f4 <rtems_bdbuf_release+0xc0>
200e974: 01 00 00 00 nop
200e978: 18 80 00 07 bgu 200e994 <rtems_bdbuf_release+0x60>
200e97c: 80 a2 20 06 cmp %o0, 6
200e980: 80 a2 20 03 cmp %o0, 3
200e984: 12 80 00 1f bne 200ea00 <rtems_bdbuf_release+0xcc> <== NEVER TAKEN
200e988: 13 10 80 00 sethi %hi(0x42000000), %o1
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200e98c: 10 80 00 07 b 200e9a8 <rtems_bdbuf_release+0x74>
200e990: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200e994: 18 80 00 1b bgu 200ea00 <rtems_bdbuf_release+0xcc> <== NEVER TAKEN
200e998: 13 10 80 00 sethi %hi(0x42000000), %o1
200e99c: 30 80 00 13 b,a 200e9e8 <rtems_bdbuf_release+0xb4>
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
200e9a0: 81 c7 e0 08 ret <== NOT EXECUTED
200e9a4: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
200e9a8: 90 07 20 40 add %i4, 0x40, %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200e9ac: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200e9b0: 92 10 00 1d mov %i5, %o1
200e9b4: 84 00 bf ff add %g2, -1, %g2
200e9b8: c4 20 60 0c st %g2, [ %g1 + 0xc ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e9bc: 82 10 20 02 mov 2, %g1
200e9c0: 7f ff eb e7 call 200995c <_Chain_Append>
200e9c4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
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)
200e9c8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e9cc: 80 a0 60 00 cmp %g1, 0
200e9d0: 12 80 00 03 bne 200e9dc <rtems_bdbuf_release+0xa8>
200e9d4: 90 07 20 64 add %i4, 0x64, %o0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200e9d8: 90 07 20 74 add %i4, 0x74, %o0
200e9dc: 7f ff f9 da call 200d144 <rtems_bdbuf_wake>
200e9e0: 01 00 00 00 nop
200e9e4: 30 80 00 09 b,a 200ea08 <rtems_bdbuf_release+0xd4>
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
200e9e8: 7f ff fb 00 call 200d5e8 <rtems_bdbuf_discard_buffer_after_access>
200e9ec: 90 10 00 1d mov %i5, %o0
break;
200e9f0: 30 80 00 06 b,a 200ea08 <rtems_bdbuf_release+0xd4>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
200e9f4: 7f ff f9 e2 call 200d17c <rtems_bdbuf_add_to_modified_list_after_access>
200e9f8: 90 10 00 1d mov %i5, %o0
break;
200e9fc: 30 80 00 03 b,a 200ea08 <rtems_bdbuf_release+0xd4>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
200ea00: 7f ff f8 89 call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ea04: 92 12 60 1c or %o1, 0x1c, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ea08: 7f ff f8 e3 call 200cd94 <rtems_bdbuf_unlock_cache>
200ea0c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
200ea10: 81 c7 e0 08 ret
200ea14: 81 e8 00 00 restore
0200ea18 <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
200ea18: 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 (!bdbuf_cache.initialised)
200ea1c: 03 00 80 85 sethi %hi(0x2021400), %g1
200ea20: c2 08 61 48 ldub [ %g1 + 0x148 ], %g1 ! 2021548 <bdbuf_cache+0x84>
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
200ea24: ba 10 00 18 mov %i0, %i5
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
200ea28: 80 a0 60 00 cmp %g1, 0
200ea2c: 02 80 00 1d be 200eaa0 <rtems_bdbuf_release_modified+0x88><== NEVER TAKEN
200ea30: b0 10 20 16 mov 0x16, %i0
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
200ea34: 80 a7 60 00 cmp %i5, 0
200ea38: 02 80 00 0e be 200ea70 <rtems_bdbuf_release_modified+0x58><== NEVER TAKEN
200ea3c: 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();
200ea40: 7f ff f8 5f call 200cbbc <rtems_bdbuf_lock_cache>
200ea44: 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)
200ea48: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200ea4c: 80 a2 20 03 cmp %o0, 3
200ea50: 0a 80 00 10 bcs 200ea90 <rtems_bdbuf_release_modified+0x78><== NEVER TAKEN
200ea54: 13 10 80 00 sethi %hi(0x42000000), %o1
200ea58: 80 a2 20 05 cmp %o0, 5
200ea5c: 08 80 00 07 bleu 200ea78 <rtems_bdbuf_release_modified+0x60>
200ea60: 80 a2 20 06 cmp %o0, 6
200ea64: 12 80 00 0b bne 200ea90 <rtems_bdbuf_release_modified+0x78><== NEVER TAKEN
200ea68: 01 00 00 00 nop
200ea6c: 30 80 00 06 b,a 200ea84 <rtems_bdbuf_release_modified+0x6c>
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
200ea70: 81 c7 e0 08 ret <== NOT EXECUTED
200ea74: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
200ea78: 7f ff f9 c1 call 200d17c <rtems_bdbuf_add_to_modified_list_after_access>
200ea7c: 90 10 00 1d mov %i5, %o0
break;
200ea80: 30 80 00 06 b,a 200ea98 <rtems_bdbuf_release_modified+0x80>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
200ea84: 7f ff fa d9 call 200d5e8 <rtems_bdbuf_discard_buffer_after_access>
200ea88: 90 10 00 1d mov %i5, %o0
break;
200ea8c: 30 80 00 03 b,a 200ea98 <rtems_bdbuf_release_modified+0x80>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
200ea90: 7f ff f8 65 call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ea94: 92 12 60 04 or %o1, 4, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ea98: 7f ff f8 bf call 200cd94 <rtems_bdbuf_unlock_cache>
200ea9c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
200eaa0: 81 c7 e0 08 ret
200eaa4: 81 e8 00 00 restore
0200d248 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
200d248: 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;
200d24c: 03 00 80 85 sethi %hi(0x2021400), %g1
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
200d250: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
rtems_blkdev_bnum block = node->block;
200d254: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
rtems_bdbuf_buffer* p = *root;
200d258: fa 00 61 00 ld [ %g1 + 0x100 ], %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));
200d25c: 90 07 bf 80 add %fp, -128, %o0
200d260: 92 10 20 00 clr %o1
200d264: 40 00 1b 44 call 2013f74 <memset>
200d268: 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;
200d26c: 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;
200d270: 9e 10 20 01 mov 1, %o7
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200d274: 10 80 00 15 b 200d2c8 <rtems_bdbuf_remove_from_tree+0x80>
200d278: 84 10 3f ff mov -1, %g2
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200d27c: fa 20 c0 00 st %i5, [ %g3 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d280: 80 a0 40 1b cmp %g1, %i3
200d284: 0a 80 00 09 bcs 200d2a8 <rtems_bdbuf_remove_from_tree+0x60><== NEVER TAKEN
200d288: 88 00 e0 04 add %g3, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
200d28c: 80 a0 40 1b cmp %g1, %i3
200d290: 32 80 00 0c bne,a 200d2c0 <rtems_bdbuf_remove_from_tree+0x78><== NEVER TAKEN
200d294: c4 2f 60 10 stb %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
200d298: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200d29c: 80 a0 40 1c cmp %g1, %i4
200d2a0: 1a 80 00 05 bcc 200d2b4 <rtems_bdbuf_remove_from_tree+0x6c>
200d2a4: 01 00 00 00 nop
{
p->avl.cache = 1;
200d2a8: de 2f 60 10 stb %o7, [ %i5 + 0x10 ]
p = p->avl.right;
200d2ac: 10 80 00 06 b 200d2c4 <rtems_bdbuf_remove_from_tree+0x7c>
200d2b0: fa 07 60 0c ld [ %i5 + 0xc ], %i5
}
else if ((p->dd != dd) || (p->block != block))
200d2b4: 02 80 00 0a be 200d2dc <rtems_bdbuf_remove_from_tree+0x94>
200d2b8: 82 07 bf 80 add %fp, -128, %g1
{
p->avl.cache = -1;
200d2bc: c4 2f 60 10 stb %g2, [ %i5 + 0x10 ]
p = p->avl.left;
200d2c0: fa 07 60 08 ld [ %i5 + 8 ], %i5
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200d2c4: 86 10 00 04 mov %g4, %g3
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
200d2c8: 80 a7 60 00 cmp %i5, 0
200d2cc: 32 bf ff ec bne,a 200d27c <rtems_bdbuf_remove_from_tree+0x34><== ALWAYS TAKEN
200d2d0: 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);
200d2d4: 10 80 00 b3 b 200d5a0 <rtems_bdbuf_remove_from_tree+0x358><== NOT EXECUTED
200d2d8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
200d2dc: 80 a0 c0 01 cmp %g3, %g1
200d2e0: 08 80 00 03 bleu 200d2ec <rtems_bdbuf_remove_from_tree+0xa4>
200d2e4: b8 10 20 00 clr %i4
{
p = *(buf_prev - 1);
200d2e8: f8 01 3f f8 ld [ %g4 + -8 ], %i4
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
200d2ec: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200d2f0: 80 a0 60 00 cmp %g1, 0
200d2f4: 32 80 00 08 bne,a 200d314 <rtems_bdbuf_remove_from_tree+0xcc>
200d2f8: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
r = q->avl.left;
200d2fc: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (r != NULL)
200d300: 80 a0 60 00 cmp %g1, 0
200d304: 32 80 00 27 bne,a 200d3a0 <rtems_bdbuf_remove_from_tree+0x158>
200d308: c0 28 60 11 clrb [ %g1 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
200d30c: 10 80 00 26 b 200d3a4 <rtems_bdbuf_remove_from_tree+0x15c>
200d310: 80 a7 20 00 cmp %i4, 0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
200d314: 80 a0 a0 00 cmp %g2, 0
200d318: 02 80 00 06 be 200d330 <rtems_bdbuf_remove_from_tree+0xe8>
200d31c: 84 10 00 01 mov %g1, %g2
200d320: b6 10 00 01 mov %g1, %i3
200d324: 86 10 00 04 mov %g4, %g3
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
200d328: 10 80 00 0f b 200d364 <rtems_bdbuf_remove_from_tree+0x11c>
200d32c: 9e 10 3f ff mov -1, %o7
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200d330: c4 07 60 08 ld [ %i5 + 8 ], %g2
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
200d334: c2 21 3f fc st %g1, [ %g4 + -4 ]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200d338: c4 20 60 08 st %g2, [ %g1 + 8 ]
r->avl.bal = q->avl.bal;
200d33c: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r->avl.cache = 1;
*buf_prev++ = q = r;
200d340: 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;
200d344: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
r->avl.cache = 1;
200d348: 84 10 20 01 mov 1, %g2
200d34c: 10 80 00 15 b 200d3a0 <rtems_bdbuf_remove_from_tree+0x158>
200d350: 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;
200d354: de 28 a0 10 stb %o7, [ %g2 + 0x10 ]
200d358: b6 10 00 02 mov %g2, %i3
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
200d35c: 86 00 e0 04 add %g3, 4, %g3
s = r->avl.left;
r->avl.cache = -1;
200d360: 84 10 00 18 mov %i0, %g2
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
200d364: f0 00 a0 08 ld [ %g2 + 8 ], %i0
200d368: 80 a6 20 00 cmp %i0, 0
200d36c: 32 bf ff fa bne,a 200d354 <rtems_bdbuf_remove_from_tree+0x10c>
200d370: 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;
200d374: f0 07 60 08 ld [ %i5 + 8 ], %i0
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;
200d378: 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;
200d37c: f0 20 a0 08 st %i0, [ %g2 + 8 ]
r->avl.left = s->avl.right;
200d380: f0 00 a0 0c ld [ %g2 + 0xc ], %i0
s->avl.right = q->avl.right;
200d384: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
s->avl.bal = q->avl.bal;
200d388: 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;
200d38c: f0 26 e0 08 st %i0, [ %i3 + 8 ]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
200d390: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
s->avl.cache = 1;
200d394: 82 10 20 01 mov 1, %g1
200d398: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*t = q = s;
200d39c: 82 10 00 02 mov %g2, %g1
}
}
if (p != NULL)
200d3a0: 80 a7 20 00 cmp %i4, 0
200d3a4: 02 80 00 0d be 200d3d8 <rtems_bdbuf_remove_from_tree+0x190>
200d3a8: 05 00 80 85 sethi %hi(0x2021400), %g2
{
if (p->avl.cache == -1)
200d3ac: c4 4f 20 10 ldsb [ %i4 + 0x10 ], %g2
200d3b0: 80 a0 bf ff cmp %g2, -1
200d3b4: 32 80 00 03 bne,a 200d3c0 <rtems_bdbuf_remove_from_tree+0x178>
200d3b8: c2 27 20 0c st %g1, [ %i4 + 0xc ]
{
p->avl.left = q;
200d3bc: c2 27 20 08 st %g1, [ %i4 + 8 ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
200d3c0: 82 07 bf 80 add %fp, -128, %g1
200d3c4: 80 a0 c0 01 cmp %g3, %g1
200d3c8: 18 80 00 06 bgu 200d3e0 <rtems_bdbuf_remove_from_tree+0x198>
200d3cc: ba 10 20 01 mov 1, %i5
200d3d0: 81 c7 e0 08 ret
200d3d4: 81 e8 00 00 restore
p->avl.right = q;
}
}
else
{
*root = q;
200d3d8: 10 bf ff fa b 200d3c0 <rtems_bdbuf_remove_from_tree+0x178>
200d3dc: c2 20 a1 00 st %g1, [ %g2 + 0x100 ]
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
200d3e0: 9e 10 3f ff mov -1, %o7
default:
break;
}
}
if (buf_prev > buf_stack)
200d3e4: b0 10 00 01 mov %g1, %i0
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
200d3e8: c2 00 ff fc ld [ %g3 + -4 ], %g1
else
{
break;
}
if (p->avl.cache == -1)
200d3ec: f8 48 60 10 ldsb [ %g1 + 0x10 ], %i4
200d3f0: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
200d3f4: 80 a7 3f ff cmp %i4, -1
{
/* rebalance left branch */
switch (p->avl.bal)
200d3f8: 85 28 a0 18 sll %g2, 0x18, %g2
else
{
break;
}
if (p->avl.cache == -1)
200d3fc: 12 80 00 29 bne 200d4a0 <rtems_bdbuf_remove_from_tree+0x258>
200d400: 85 38 a0 18 sra %g2, 0x18, %g2
{
/* rebalance left branch */
switch (p->avl.bal)
200d404: 80 a0 a0 00 cmp %g2, 0
200d408: 22 80 00 14 be,a 200d458 <rtems_bdbuf_remove_from_tree+0x210>
200d40c: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
200d410: 80 a0 a0 01 cmp %g2, 1
200d414: 02 80 00 06 be 200d42c <rtems_bdbuf_remove_from_tree+0x1e4>
200d418: 80 a0 bf ff cmp %g2, -1
200d41c: 12 80 00 4e bne 200d554 <rtems_bdbuf_remove_from_tree+0x30c><== NEVER TAKEN
200d420: 84 10 20 01 mov 1, %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200d424: 10 80 00 4c b 200d554 <rtems_bdbuf_remove_from_tree+0x30c>
200d428: c0 28 60 11 clrb [ %g1 + 0x11 ]
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
200d42c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
if (p1->avl.bal >= 0) /* simple RR-turn */
200d430: f6 48 a0 11 ldsb [ %g2 + 0x11 ], %i3
200d434: 80 a6 e0 00 cmp %i3, 0
200d438: 06 80 00 0a bl 200d460 <rtems_bdbuf_remove_from_tree+0x218>
200d43c: c8 00 a0 08 ld [ %g2 + 8 ], %g4
{
p->avl.right = p1->avl.left;
200d440: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
if (p1->avl.bal == 0)
200d444: 80 a6 e0 00 cmp %i3, 0
200d448: 12 80 00 2c bne 200d4f8 <rtems_bdbuf_remove_from_tree+0x2b0>
200d44c: c2 20 a0 08 st %g1, [ %g2 + 8 ]
{
p1->avl.bal = -1;
200d450: f8 28 a0 11 stb %i4, [ %g2 + 0x11 ]
200d454: 82 10 00 02 mov %g2, %g1
modified = false;
200d458: 10 80 00 3f b 200d554 <rtems_bdbuf_remove_from_tree+0x30c>
200d45c: 84 10 20 00 clr %g2
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d460: f8 01 20 0c ld [ %g4 + 0xc ], %i4
p2->avl.right = p1;
200d464: c4 21 20 0c st %g2, [ %g4 + 0xc ]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d468: f8 20 a0 08 st %i4, [ %g2 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d46c: f8 01 20 08 ld [ %g4 + 8 ], %i4
p2->avl.left = p;
200d470: 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;
200d474: f8 20 60 0c st %i4, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200d478: f8 49 20 11 ldsb [ %g4 + 0x11 ], %i4
200d47c: b8 1f 20 01 xor %i4, 1, %i4
200d480: 80 a0 00 1c cmp %g0, %i4
200d484: b8 40 3f ff addx %g0, -1, %i4
200d488: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
200d48c: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d490: 82 38 00 01 xnor %g0, %g1, %g1
200d494: 80 a0 00 01 cmp %g0, %g1
200d498: 10 80 00 2b b 200d544 <rtems_bdbuf_remove_from_tree+0x2fc>
200d49c: 82 60 3f ff subx %g0, -1, %g1
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d4a0: 80 a0 a0 00 cmp %g2, 0
200d4a4: 22 bf ff ed be,a 200d458 <rtems_bdbuf_remove_from_tree+0x210>
200d4a8: de 28 60 11 stb %o7, [ %g1 + 0x11 ]
200d4ac: 80 a0 a0 01 cmp %g2, 1
200d4b0: 02 80 00 06 be 200d4c8 <rtems_bdbuf_remove_from_tree+0x280>
200d4b4: 80 a0 bf ff cmp %g2, -1
200d4b8: 32 80 00 27 bne,a 200d554 <rtems_bdbuf_remove_from_tree+0x30c><== NEVER TAKEN
200d4bc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
200d4c0: 10 80 00 04 b 200d4d0 <rtems_bdbuf_remove_from_tree+0x288>
200d4c4: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200d4c8: 10 80 00 22 b 200d550 <rtems_bdbuf_remove_from_tree+0x308>
200d4cc: c0 28 60 11 clrb [ %g1 + 0x11 ]
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
200d4d0: f8 48 a0 11 ldsb [ %g2 + 0x11 ], %i4
200d4d4: 80 a7 20 00 cmp %i4, 0
200d4d8: 14 80 00 0c bg 200d508 <rtems_bdbuf_remove_from_tree+0x2c0>
200d4dc: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
200d4e0: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
if (p1->avl.bal == 0)
200d4e4: 80 a7 20 00 cmp %i4, 0
200d4e8: 12 80 00 04 bne 200d4f8 <rtems_bdbuf_remove_from_tree+0x2b0><== NEVER TAKEN
200d4ec: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
p1->avl.bal = 1;
200d4f0: 10 bf ff d9 b 200d454 <rtems_bdbuf_remove_from_tree+0x20c>
200d4f4: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
modified = false;
}
else
{
p->avl.bal = 0;
200d4f8: c0 28 60 11 clrb [ %g1 + 0x11 ]
p1->avl.bal = 0;
200d4fc: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d500: 10 80 00 14 b 200d550 <rtems_bdbuf_remove_from_tree+0x308>
200d504: 82 10 00 02 mov %g2, %g1
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d508: f8 01 20 08 ld [ %g4 + 8 ], %i4
p2->avl.left = p1;
200d50c: c4 21 20 08 st %g2, [ %g4 + 8 ]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d510: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d514: f8 01 20 0c ld [ %g4 + 0xc ], %i4
p2->avl.right = p;
200d518: 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;
200d51c: 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;
200d520: f8 49 20 11 ldsb [ %g4 + 0x11 ], %i4
200d524: b8 38 00 1c xnor %g0, %i4, %i4
200d528: 80 a0 00 1c cmp %g0, %i4
200d52c: b8 60 3f ff subx %g0, -1, %i4
200d530: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200d534: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d538: 82 18 60 01 xor %g1, 1, %g1
200d53c: 80 a0 00 01 cmp %g0, %g1
200d540: 82 40 3f ff addx %g0, -1, %g1
200d544: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
p = p2;
p2->avl.bal = 0;
200d548: c0 29 20 11 clrb [ %g4 + 0x11 ]
200d54c: 82 10 00 04 mov %g4, %g1
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d550: 84 10 20 01 mov 1, %g2
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
200d554: 88 00 ff fc add %g3, -4, %g4
default:
break;
}
}
if (buf_prev > buf_stack)
200d558: 80 a1 00 18 cmp %g4, %i0
200d55c: 28 80 00 09 bleu,a 200d580 <rtems_bdbuf_remove_from_tree+0x338>
200d560: 05 00 80 85 sethi %hi(0x2021400), %g2
{
q = *(buf_prev - 1);
200d564: c8 00 ff f8 ld [ %g3 + -8 ], %g4
if (q->avl.cache == -1)
200d568: f8 49 20 10 ldsb [ %g4 + 0x10 ], %i4
200d56c: 80 a7 3f ff cmp %i4, -1
200d570: 32 80 00 07 bne,a 200d58c <rtems_bdbuf_remove_from_tree+0x344>
200d574: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
q->avl.left = p;
200d578: 10 80 00 05 b 200d58c <rtems_bdbuf_remove_from_tree+0x344>
200d57c: c2 21 20 08 st %g1, [ %g4 + 8 ]
q->avl.right = p;
}
}
else
{
*root = p;
200d580: c2 20 a1 00 st %g1, [ %g2 + 0x100 ]
200d584: 81 c7 e0 08 ret
200d588: 81 e8 00 00 restore
*root = q;
}
modified = true;
while (modified)
200d58c: 80 88 a0 ff btst 0xff, %g2
200d590: 12 bf ff 96 bne 200d3e8 <rtems_bdbuf_remove_from_tree+0x1a0>
200d594: 86 00 ff fc add %g3, -4, %g3
200d598: 81 c7 e0 08 ret
200d59c: 81 e8 00 00 restore
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);
200d5a0: 13 10 80 00 sethi %hi(0x42000000), %o1 <== NOT EXECUTED
200d5a4: 7f ff fd a0 call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d5a8: 92 12 60 09 or %o1, 9, %o1 ! 42000009 <RAM_END+0x3fc00009><== NOT EXECUTED
0200d5b0 <rtems_bdbuf_remove_from_tree_and_lru_list>:
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
200d5b0: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
200d5b4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200d5b8: 80 a2 20 00 cmp %o0, 0
200d5bc: 02 80 00 09 be 200d5e0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
200d5c0: 80 a2 20 02 cmp %o0, 2
200d5c4: 12 80 00 05 bne 200d5d8 <rtems_bdbuf_remove_from_tree_and_lru_list+0x28><== NEVER TAKEN
200d5c8: 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);
200d5cc: 7f ff ff 1f call 200d248 <rtems_bdbuf_remove_from_tree>
200d5d0: 90 10 00 18 mov %i0, %o0
break;
200d5d4: 30 80 00 03 b,a 200d5e0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
200d5d8: 7f ff fd 93 call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d5dc: 92 12 60 08 or %o1, 8, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
200d5e0: 40 00 0e e6 call 2011178 <_Chain_Extract>
200d5e4: 81 e8 00 00 restore
0200ceb4 <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200ceb4: 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);
200ceb8: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200cebc: 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);
200cec0: 90 10 00 18 mov %i0, %o0
200cec4: 92 12 63 ff or %o1, 0x3ff, %o1
200cec8: 40 00 0f 84 call 2010cd8 <rtems_task_mode>
200cecc: 94 07 a0 44 add %fp, 0x44, %o2
if (sc != RTEMS_SUCCESSFUL)
200ced0: 80 a2 20 00 cmp %o0, 0
200ced4: 02 80 00 04 be 200cee4 <rtems_bdbuf_restore_preemption+0x30><== ALWAYS TAKEN
200ced8: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
200cedc: 7f ff f1 4a call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cee0: 90 12 20 11 or %o0, 0x11, %o0 ! 42000011 <RAM_END+0x3fc00011><== NOT EXECUTED
200cee4: 81 c7 e0 08 ret
200cee8: 81 e8 00 00 restore
0200cc38 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
200cc38: 9d e3 bf 98 save %sp, -104, %sp
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200cc3c: d2 06 40 00 ld [ %i1 ], %o1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200cc40: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
200cc44: 80 a2 40 19 cmp %o1, %i1
200cc48: 02 80 00 4d be 200cd7c <rtems_bdbuf_swapout_modified_processing+0x144>
200cc4c: 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))
200cc50: 02 80 00 05 be 200cc64 <rtems_bdbuf_swapout_modified_processing+0x2c>
200cc54: a6 10 20 00 clr %l3
* @param update_timers If true update the timers.
* @param timer_delta It update_timers is true update the timers by this
* amount.
*/
static void
rtems_bdbuf_swapout_modified_processing (const rtems_disk_device **dd_ptr,
200cc58: c2 06 00 00 ld [ %i0 ], %g1
200cc5c: 80 a0 00 01 cmp %g0, %g1
200cc60: a6 60 3f ff subx %g0, -1, %l3
* 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))
200cc64: a6 0c e0 ff and %l3, 0xff, %l3
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
200cc68: 25 00 80 85 sethi %hi(0x2021400), %l2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200cc6c: a2 10 20 09 mov 9, %l1
* 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))
200cc70: 80 a4 e0 00 cmp %l3, 0
200cc74: 32 80 00 0f bne,a 200ccb0 <rtems_bdbuf_swapout_modified_processing+0x78>
200cc78: c0 22 60 2c clr [ %o1 + 0x2c ]
200cc7c: 80 a6 e0 00 cmp %i3, 0
200cc80: 02 80 00 07 be 200cc9c <rtems_bdbuf_swapout_modified_processing+0x64>
200cc84: 82 14 a0 c4 or %l2, 0xc4, %g1
200cc88: c4 06 00 00 ld [ %i0 ], %g2
200cc8c: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
200cc90: 80 a0 80 01 cmp %g2, %g1
200cc94: 02 80 00 06 be 200ccac <rtems_bdbuf_swapout_modified_processing+0x74>
200cc98: 82 14 a0 c4 or %l2, 0xc4, %g1
|| rtems_bdbuf_has_buffer_waiters ())
200cc9c: c2 00 60 74 ld [ %g1 + 0x74 ], %g1
200cca0: 80 a0 60 00 cmp %g1, 0
200cca4: 22 80 00 04 be,a 200ccb4 <rtems_bdbuf_swapout_modified_processing+0x7c>
200cca8: c2 02 60 2c ld [ %o1 + 0x2c ], %g1
bd->hold_timer = 0;
200ccac: c0 22 60 2c clr [ %o1 + 0x2c ]
if (bd->hold_timer)
200ccb0: c2 02 60 2c ld [ %o1 + 0x2c ], %g1
200ccb4: 80 a0 60 00 cmp %g1, 0
200ccb8: 22 80 00 10 be,a 200ccf8 <rtems_bdbuf_swapout_modified_processing+0xc0>
200ccbc: c2 06 00 00 ld [ %i0 ], %g1
{
if (update_timers)
200ccc0: 80 a7 20 00 cmp %i4, 0
200ccc4: 22 80 00 08 be,a 200cce4 <rtems_bdbuf_swapout_modified_processing+0xac>
200ccc8: c2 02 60 2c ld [ %o1 + 0x2c ], %g1
{
if (bd->hold_timer > timer_delta)
200cccc: 80 a0 40 1d cmp %g1, %i5
200ccd0: 28 80 00 04 bleu,a 200cce0 <rtems_bdbuf_swapout_modified_processing+0xa8>
200ccd4: c0 22 60 2c clr [ %o1 + 0x2c ]
bd->hold_timer -= timer_delta;
200ccd8: 82 20 40 1d sub %g1, %i5, %g1
200ccdc: c2 22 60 2c st %g1, [ %o1 + 0x2c ]
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
200cce0: c2 02 60 2c ld [ %o1 + 0x2c ], %g1
200cce4: 80 a0 60 00 cmp %g1, 0
200cce8: 22 80 00 04 be,a 200ccf8 <rtems_bdbuf_swapout_modified_processing+0xc0>
200ccec: c2 06 00 00 ld [ %i0 ], %g1
{
node = node->next;
continue;
200ccf0: 10 80 00 20 b 200cd70 <rtems_bdbuf_swapout_modified_processing+0x138>
200ccf4: d2 02 40 00 ld [ %o1 ], %o1
/*
* 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)
200ccf8: 80 a0 60 00 cmp %g1, 0
200ccfc: 32 80 00 05 bne,a 200cd10 <rtems_bdbuf_swapout_modified_processing+0xd8>
200cd00: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
*dd_ptr = bd->dd;
200cd04: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
200cd08: c2 26 00 00 st %g1, [ %i0 ]
if (bd->dd == *dd_ptr)
200cd0c: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
200cd10: c2 06 00 00 ld [ %i0 ], %g1
200cd14: 80 a0 80 01 cmp %g2, %g1
200cd18: 12 80 00 15 bne 200cd6c <rtems_bdbuf_swapout_modified_processing+0x134><== NEVER TAKEN
200cd1c: e0 02 40 00 ld [ %o1 ], %l0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200cd20: e2 22 60 20 st %l1, [ %o1 + 0x20 ]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
200cd24: 90 10 00 09 mov %o1, %o0
200cd28: 40 00 11 14 call 2011178 <_Chain_Extract>
200cd2c: d2 27 bf fc st %o1, [ %fp + -4 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract (node);
tnode = tnode->previous;
200cd30: d0 06 a0 08 ld [ %i2 + 8 ], %o0
while (node && !rtems_chain_is_head (transfer, tnode))
200cd34: 10 80 00 07 b 200cd50 <rtems_bdbuf_swapout_modified_processing+0x118>
200cd38: d2 07 bf fc ld [ %fp + -4 ], %o1
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
200cd3c: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
200cd40: 80 a0 80 01 cmp %g2, %g1
200cd44: 18 80 00 10 bgu 200cd84 <rtems_bdbuf_swapout_modified_processing+0x14c>
200cd48: 01 00 00 00 nop
{
rtems_chain_insert (tnode, node);
node = NULL;
}
else
tnode = tnode->previous;
200cd4c: d0 02 20 04 ld [ %o0 + 4 ], %o0
rtems_chain_extract (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
200cd50: 80 a2 60 00 cmp %o1, 0
200cd54: 02 80 00 06 be 200cd6c <rtems_bdbuf_swapout_modified_processing+0x134><== NEVER TAKEN
200cd58: 80 a2 00 1a cmp %o0, %i2
200cd5c: 32 bf ff f8 bne,a 200cd3c <rtems_bdbuf_swapout_modified_processing+0x104>
200cd60: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
200cd64: 10 80 00 08 b 200cd84 <rtems_bdbuf_swapout_modified_processing+0x14c>
200cd68: 90 10 00 1a mov %i2, %o0
}
if (node)
rtems_chain_prepend (transfer, node);
node = next_node;
200cd6c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
200cd70: 80 a2 40 19 cmp %o1, %i1
200cd74: 12 bf ff c0 bne 200cc74 <rtems_bdbuf_swapout_modified_processing+0x3c>
200cd78: 80 a4 e0 00 cmp %l3, 0
200cd7c: 81 c7 e0 08 ret
200cd80: 81 e8 00 00 restore
200cd84: 40 00 11 06 call 201119c <_Chain_Insert>
200cd88: 01 00 00 00 nop
}
if (node)
rtems_chain_prepend (transfer, node);
node = next_node;
200cd8c: 10 bf ff f9 b 200cd70 <rtems_bdbuf_swapout_modified_processing+0x138>
200cd90: 92 10 00 10 mov %l0, %o1
0200d91c <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
200d91c: 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;;
200d920: 35 00 80 7a sethi %hi(0x201e800), %i2
200d924: b4 16 a1 80 or %i2, 0x180, %i2 ! 201e980 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200d928: 7f ff fd a3 call 200cfb4 <rtems_bdbuf_swapout_writereq_alloc>
200d92c: f6 06 a0 0c ld [ %i2 + 0xc ], %i3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200d930: 82 07 bf e4 add %fp, -28, %g1
200d934: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
200d938: 82 07 bf e0 add %fp, -32, %g1
200d93c: c2 27 bf e8 st %g1, [ %fp + -24 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200d940: 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 ();
200d944: d0 27 bf f4 st %o0, [ %fp + -12 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200d948: 91 2e e0 07 sll %i3, 7, %o0
200d94c: 90 22 00 01 sub %o0, %g1, %o0
200d950: 03 00 80 82 sethi %hi(0x2020800), %g1
200d954: d2 00 62 cc ld [ %g1 + 0x2cc ], %o1 ! 2020acc <Configuration+0x10>
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200d958: c0 27 bf e4 clr [ %fp + -28 ]
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;
200d95c: c0 27 bf ec clr [ %fp + -20 ]
transfer.syncing = false;
200d960: c0 2f bf f0 clrb [ %fp + -16 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200d964: 90 02 00 1b add %o0, %i3, %o0
200d968: 40 00 3a 97 call 201c3c4 <.udiv>
200d96c: 91 2a 20 03 sll %o0, 3, %o0
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
200d970: 25 00 80 85 sethi %hi(0x2021400), %l2
200d974: a2 10 00 08 mov %o0, %l1
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
200d978: 7f ff fc 91 call 200cbbc <rtems_bdbuf_lock_cache>
200d97c: 31 10 91 1b sethi %hi(0x42446c00), %i0
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
200d980: 33 00 80 37 sethi %hi(0x200dc00), %i1
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200d984: b8 10 20 00 clr %i4
200d988: e6 06 a0 14 ld [ %i2 + 0x14 ], %l3
200d98c: a4 14 a0 cc or %l2, 0xcc, %l2
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
200d990: a0 10 20 01 mov 1, %l0
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
200d994: b0 16 23 00 or %i0, 0x300, %i0
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
200d998: 10 80 00 30 b 200da58 <rtems_bdbuf_swapout_task+0x13c>
200d99c: b2 16 60 68 or %i1, 0x68, %i1
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
200d9a0: 7f ff dd 84 call 2004fb0 <malloc> <== NOT EXECUTED
200d9a4: 90 10 20 2c mov 0x2c, %o0 <== NOT EXECUTED
if (!worker)
200d9a8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
200d9ac: 12 80 00 05 bne 200d9c0 <rtems_bdbuf_swapout_task+0xa4> <== NOT EXECUTED
200d9b0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
200d9b4: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200d9b8: 10 80 00 1d b 200da2c <rtems_bdbuf_swapout_task+0x110> <== NOT EXECUTED
200d9bc: 90 12 20 15 or %o0, 0x15, %o0 ! 42000015 <RAM_END+0x3fc00015><== NOT EXECUTED
200d9c0: 7f ff ef e7 call 200995c <_Chain_Append> <== NOT EXECUTED
200d9c4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200d9c8: 7f ff fd 7b call 200cfb4 <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
200d9cc: e0 2f 60 0c stb %l0, [ %i5 + 0xc ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
(bdbuf_config.swapout_priority ?
200d9d0: d2 06 a0 08 ld [ %i2 + 8 ], %o1 <== NOT EXECUTED
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200d9d4: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== 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 );
200d9d8: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
200d9dc: 84 07 60 14 add %i5, 0x14, %g2 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
200d9e0: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200d9e4: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
200d9e8: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200d9ec: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
200d9f0: 90 07 20 61 add %i4, 0x61, %o0 <== NOT EXECUTED
200d9f4: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
200d9f8: 12 80 00 03 bne 200da04 <rtems_bdbuf_swapout_task+0xe8> <== NOT EXECUTED
200d9fc: 90 12 00 18 or %o0, %i0, %o0 <== NOT EXECUTED
200da00: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
200da04: 15 00 00 08 sethi %hi(0x2000), %o2 <== NOT EXECUTED
200da08: 96 10 24 00 mov 0x400, %o3 <== NOT EXECUTED
200da0c: 98 10 20 00 clr %o4 <== NOT EXECUTED
200da10: 7f ff ed 48 call 2008f30 <rtems_task_create> <== NOT EXECUTED
200da14: 9a 07 60 08 add %i5, 8, %o5 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT),
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
200da18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200da1c: 22 80 00 06 be,a 200da34 <rtems_bdbuf_swapout_task+0x118><== NOT EXECUTED
200da20: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
200da24: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200da28: 90 12 20 16 or %o0, 0x16, %o0 ! 42000016 <RAM_END+0x3fc00016><== NOT EXECUTED
200da2c: 7f ff ee 76 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200da30: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_task_start (worker->id,
200da34: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200da38: 7f ff ed cb call 2009164 <rtems_task_start> <== NOT EXECUTED
200da3c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
200da40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200da44: 22 80 00 05 be,a 200da58 <rtems_bdbuf_swapout_task+0x13c><== NOT EXECUTED
200da48: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
200da4c: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200da50: 10 bf ff f7 b 200da2c <rtems_bdbuf_swapout_task+0x110> <== NOT EXECUTED
200da54: 90 12 20 17 or %o0, 0x17, %o0 ! 42000017 <RAM_END+0x3fc00017><== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200da58: 80 a7 00 13 cmp %i4, %l3
200da5c: 0a bf ff d1 bcs 200d9a0 <rtems_bdbuf_swapout_task+0x84> <== NEVER TAKEN
200da60: 01 00 00 00 nop
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
200da64: 7f ff fc cc call 200cd94 <rtems_bdbuf_unlock_cache>
200da68: 39 00 80 85 sethi %hi(0x2021400), %i4
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200da6c: b8 17 20 c4 or %i4, 0xc4, %i4 ! 20214c4 <bdbuf_cache>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
200da70: a6 07 20 08 add %i4, 8, %l3
/*
* 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,
200da74: a4 07 20 58 add %i4, 0x58, %l2
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200da78: 10 80 00 64 b 200dc08 <rtems_bdbuf_swapout_task+0x2ec>
200da7c: a0 07 20 4c add %i4, 0x4c, %l0
200da80: b2 10 20 00 clr %i1
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
200da84: 7f ff fc 4e call 200cbbc <rtems_bdbuf_lock_cache>
200da88: b4 10 20 00 clr %i2
* 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)
200da8c: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
200da90: 80 a0 60 00 cmp %g1, 0
200da94: 12 80 00 07 bne 200dab0 <rtems_bdbuf_swapout_task+0x194>
200da98: ba 07 bf e0 add %fp, -32, %i5
200da9c: 7f ff ef bb call 2009988 <_Chain_Get>
200daa0: 90 10 00 13 mov %l3, %o0
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
200daa4: b4 92 20 00 orcc %o0, 0, %i2
200daa8: 32 80 00 02 bne,a 200dab0 <rtems_bdbuf_swapout_task+0x194><== NEVER TAKEN
200daac: 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 );
200dab0: 82 07 60 04 add %i5, 4, %g1
head->next = tail;
200dab4: c2 27 40 00 st %g1, [ %i5 ]
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
200dab8: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
head->previous = NULL;
200dabc: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
200dac0: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
200dac4: 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)
200dac8: 80 88 60 ff btst 0xff, %g1
200dacc: 02 80 00 04 be 200dadc <rtems_bdbuf_swapout_task+0x1c0>
200dad0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
transfer->dd = bdbuf_cache.sync_device;
200dad4: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
200dad8: 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,
200dadc: b0 07 60 0c add %i5, 0xc, %i0
200dae0: 92 10 00 12 mov %l2, %o1
200dae4: 90 10 00 18 mov %i0, %o0
200dae8: 94 10 00 1d mov %i5, %o2
200daec: 96 10 20 01 mov 1, %o3
200daf0: 98 10 20 00 clr %o4
200daf4: 7f ff fc 51 call 200cc38 <rtems_bdbuf_swapout_modified_processing>
200daf8: 9a 10 00 1b mov %i3, %o5
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200dafc: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
200db00: 90 10 00 18 mov %i0, %o0
200db04: 92 10 00 10 mov %l0, %o1
200db08: 94 10 00 1d mov %i5, %o2
200db0c: 98 0e 60 01 and %i1, 1, %o4
200db10: 7f ff fc 4a call 200cc38 <rtems_bdbuf_swapout_modified_processing>
200db14: 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 ();
200db18: 7f ff fc 9f call 200cd94 <rtems_bdbuf_unlock_cache>
200db1c: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200db20: 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 );
200db24: 82 07 60 04 add %i5, 4, %g1
200db28: 80 a0 80 01 cmp %g2, %g1
200db2c: 02 80 00 11 be 200db70 <rtems_bdbuf_swapout_task+0x254>
200db30: 80 a6 a0 00 cmp %i2, 0
{
if (worker)
200db34: 02 80 00 0b be 200db60 <rtems_bdbuf_swapout_task+0x244> <== ALWAYS TAKEN
200db38: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
200db3c: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
200db40: 7f ff eb 50 call 2008880 <rtems_event_send> <== NOT EXECUTED
200db44: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200db48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200db4c: 02 80 00 0a be 200db74 <rtems_bdbuf_swapout_task+0x258> <== NOT EXECUTED
200db50: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
200db54: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200db58: 10 bf ff b5 b 200da2c <rtems_bdbuf_swapout_task+0x110> <== NOT EXECUTED
200db5c: 90 12 20 14 or %o0, 0x14, %o0 ! 42000014 <RAM_END+0x3fc00014><== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
200db60: 7f ff ff 16 call 200d7b8 <rtems_bdbuf_swapout_write>
200db64: 90 10 00 1d mov %i5, %o0
}
transfered_buffers = true;
200db68: 10 80 00 03 b 200db74 <rtems_bdbuf_swapout_task+0x258>
200db6c: 82 10 20 01 mov 1, %g1
200db70: 82 10 20 00 clr %g1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
200db74: c4 0f 20 30 ldub [ %i4 + 0x30 ], %g2
200db78: 80 a0 a0 00 cmp %g2, 0
200db7c: 02 80 00 13 be 200dbc8 <rtems_bdbuf_swapout_task+0x2ac>
200db80: 82 08 60 ff and %g1, 0xff, %g1
200db84: 80 a0 60 00 cmp %g1, 0
200db88: 12 bf ff bf bne 200da84 <rtems_bdbuf_swapout_task+0x168>
200db8c: b2 10 20 00 clr %i1
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
200db90: 7f ff fc 0b call 200cbbc <rtems_bdbuf_lock_cache>
200db94: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
200db98: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
200db9c: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
200dba0: 7f ff fc 7d call 200cd94 <rtems_bdbuf_unlock_cache>
200dba4: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
200dba8: 80 a7 60 00 cmp %i5, 0
200dbac: 22 80 00 0a be,a 200dbd4 <rtems_bdbuf_swapout_task+0x2b8><== NEVER TAKEN
200dbb0: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
200dbb4: 90 10 00 1d mov %i5, %o0
200dbb8: 7f ff eb 32 call 2008880 <rtems_event_send>
200dbbc: 92 10 20 02 mov 2, %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200dbc0: 10 80 00 05 b 200dbd4 <rtems_bdbuf_swapout_task+0x2b8>
200dbc4: 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,
200dbc8: 80 a0 60 00 cmp %g1, 0
200dbcc: 12 bf ff ad bne 200da80 <rtems_bdbuf_swapout_task+0x164>
200dbd0: 90 10 20 04 mov 4, %o0
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200dbd4: 92 10 20 00 clr %o1
200dbd8: 94 10 00 11 mov %l1, %o2
200dbdc: 7f ff ea c4 call 20086ec <rtems_event_receive>
200dbe0: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
200dbe4: 80 a2 20 06 cmp %o0, 6
200dbe8: 22 80 00 09 be,a 200dc0c <rtems_bdbuf_swapout_task+0x2f0>
200dbec: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200dbf0: 80 a2 20 00 cmp %o0, 0
200dbf4: 22 80 00 06 be,a 200dc0c <rtems_bdbuf_swapout_task+0x2f0><== ALWAYS TAKEN
200dbf8: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
200dbfc: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200dc00: 10 bf ff 8b b 200da2c <rtems_bdbuf_swapout_task+0x110> <== NOT EXECUTED
200dc04: 90 12 20 18 or %o0, 0x18, %o0 ! 42000018 <RAM_END+0x3fc00018><== NOT EXECUTED
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200dc08: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200dc0c: 80 a0 60 00 cmp %g1, 0
200dc10: 12 bf ff 9d bne 200da84 <rtems_bdbuf_swapout_task+0x168> <== ALWAYS TAKEN
200dc14: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
200dc18: 7f ff fb e9 call 200cbbc <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200dc1c: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200dc20: 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))
200dc24: 10 80 00 06 b 200dc3c <rtems_bdbuf_swapout_task+0x320> <== NOT EXECUTED
200dc28: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
200dc2c: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
200dc30: 7f ff eb 14 call 2008880 <rtems_event_send> <== NOT EXECUTED
200dc34: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200dc38: 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))
200dc3c: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200dc40: 32 bf ff fb bne,a 200dc2c <rtems_bdbuf_swapout_task+0x310><== NOT EXECUTED
200dc44: 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 ();
200dc48: 7f ff fc 53 call 200cd94 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200dc4c: 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);
200dc50: 7f ff db 60 call 20049d0 <free> <== NOT EXECUTED
200dc54: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200dc58: 7f ff ed 01 call 200905c <rtems_task_delete> <== NOT EXECUTED
200dc5c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
200dc60: 81 c7 e0 08 ret <== NOT EXECUTED
200dc64: 81 e8 00 00 restore <== NOT EXECUTED
0200dc68 <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)
{
200dc68: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
200dc6c: 39 00 80 85 sethi %hi(0x2021400), %i4 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
200dc70: ba 06 20 10 add %i0, 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 );
200dc74: 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)
200dc78: 10 80 00 11 b 200dcbc <rtems_bdbuf_swapout_worker_task+0x54><== NOT EXECUTED
200dc7c: b8 17 20 cc or %i4, 0xcc, %i4 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
200dc80: 7f ff fc 6d call 200ce34 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
200dc84: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
200dc88: 7f ff fe cc call 200d7b8 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
200dc8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200dc90: 7f ff fb cb call 200cbbc <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200dc94: 01 00 00 00 nop <== NOT EXECUTED
200dc98: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
200dc9c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
head->next = tail;
200dca0: f6 26 20 10 st %i3, [ %i0 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
200dca4: c0 26 20 14 clr [ %i0 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
200dca8: fa 26 20 18 st %i5, [ %i0 + 0x18 ] <== NOT EXECUTED
200dcac: 7f ff ef 2c call 200995c <_Chain_Append> <== NOT EXECUTED
200dcb0: c0 26 20 1c clr [ %i0 + 0x1c ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
200dcb4: 7f ff fc 38 call 200cd94 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200dcb8: 01 00 00 00 nop <== 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)
200dcbc: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200dcc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200dcc4: 12 bf ff ef bne 200dc80 <rtems_bdbuf_swapout_worker_task+0x18><== NOT EXECUTED
200dcc8: 01 00 00 00 nop <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
200dccc: 7f ff db 41 call 20049d0 <free> <== NOT EXECUTED
200dcd0: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
free (worker);
200dcd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200dcd8: 7f ff db 3e call 20049d0 <free> <== NOT EXECUTED
200dcdc: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200dce0: 7f ff ec df call 200905c <rtems_task_delete> <== NOT EXECUTED
200dce4: 81 e8 00 00 restore <== NOT EXECUTED
0200d7b8 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
200d7b8: 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))
200d7bc: 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 );
200d7c0: b6 06 20 04 add %i0, 4, %i3
200d7c4: 80 a0 40 1b cmp %g1, %i3
200d7c8: 02 80 00 53 be 200d914 <rtems_bdbuf_swapout_write+0x15c> <== NEVER TAKEN
200d7cc: 35 00 80 7a sethi %hi(0x201e800), %i2
* Number of buffers per bd. This is used to detect the next
* block.
*/
uint32_t bufs_per_bd = 0;
const rtems_disk_device *dd = transfer->dd;
200d7d0: fa 06 20 0c ld [ %i0 + 0xc ], %i5
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
200d7d4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200d7d8: 82 16 a1 80 or %i2, 0x180, %g1
200d7dc: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
200d7e0: 40 00 3a f9 call 201c3c4 <.udiv>
200d7e4: b8 10 20 00 clr %i4
* 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;
200d7e8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200d7ec: 84 10 20 0c mov 0xc, %g2
*/
uint32_t bufs_per_bd = 0;
const rtems_disk_device *dd = transfer->dd;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
200d7f0: a0 10 00 08 mov %o0, %l0
* 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;
200d7f4: c4 20 60 0c st %g2, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200d7f8: c0 20 60 10 clr [ %g1 + 0x10 ]
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
200d7fc: 10 80 00 35 b 200d8d0 <rtems_bdbuf_swapout_write+0x118>
200d800: b2 10 20 0c mov 0xc, %i1
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
200d804: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200d808: 80 88 60 01 btst 1, %g1
200d80c: 02 80 00 0f be 200d848 <rtems_bdbuf_swapout_write+0x90> <== ALWAYS TAKEN
200d810: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200d814: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED
200d818: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
200d81c: 22 80 00 0c be,a 200d84c <rtems_bdbuf_swapout_write+0x94><== NOT EXECUTED
200d820: c8 00 60 10 ld [ %g1 + 0x10 ], %g4 <== NOT EXECUTED
transfer->write_req->bufnum &&
200d824: c6 02 60 18 ld [ %o1 + 0x18 ], %g3 <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
200d828: 84 07 00 10 add %i4, %l0, %g2 <== NOT EXECUTED
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
transfer->write_req->bufnum &&
200d82c: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
200d830: 22 80 00 07 be,a 200d84c <rtems_bdbuf_swapout_write+0x94><== NOT EXECUTED
200d834: c8 00 60 10 ld [ %g1 + 0x10 ], %g4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
200d838: 40 00 0e 59 call 201119c <_Chain_Insert> <== NOT EXECUTED
200d83c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
{
rtems_chain_prepend (&transfer->bds, &bd->link);
write = true;
200d840: 10 80 00 10 b 200d880 <rtems_bdbuf_swapout_write+0xc8> <== NOT EXECUTED
200d844: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200d848: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200d84c: f8 02 60 18 ld [ %o1 + 0x18 ], %i4
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200d850: 87 29 20 04 sll %g4, 4, %g3
transfer->write_req->bufnum++;
200d854: 88 01 20 01 inc %g4
200d858: 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];
200d85c: 86 00 e0 18 add %g3, 0x18, %g3
200d860: 84 00 40 03 add %g1, %g3, %g2
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200d864: f8 20 40 03 st %i4, [ %g1 + %g3 ]
buf->length = dd->block_size;
200d868: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
200d86c: d2 20 a0 0c st %o1, [ %g2 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
200d870: c2 20 a0 04 st %g1, [ %g2 + 4 ]
buf->buffer = bd->buffer;
200d874: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
200d878: c2 20 a0 08 st %g1, [ %g2 + 8 ]
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
200d87c: 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) ||
200d880: c4 06 00 00 ld [ %i0 ], %g2
200d884: 80 a0 80 1b cmp %g2, %i3
200d888: 02 80 00 0b be 200d8b4 <rtems_bdbuf_swapout_write+0xfc>
200d88c: 84 16 a1 80 or %i2, 0x180, %g2
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
200d890: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
/*
* 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) ||
200d894: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
200d898: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200d89c: 80 a0 c0 02 cmp %g3, %g2
200d8a0: 3a 80 00 06 bcc,a 200d8b8 <rtems_bdbuf_swapout_write+0x100>
200d8a4: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
200d8a8: 80 88 60 ff btst 0xff, %g1
200d8ac: 02 80 00 09 be 200d8d0 <rtems_bdbuf_swapout_write+0x118> <== ALWAYS TAKEN
200d8b0: 01 00 00 00 nop
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
200d8b4: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
200d8b8: 90 10 00 1d mov %i5, %o0
200d8bc: 7f ff ff 66 call 200d654 <rtems_bdbuf_execute_transfer_request>
200d8c0: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200d8c4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200d8c8: f2 20 60 0c st %i1, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200d8cc: c0 20 60 10 clr [ %g1 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
200d8d0: 7f ff f0 2e call 2009988 <_Chain_Get>
200d8d4: 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(&transfer->bds)) != NULL)
200d8d8: 92 92 20 00 orcc %o0, 0, %o1
200d8dc: 32 bf ff ca bne,a 200d804 <rtems_bdbuf_swapout_write+0x4c>
200d8e0: c2 07 60 08 ld [ %i5 + 8 ], %g1
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
200d8e4: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
200d8e8: 80 a0 60 00 cmp %g1, 0
200d8ec: 02 80 00 0a be 200d914 <rtems_bdbuf_swapout_write+0x15c>
200d8f0: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
200d8f4: d0 07 60 08 ld [ %i5 + 8 ], %o0
200d8f8: 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 &&
200d8fc: 80 88 60 02 btst 2, %g1
200d900: 02 80 00 05 be 200d914 <rtems_bdbuf_swapout_write+0x15c> <== ALWAYS TAKEN
200d904: 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);
200d908: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
200d90c: 9f c0 40 00 call %g1 <== NOT EXECUTED
200d910: 94 10 20 00 clr %o2 <== NOT EXECUTED
200d914: 81 c7 e0 08 ret
200d918: 81 e8 00 00 restore
0200cfb4 <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
200cfb4: 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)));
200cfb8: 03 00 80 7a sethi %hi(0x201e800), %g1
200cfbc: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 201e984 <rtems_bdbuf_configuration+0x4>
200cfc0: 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 =
200cfc4: 7f ff df fb call 2004fb0 <malloc>
200cfc8: 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)
200cfcc: b0 92 20 00 orcc %o0, 0, %i0
200cfd0: 12 80 00 05 bne 200cfe4 <rtems_bdbuf_swapout_writereq_alloc+0x30><== ALWAYS TAKEN
200cfd4: 82 10 20 01 mov 1, %g1
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
200cfd8: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200cfdc: 7f ff f1 0a call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cfe0: 90 12 20 15 or %o0, 0x15, %o0 ! 42000015 <RAM_END+0x3fc00015><== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
200cfe4: c2 26 00 00 st %g1, [ %i0 ]
write_req->req_done = rtems_bdbuf_transfer_done;
200cfe8: 03 00 80 33 sethi %hi(0x200cc00), %g1
200cfec: 82 10 62 1c or %g1, 0x21c, %g1 ! 200ce1c <rtems_bdbuf_transfer_done>
write_req->done_arg = write_req;
200cff0: f0 26 20 08 st %i0, [ %i0 + 8 ]
write_req->io_task = rtems_task_self ();
200cff4: 40 00 0f 97 call 2010e50 <rtems_task_self>
200cff8: c2 26 20 04 st %g1, [ %i0 + 4 ]
200cffc: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return write_req;
}
200d000: 81 c7 e0 08 ret
200d004: 81 e8 00 00 restore
0200eaa8 <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
200eaa8: 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 (!bdbuf_cache.initialised)
200eaac: 39 00 80 85 sethi %hi(0x2021400), %i4
200eab0: b8 17 20 c4 or %i4, 0xc4, %i4 ! 20214c4 <bdbuf_cache>
200eab4: c2 0f 20 84 ldub [ %i4 + 0x84 ], %g1
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
200eab8: ba 10 00 18 mov %i0, %i5
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
200eabc: 80 a0 60 00 cmp %g1, 0
200eac0: 02 80 00 4d be 200ebf4 <rtems_bdbuf_sync+0x14c> <== NEVER TAKEN
200eac4: b0 10 20 16 mov 0x16, %i0
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
200eac8: 80 a7 60 00 cmp %i5, 0
200eacc: 02 80 00 0f be 200eb08 <rtems_bdbuf_sync+0x60> <== NEVER TAKEN
200ead0: 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();
200ead4: 7f ff f8 3a call 200cbbc <rtems_bdbuf_lock_cache>
200ead8: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200eadc: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200eae0: 80 a2 20 03 cmp %o0, 3
200eae4: 0a 80 00 3f bcs 200ebe0 <rtems_bdbuf_sync+0x138> <== NEVER TAKEN
200eae8: 13 10 80 00 sethi %hi(0x42000000), %o1
200eaec: 80 a2 20 05 cmp %o0, 5
200eaf0: 08 80 00 08 bleu 200eb10 <rtems_bdbuf_sync+0x68>
200eaf4: 82 10 20 08 mov 8, %g1
200eaf8: 80 a2 20 06 cmp %o0, 6
200eafc: 12 80 00 3a bne 200ebe4 <rtems_bdbuf_sync+0x13c> <== NEVER TAKEN
200eb00: 92 12 60 03 or %o1, 3, %o1
200eb04: 30 80 00 34 b,a 200ebd4 <rtems_bdbuf_sync+0x12c>
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
200eb08: 81 c7 e0 08 ret <== NOT EXECUTED
200eb0c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
200eb10: 90 07 20 58 add %i4, 0x58, %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eb14: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
200eb18: 7f ff eb 91 call 200995c <_Chain_Append>
200eb1c: 92 10 00 1d mov %i5, %o1
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
200eb20: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200eb24: 80 a0 60 00 cmp %g1, 0
200eb28: 02 80 00 04 be 200eb38 <rtems_bdbuf_sync+0x90>
200eb2c: 01 00 00 00 nop
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200eb30: 7f ff f9 85 call 200d144 <rtems_bdbuf_wake>
200eb34: 90 07 20 64 add %i4, 0x64, %o0
rtems_bdbuf_wake_swapper ();
200eb38: 7f ff f8 ad call 200cdec <rtems_bdbuf_wake_swapper>
200eb3c: 39 00 80 85 sethi %hi(0x2021400), %i4
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);
200eb40: b8 17 21 30 or %i4, 0x130, %i4 ! 2021530 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200eb44: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200eb48: 80 a2 20 01 cmp %o0, 1
200eb4c: 0a 80 00 0d bcs 200eb80 <rtems_bdbuf_sync+0xd8> <== NEVER TAKEN
200eb50: 13 10 80 00 sethi %hi(0x42000000), %o1
200eb54: 80 a2 20 07 cmp %o0, 7
200eb58: 28 80 00 0c bleu,a 200eb88 <rtems_bdbuf_sync+0xe0>
200eb5c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200eb60: 80 a2 20 0a cmp %o0, 0xa
200eb64: 18 80 00 20 bgu 200ebe4 <rtems_bdbuf_sync+0x13c> <== NEVER TAKEN
200eb68: 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);
200eb6c: 90 10 00 1d mov %i5, %o0
200eb70: 7f ff f8 fe call 200cf68 <rtems_bdbuf_wait>
200eb74: 92 10 00 1c mov %i4, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200eb78: 10 bf ff f4 b 200eb48 <rtems_bdbuf_sync+0xa0>
200eb7c: 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_9);
200eb80: 10 80 00 19 b 200ebe4 <rtems_bdbuf_sync+0x13c> <== NOT EXECUTED
200eb84: 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
200eb88: 80 a0 60 00 cmp %g1, 0
200eb8c: 12 80 00 18 bne 200ebec <rtems_bdbuf_sync+0x144>
200eb90: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
200eb94: 80 a0 60 01 cmp %g1, 1
200eb98: 18 80 00 15 bgu 200ebec <rtems_bdbuf_sync+0x144> <== NEVER TAKEN
200eb9c: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
200eba0: 32 80 00 0a bne,a 200ebc8 <rtems_bdbuf_sync+0x120>
200eba4: 11 00 80 85 sethi %hi(0x2021400), %o0
{
rtems_bdbuf_remove_from_tree (bd);
200eba8: 7f ff f9 a8 call 200d248 <rtems_bdbuf_remove_from_tree>
200ebac: 90 10 00 1d mov %i5, %o0
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
200ebb0: 11 00 80 85 sethi %hi(0x2021400), %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ebb4: c0 27 60 20 clr [ %i5 + 0x20 ]
200ebb8: 90 12 21 04 or %o0, 0x104, %o0
200ebbc: 40 00 09 78 call 201119c <_Chain_Insert>
200ebc0: 92 10 00 1d mov %i5, %o1
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200ebc4: 11 00 80 85 sethi %hi(0x2021400), %o0
200ebc8: 7f ff f9 5f call 200d144 <rtems_bdbuf_wake>
200ebcc: 90 12 21 38 or %o0, 0x138, %o0 ! 2021538 <bdbuf_cache+0x74>
200ebd0: 30 80 00 07 b,a 200ebec <rtems_bdbuf_sync+0x144>
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);
200ebd4: 7f ff fa 85 call 200d5e8 <rtems_bdbuf_discard_buffer_after_access>
200ebd8: 90 10 00 1d mov %i5, %o0
break;
200ebdc: 30 80 00 04 b,a 200ebec <rtems_bdbuf_sync+0x144>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
200ebe0: 92 12 60 03 or %o1, 3, %o1 <== NOT EXECUTED
200ebe4: 7f ff f8 10 call 200cc24 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ebe8: 01 00 00 00 nop <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ebec: 7f ff f8 6a call 200cd94 <rtems_bdbuf_unlock_cache>
200ebf0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return RTEMS_SUCCESSFUL;
}
200ebf4: 81 c7 e0 08 ret
200ebf8: 81 e8 00 00 restore
0200ebfc <rtems_bdbuf_syncdev>:
rtems_status_code
rtems_bdbuf_syncdev (const rtems_disk_device *dd)
{
200ebfc: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (rtems_bdbuf_tracer)
printf ("bdbuf:syncdev: %08x\n", (unsigned) dd->dev);
sc = rtems_bdbuf_obtain_disk (dd, 0, NULL, NULL);
200ec00: 92 10 20 00 clr %o1
200ec04: 90 10 00 18 mov %i0, %o0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (const rtems_disk_device *dd)
{
200ec08: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (rtems_bdbuf_tracer)
printf ("bdbuf:syncdev: %08x\n", (unsigned) dd->dev);
sc = rtems_bdbuf_obtain_disk (dd, 0, NULL, NULL);
200ec0c: 94 10 20 00 clr %o2
200ec10: 7f ff f9 17 call 200d06c <rtems_bdbuf_obtain_disk>
200ec14: 96 10 20 00 clr %o3
if (sc != RTEMS_SUCCESSFUL)
200ec18: b0 92 20 00 orcc %o0, 0, %i0
200ec1c: 12 80 00 12 bne 200ec64 <rtems_bdbuf_syncdev+0x68> <== NEVER TAKEN
200ec20: 01 00 00 00 nop
* Take the sync lock before locking the cache. Once we have the sync lock we
* can lock the cache. If another thread has the sync lock it will cause this
* thread to block until it owns the sync lock then it can own the cache. The
* sync lock can only be obtained with the cache unlocked.
*/
rtems_bdbuf_lock_sync ();
200ec24: 7f ff f7 f3 call 200cbf0 <rtems_bdbuf_lock_sync>
200ec28: 39 00 80 85 sethi %hi(0x2021400), %i4
rtems_bdbuf_lock_cache ();
200ec2c: 7f ff f7 e4 call 200cbbc <rtems_bdbuf_lock_cache>
200ec30: b8 17 20 c4 or %i4, 0xc4, %i4 ! 20214c4 <bdbuf_cache>
* out task know the id of the requester to wake when done.
*
* The swap out task will negate the sync active flag when no more buffers
* for the device are held on the "modified for sync" queues.
*/
bdbuf_cache.sync_active = true;
200ec34: 82 10 20 01 mov 1, %g1
bdbuf_cache.sync_requester = rtems_task_self ();
200ec38: 40 00 08 86 call 2010e50 <rtems_task_self>
200ec3c: c2 2f 20 30 stb %g1, [ %i4 + 0x30 ]
bdbuf_cache.sync_device = dd;
200ec40: fa 27 20 38 st %i5, [ %i4 + 0x38 ]
rtems_bdbuf_wake_swapper ();
200ec44: 7f ff f8 6a call 200cdec <rtems_bdbuf_wake_swapper>
200ec48: d0 27 20 34 st %o0, [ %i4 + 0x34 ]
rtems_bdbuf_unlock_cache ();
200ec4c: 7f ff f8 52 call 200cd94 <rtems_bdbuf_unlock_cache>
200ec50: 01 00 00 00 nop
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
200ec54: 7f ff f8 78 call 200ce34 <rtems_bdbuf_wait_for_event>
200ec58: 90 10 20 02 mov 2, %o0 ! 2 <PROM_START+0x2>
rtems_bdbuf_unlock_sync ();
200ec5c: 7f ff f8 59 call 200cdc0 <rtems_bdbuf_unlock_sync>
200ec60: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
200ec64: 81 c7 e0 08 ret
200ec68: 81 e8 00 00 restore
0200cd94 <rtems_bdbuf_unlock_cache>:
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
200cd94: 9d e3 bf a0 save %sp, -96, %sp
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
200cd98: 03 00 80 85 sethi %hi(0x2021400), %g1
200cd9c: 7f ff f0 38 call 2008e7c <rtems_semaphore_release>
200cda0: d0 00 60 ec ld [ %g1 + 0xec ], %o0 ! 20214ec <bdbuf_cache+0x28>
if (sc != RTEMS_SUCCESSFUL)
200cda4: 80 a2 20 00 cmp %o0, 0
200cda8: 02 80 00 04 be 200cdb8 <rtems_bdbuf_unlock_cache+0x24> <== ALWAYS TAKEN
200cdac: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (fatal_error_code);
200cdb0: 7f ff f1 95 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cdb4: 90 12 20 0e or %o0, 0xe, %o0 ! 4200000e <RAM_END+0x3fc0000e><== NOT EXECUTED
200cdb8: 81 c7 e0 08 ret
200cdbc: 81 e8 00 00 restore
0200cdc0 <rtems_bdbuf_unlock_sync>:
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
200cdc0: 9d e3 bf a0 save %sp, -96, %sp
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
200cdc4: 03 00 80 85 sethi %hi(0x2021400), %g1
200cdc8: 7f ff f0 2d call 2008e7c <rtems_semaphore_release>
200cdcc: d0 00 60 f0 ld [ %g1 + 0xf0 ], %o0 ! 20214f0 <bdbuf_cache+0x2c>
if (sc != RTEMS_SUCCESSFUL)
200cdd0: 80 a2 20 00 cmp %o0, 0
200cdd4: 02 80 00 04 be 200cde4 <rtems_bdbuf_unlock_sync+0x24> <== ALWAYS TAKEN
200cdd8: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (fatal_error_code);
200cddc: 7f ff f1 8a call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cde0: 90 12 20 0c or %o0, 0xc, %o0 ! 4200000c <RAM_END+0x3fc0000c><== NOT EXECUTED
200cde4: 81 c7 e0 08 ret
200cde8: 81 e8 00 00 restore
0200ce34 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
200ce34: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
200ce38: 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;
200ce3c: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
200ce40: 90 10 00 18 mov %i0, %o0
200ce44: 94 10 20 00 clr %o2
200ce48: 7f ff ee 29 call 20086ec <rtems_event_receive>
200ce4c: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
200ce50: 80 a2 20 00 cmp %o0, 0
200ce54: 12 80 00 05 bne 200ce68 <rtems_bdbuf_wait_for_event+0x34> <== NEVER TAKEN
200ce58: c2 07 bf fc ld [ %fp + -4 ], %g1
200ce5c: 80 a0 40 18 cmp %g1, %i0
200ce60: 02 80 00 05 be 200ce74 <rtems_bdbuf_wait_for_event+0x40> <== ALWAYS TAKEN
200ce64: 01 00 00 00 nop
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
200ce68: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200ce6c: 7f ff f1 66 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200ce70: 90 12 20 1a or %o0, 0x1a, %o0 ! 4200001a <RAM_END+0x3fc0001a><== NOT EXECUTED
200ce74: 81 c7 e0 08 ret
200ce78: 81 e8 00 00 restore
0200d144 <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)
{
200d144: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
200d148: c2 06 00 00 ld [ %i0 ], %g1
200d14c: 80 a0 60 00 cmp %g1, 0
200d150: 02 80 00 09 be 200d174 <rtems_bdbuf_wake+0x30>
200d154: 01 00 00 00 nop
{
sc = rtems_semaphore_flush (waiters->sema);
200d158: 40 00 0e b6 call 2010c30 <rtems_semaphore_flush>
200d15c: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
200d160: 80 a2 20 00 cmp %o0, 0
200d164: 02 80 00 04 be 200d174 <rtems_bdbuf_wake+0x30> <== ALWAYS TAKEN
200d168: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
200d16c: 7f ff f0 a6 call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200d170: 90 12 20 13 or %o0, 0x13, %o0 ! 42000013 <RAM_END+0x3fc00013><== NOT EXECUTED
200d174: 81 c7 e0 08 ret
200d178: 81 e8 00 00 restore
0200cdec <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
200cdec: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
200cdf0: 03 00 80 85 sethi %hi(0x2021400), %g1
200cdf4: d0 00 60 c4 ld [ %g1 + 0xc4 ], %o0 ! 20214c4 <bdbuf_cache>
200cdf8: 7f ff ee a2 call 2008880 <rtems_event_send>
200cdfc: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200ce00: 80 a2 20 00 cmp %o0, 0
200ce04: 02 80 00 04 be 200ce14 <rtems_bdbuf_wake_swapper+0x28> <== ALWAYS TAKEN
200ce08: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
200ce0c: 7f ff f1 7e call 2009404 <rtems_fatal_error_occurred> <== NOT EXECUTED
200ce10: 90 12 20 14 or %o0, 0x14, %o0 ! 42000014 <RAM_END+0x3fc00014><== NOT EXECUTED
200ce14: 81 c7 e0 08 ret
200ce18: 81 e8 00 00 restore
02023910 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
2023910: 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;
2023914: 84 10 20 00 clr %g2
2023918: 80 a6 60 00 cmp %i1, 0
202391c: 02 80 00 06 be 2023934 <rtems_bdpart_create+0x24> <== NEVER TAKEN
2023920: 82 10 00 18 mov %i0, %g1
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
2023924: c6 06 40 00 ld [ %i1 ], %g3
2023928: 80 a0 e0 00 cmp %g3, 0
202392c: 22 80 00 02 be,a 2023934 <rtems_bdpart_create+0x24> <== ALWAYS TAKEN
2023930: c4 0e 60 08 ldub [ %i1 + 8 ], %g2
&& 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 =
2023934: 80 a0 00 02 cmp %g0, %g2
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
2023938: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
202393c: ba 40 3f ff addx %g0, -1, %i5
2023940: a0 10 00 02 mov %g2, %l0
2023944: ba 0f 7f c2 and %i5, -62, %i5
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
2023948: b0 10 20 00 clr %i0
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) {
202394c: 80 a7 20 00 cmp %i4, 0
2023950: 02 80 00 6e be 2023b08 <rtems_bdpart_create+0x1f8> <== NEVER TAKEN
2023954: ba 07 60 3f add %i5, 0x3f, %i5
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
2023958: 80 a6 a0 00 cmp %i2, 0
202395c: 02 80 00 6b be 2023b08 <rtems_bdpart_create+0x1f8> <== NEVER TAKEN
2023960: b0 10 20 09 mov 9, %i0
2023964: 80 a6 60 00 cmp %i1, 0
2023968: 02 80 00 68 be 2023b08 <rtems_bdpart_create+0x1f8> <== NEVER TAKEN
202396c: 80 a6 e0 00 cmp %i3, 0
2023970: 02 80 00 66 be 2023b08 <rtems_bdpart_create+0x1f8> <== NEVER TAKEN
2023974: 90 10 00 01 mov %g1, %o0
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
2023978: 92 10 20 00 clr %o1
202397c: 94 10 20 00 clr %o2
2023980: 40 00 01 c4 call 2024090 <rtems_bdpart_get_disk_data>
2023984: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
2023988: 82 10 20 00 clr %g1
202398c: b0 92 20 00 orcc %o0, 0, %i0
2023990: 12 80 00 5e bne 2023b08 <rtems_bdpart_create+0x1f8> <== NEVER TAKEN
2023994: 84 10 20 00 clr %g2
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2023998: 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];
202399c: c6 06 c0 03 ld [ %i3 + %g3 ], %g3
20239a0: a8 00 c0 02 add %g3, %g2, %l4
if (dist_sum < prev_sum) {
20239a4: 80 a5 00 02 cmp %l4, %g2
20239a8: 0a 80 00 5e bcs 2023b20 <rtems_bdpart_create+0x210> <== NEVER TAKEN
20239ac: 80 a0 e0 00 cmp %g3, 0
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
20239b0: 02 80 00 5c be 2023b20 <rtems_bdpart_create+0x210> <== NEVER TAKEN
20239b4: 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) {
20239b8: 80 a0 40 1c cmp %g1, %i4
20239bc: 32 bf ff f7 bne,a 2023998 <rtems_bdpart_create+0x88>
20239c0: 84 10 00 14 mov %l4, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
20239c4: c2 06 40 00 ld [ %i1 ], %g1
20239c8: 80 a0 60 00 cmp %g1, 0
20239cc: 12 80 00 51 bne 2023b10 <rtems_bdpart_create+0x200> <== NEVER TAKEN
20239d0: 80 8c 20 ff btst 0xff, %l0
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
20239d4: 02 80 00 09 be 20239f8 <rtems_bdpart_create+0xe8> <== NEVER TAKEN
20239d8: 80 a7 20 04 cmp %i4, 4
disk_end -= (disk_end % record_space);
20239dc: f2 07 bf fc ld [ %fp + -4 ], %i1
20239e0: 92 10 00 1d mov %i5, %o1
20239e4: 40 00 df 47 call 205b700 <.urem>
20239e8: 90 10 00 19 mov %i1, %o0
20239ec: b2 26 40 08 sub %i1, %o0, %i1
20239f0: f2 27 bf fc st %i1, [ %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) {
20239f4: 80 a7 20 04 cmp %i4, 4
20239f8: 08 80 00 06 bleu 2023a10 <rtems_bdpart_create+0x100> <== NEVER TAKEN
20239fc: b2 10 00 1d mov %i5, %i1
overhead += (count - 3) * record_space;
2023a00: 90 10 00 1d mov %i5, %o0
2023a04: 7f ff 7c ee call 2002dbc <.umul>
2023a08: 92 07 3f fd add %i4, -3, %o1
2023a0c: b2 02 00 1d add %o0, %i5, %i1
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
2023a10: 80 8c 20 ff btst 0xff, %l0
2023a14: 02 80 00 07 be 2023a30 <rtems_bdpart_create+0x120> <== NEVER TAKEN
2023a18: e6 07 bf fc ld [ %fp + -4 ], %l3
overhead += (count - 1) * record_space;
2023a1c: 90 10 00 1d mov %i5, %o0
2023a20: 7f ff 7c e7 call 2002dbc <.umul>
2023a24: 92 07 3f ff add %i4, -1, %o1
2023a28: b2 06 40 08 add %i1, %o0, %i1
}
/* Check disk space */
if ((overhead + count) > disk_end) {
2023a2c: e6 07 bf fc ld [ %fp + -4 ], %l3
2023a30: 82 06 40 1c add %i1, %i4, %g1
2023a34: 80 a0 40 13 cmp %g1, %l3
2023a38: 18 80 00 38 bgu 2023b18 <rtems_bdpart_create+0x208> <== NEVER TAKEN
2023a3c: aa 24 c0 19 sub %l3, %i1, %l5
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
2023a40: a2 10 00 1a mov %i2, %l1
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
2023a44: a0 10 00 1d mov %i5, %l0
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2023a48: b2 10 20 00 clr %i1
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2023a4c: 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];
2023a50: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
2023a54: 92 10 00 15 mov %l5, %o1
2023a58: 7f ff 7c d9 call 2002dbc <.umul>
2023a5c: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
2023a60: 80 a2 00 15 cmp %o0, %l5
2023a64: 0a 80 00 2f bcs 2023b20 <rtems_bdpart_create+0x210> <== NEVER TAKEN
2023a68: 80 a2 00 12 cmp %o0, %l2
2023a6c: 2a 80 00 27 bcs,a 2023b08 <rtems_bdpart_create+0x1f8> <== NEVER TAKEN
2023a70: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
2023a74: 40 00 de 77 call 205b450 <.udiv>
2023a78: 92 10 00 14 mov %l4, %o1
/* Ensure that the partition is not empty */
if (s == 0) {
2023a7c: a4 92 20 00 orcc %o0, 0, %l2
2023a80: 22 80 00 02 be,a 2023a88 <rtems_bdpart_create+0x178> <== NEVER TAKEN
2023a84: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
2023a88: 90 10 00 12 mov %l2, %o0
2023a8c: 40 00 df 1d call 205b700 <.urem>
2023a90: 92 10 00 1d mov %i5, %o1
2023a94: a4 04 80 1d add %l2, %i5, %l2
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
2023a98: 82 10 20 01 mov 1, %g1
2023a9c: 80 a6 60 02 cmp %i1, 2
2023aa0: 18 80 00 03 bgu 2023aac <rtems_bdpart_create+0x19c>
2023aa4: a4 24 80 08 sub %l2, %o0, %l2
2023aa8: 82 10 20 00 clr %g1
2023aac: 80 88 60 ff btst 0xff, %g1
2023ab0: 22 80 00 0a be,a 2023ad8 <rtems_bdpart_create+0x1c8>
2023ab4: e0 24 40 00 st %l0, [ %l1 ]
2023ab8: 80 a7 20 04 cmp %i4, 4
2023abc: 18 80 00 03 bgu 2023ac8 <rtems_bdpart_create+0x1b8> <== ALWAYS TAKEN
2023ac0: 82 10 20 01 mov 1, %g1
2023ac4: 82 10 20 00 clr %g1 <== NOT EXECUTED
2023ac8: 80 88 60 ff btst 0xff, %g1
2023acc: 32 80 00 02 bne,a 2023ad4 <rtems_bdpart_create+0x1c4> <== ALWAYS TAKEN
2023ad0: a0 04 00 1d add %l0, %i5, %l0
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
2023ad4: e0 24 40 00 st %l0, [ %l1 ]
pos += s;
2023ad8: a0 04 00 12 add %l0, %l2, %l0
p->end = pos;
2023adc: 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) {
2023ae0: b2 06 60 01 inc %i1
2023ae4: 80 a6 40 1c cmp %i1, %i4
2023ae8: 12 bf ff d9 bne 2023a4c <rtems_bdpart_create+0x13c>
2023aec: 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;
2023af0: b2 06 7f ff add %i1, -1, %i1
2023af4: 83 2e 60 04 sll %i1, 4, %g1
2023af8: b3 2e 60 06 sll %i1, 6, %i1
2023afc: b2 26 40 01 sub %i1, %g1, %i1
2023b00: b4 06 80 19 add %i2, %i1, %i2
2023b04: e6 26 a0 04 st %l3, [ %i2 + 4 ]
return RTEMS_SUCCESSFUL;
2023b08: 81 c7 e0 08 ret
2023b0c: 81 e8 00 00 restore
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
return RTEMS_NOT_IMPLEMENTED;
2023b10: 81 c7 e0 08 ret <== NOT EXECUTED
2023b14: 91 e8 20 18 restore %g0, 0x18, %o0 <== NOT EXECUTED
overhead += (count - 1) * record_space;
}
/* Check disk space */
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
2023b18: 81 c7 e0 08 ret <== NOT EXECUTED
2023b1c: 91 e8 20 1b restore %g0, 0x1b, %o0 <== NOT EXECUTED
2023b20: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
2023b24: 81 c7 e0 08 ret <== NOT EXECUTED
2023b28: 81 e8 00 00 restore <== NOT EXECUTED
02023b2c <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
2023b2c: 9d e3 bf 68 save %sp, -152, %sp
size_t i = 0;
printf(
2023b30: 11 00 81 8d sethi %hi(0x2063400), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2023b34: 21 00 81 8e sethi %hi(0x2063800), %l0
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
2023b38: 90 12 23 e0 or %o0, 0x3e0, %o0
2023b3c: 40 00 8b 2d call 20467f0 <puts>
2023b40: 39 00 81 8e sethi %hi(0x2063800), %i4
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2023b44: 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";
2023b48: 23 00 81 8d sethi %hi(0x2063400), %l1
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2023b4c: a0 14 21 20 or %l0, 0x120, %l0
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
2023b50: 35 00 81 8d sethi %hi(0x2063400), %i2
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
2023b54: 37 00 81 8d sethi %hi(0x2063400), %i3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2023b58: 10 80 00 32 b 2023c20 <rtems_bdpart_dump+0xf4>
2023b5c: b8 17 21 28 or %i4, 0x128, %i4
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)) {
2023b60: a4 06 20 08 add %i0, 8, %l2
2023b64: 92 07 bf ff add %fp, -1, %o1
2023b68: 40 00 01 3e call 2024060 <rtems_bdpart_to_mbr_partition_type>
2023b6c: 90 10 00 12 mov %l2, %o0
2023b70: 80 8a 20 ff btst 0xff, %o0
2023b74: 02 80 00 21 be 2023bf8 <rtems_bdpart_dump+0xcc> <== NEVER TAKEN
2023b78: c2 0f bf ff ldub [ %fp + -1 ], %g1
switch (type_mbr) {
2023b7c: 84 08 60 ff and %g1, 0xff, %g2
2023b80: 80 a0 a0 0b cmp %g2, 0xb
2023b84: 02 80 00 21 be 2023c08 <rtems_bdpart_dump+0xdc> <== ALWAYS TAKEN
2023b88: 96 14 63 c8 or %l1, 0x3c8, %o3
2023b8c: 80 a0 a0 0b cmp %g2, 0xb <== NOT EXECUTED
2023b90: 18 80 00 0a bgu 2023bb8 <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
2023b94: 80 a0 a0 0e cmp %g2, 0xe <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
2023b98: 17 00 81 8d sethi %hi(0x2063400), %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) {
2023b9c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
2023ba0: 02 80 00 1a be 2023c08 <rtems_bdpart_dump+0xdc> <== NOT EXECUTED
2023ba4: 96 12 e3 a8 or %o3, 0x3a8, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
2023ba8: 17 00 81 8d sethi %hi(0x2063400), %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) {
2023bac: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
2023bb0: 10 80 00 0a b 2023bd8 <rtems_bdpart_dump+0xac> <== NOT EXECUTED
2023bb4: 96 12 e3 a0 or %o3, 0x3a0, %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) {
2023bb8: 02 80 00 14 be 2023c08 <rtems_bdpart_dump+0xdc> <== NOT EXECUTED
2023bbc: 96 16 a3 d0 or %i2, 0x3d0, %o3 <== NOT EXECUTED
2023bc0: 80 a0 a0 da cmp %g2, 0xda <== NOT EXECUTED
2023bc4: 02 80 00 11 be 2023c08 <rtems_bdpart_dump+0xdc> <== NOT EXECUTED
2023bc8: 96 16 e3 b0 or %i3, 0x3b0, %o3 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2023bcc: 17 00 81 8d sethi %hi(0x2063400), %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) {
2023bd0: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2023bd4: 96 12 e3 b8 or %o3, 0x3b8, %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) {
2023bd8: 02 80 00 0c be 2023c08 <rtems_bdpart_dump+0xdc> <== NOT EXECUTED
2023bdc: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2023be0: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
2023be4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2023be8: 40 00 90 90 call 2047e28 <snprintf> <== NOT EXECUTED
2023bec: 96 08 60 ff and %g1, 0xff, %o3 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
2023bf0: 10 80 00 06 b 2023c08 <rtems_bdpart_dump+0xdc> <== NOT EXECUTED
2023bf4: 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);
2023bf8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
2023bfc: 40 00 65 93 call 203d248 <uuid_unparse_lower> <== NOT EXECUTED
2023c00: 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;
2023c04: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
}
printf(
2023c08: d2 06 00 00 ld [ %i0 ], %o1
2023c0c: d4 06 20 04 ld [ %i0 + 4 ], %o2
2023c10: 90 10 00 1c mov %i4, %o0
2023c14: 40 00 8a 5c call 2046584 <printf>
2023c18: ba 07 60 01 inc %i5
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2023c1c: b0 06 20 30 add %i0, 0x30, %i0
2023c20: 80 a7 40 19 cmp %i5, %i1
2023c24: 32 bf ff cf bne,a 2023b60 <rtems_bdpart_dump+0x34>
2023c28: c0 2f bf ff clrb [ %fp + -1 ]
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
2023c2c: 11 00 81 8e sethi %hi(0x2063800), %o0
2023c30: 40 00 8a f0 call 20467f0 <puts>
2023c34: 90 12 20 d0 or %o0, 0xd0, %o0 ! 20638d0 <rtems_rfs_rtems_eval_config+0xf50>
}
2023c38: 81 c7 e0 08 ret
2023c3c: 81 e8 00 00 restore
02024090 <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
const rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
2024090: 9d e3 bf 98 save %sp, -104, %sp
const 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);
2024094: 92 10 20 02 mov 2, %o1
2024098: 90 10 00 18 mov %i0, %o0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
const rtems_disk_device *dd = NULL;
202409c: 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);
20240a0: 7f ff 95 95 call 20096f4 <open>
20240a4: b0 10 20 03 mov 3, %i0
if (fd < 0) {
20240a8: 80 a2 20 00 cmp %o0, 0
20240ac: 06 80 00 13 bl 20240f8 <rtems_bdpart_get_disk_data+0x68> <== NEVER TAKEN
20240b0: ba 10 00 08 mov %o0, %i5
static inline int rtems_disk_fd_get_disk_device(
int fd,
const rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
20240b4: 13 10 01 10 sethi %hi(0x40044000), %o1
20240b8: 94 07 bf fc add %fp, -4, %o2
20240bc: 7f ff 92 06 call 20088d4 <ioctl>
20240c0: 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) {
20240c4: 80 a2 20 00 cmp %o0, 0
20240c8: 12 80 00 0d bne 20240fc <rtems_bdpart_get_disk_data+0x6c> <== NEVER TAKEN
20240cc: 80 a6 20 00 cmp %i0, 0
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
20240d0: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
20240d4: c4 18 60 18 ldd [ %g1 + 0x18 ], %g2
20240d8: c6 26 c0 00 st %g3, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
20240dc: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
20240e0: 80 a0 61 ff cmp %g1, 0x1ff
20240e4: 08 80 00 05 bleu 20240f8 <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
20240e8: b0 10 20 1b mov 0x1b, %i0
int *fd_ptr,
const rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
20240ec: 80 a0 00 02 cmp %g0, %g2
20240f0: b0 60 20 00 subx %g0, 0, %i0
20240f4: b0 0e 20 1b and %i0, 0x1b, %i0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
20240f8: 80 a6 20 00 cmp %i0, 0
20240fc: 12 80 00 0a bne 2024124 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
2024100: 80 a6 60 00 cmp %i1, 0
2024104: 02 80 00 08 be 2024124 <rtems_bdpart_get_disk_data+0x94>
2024108: 80 a6 a0 00 cmp %i2, 0
202410c: 02 80 00 06 be 2024124 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
2024110: c2 07 bf fc ld [ %fp + -4 ], %g1
*fd_ptr = fd;
2024114: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
2024118: c2 26 80 00 st %g1, [ %i2 ]
202411c: 81 c7 e0 08 ret
2024120: 81 e8 00 00 restore
} else {
close( fd);
2024124: 7f ff 90 dc call 2008494 <close>
2024128: 90 10 00 1d mov %i5, %o0
}
return sc;
}
202412c: 81 c7 e0 08 ret
2024130: 81 e8 00 00 restore
02023c40 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2023c40: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
2023c44: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2023c48: 40 00 98 6e call 2049e00 <strrchr> <== NOT EXECUTED
2023c4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2023c50: 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);
2023c54: 40 00 94 30 call 2048d14 <strlen> <== NOT EXECUTED
2023c58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2023c5c: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2023c60: 40 00 94 2d call 2048d14 <strlen> <== NOT EXECUTED
2023c64: 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;
2023c68: a8 10 20 1a mov 0x1a, %l4 <== 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);
2023c6c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
2023c70: 7f ff 94 42 call 2008d78 <malloc> <== NOT EXECUTED
2023c74: 90 06 60 04 add %i1, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
2023c78: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023c7c: 02 80 00 4e be 2023db4 <rtems_bdpart_mount+0x174> <== NOT EXECUTED
2023c80: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
2023c84: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2023c88: 40 00 94 e9 call 204902c <strncpy> <== NOT EXECUTED
2023c8c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
if (disk_file_name != NULL) {
disk_file_name += 1;
disk_file_name_size = strlen( disk_file_name);
} else {
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
2023c90: a4 10 00 19 mov %i1, %l2 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
/* Get disk file name */
if (disk_file_name != NULL) {
2023c94: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2023c98: 02 80 00 06 be 2023cb0 <rtems_bdpart_mount+0x70> <== NOT EXECUTED
2023c9c: a6 10 00 18 mov %i0, %l3 <== NOT EXECUTED
disk_file_name += 1;
2023ca0: a6 07 60 01 add %i5, 1, %l3 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
2023ca4: 40 00 94 1c call 2048d14 <strlen> <== NOT EXECUTED
2023ca8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
2023cac: 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);
2023cb0: a2 04 80 10 add %l2, %l0, %l1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
2023cb4: a8 10 20 1a mov 0x1a, %l4 <== 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);
2023cb8: 7f ff 94 30 call 2008d78 <malloc> <== NOT EXECUTED
2023cbc: 90 04 60 05 add %l1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
2023cc0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023cc4: 02 80 00 38 be 2023da4 <rtems_bdpart_mount+0x164> <== NOT EXECUTED
2023cc8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
2023ccc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2023cd0: 40 00 94 d7 call 204902c <strncpy> <== NOT EXECUTED
2023cd4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
2023cd8: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2023cdc: 90 04 20 01 add %l0, 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] = '/';
2023ce0: c2 2f 40 10 stb %g1, [ %i5 + %l0 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2023ce4: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
2023ce8: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2023cec: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
2023cf0: b0 07 00 19 add %i4, %i1, %i0 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2023cf4: a2 04 60 01 inc %l1 <== 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);
2023cf8: 21 00 81 94 sethi %hi(0x2065000), %l0 <== 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);
2023cfc: 40 00 94 cc call 204902c <strncpy> <== NOT EXECUTED
2023d00: 33 00 81 8e sethi %hi(0x2063800), %i1 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2023d04: a2 07 40 11 add %i5, %l1, %l1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2023d08: b6 10 20 00 clr %i3 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2023d0c: a0 14 22 e0 or %l0, 0x2e0, %l0 <== 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) {
2023d10: 10 80 00 1d b 2023d84 <rtems_bdpart_mount+0x144> <== NOT EXECUTED
2023d14: b2 16 61 40 or %i1, 0x140, %i1 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2023d18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2023d1c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2023d20: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2023d24: 40 00 90 41 call 2047e28 <snprintf> <== NOT EXECUTED
2023d28: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2023d2c: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2023d30: 14 80 00 1a bg 2023d98 <rtems_bdpart_mount+0x158> <== NOT EXECUTED
2023d34: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
2023d38: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
2023d3c: 40 00 94 bc call 204902c <strncpy> <== NOT EXECUTED
2023d40: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
2023d44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2023d48: 7f ff 97 b8 call 2009c28 <rtems_mkdir> <== NOT EXECUTED
2023d4c: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
2023d50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023d54: 12 80 00 13 bne 2023da0 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
2023d58: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
2023d5c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2023d60: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2023d64: 96 10 20 00 clr %o3 <== NOT EXECUTED
2023d68: 7f ff 94 c1 call 200906c <mount> <== NOT EXECUTED
2023d6c: 98 10 20 00 clr %o4 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
2023d70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023d74: 02 80 00 05 be 2023d88 <rtems_bdpart_mount+0x148> <== NOT EXECUTED
2023d78: 80 a6 c0 1a cmp %i3, %i2 <== NOT EXECUTED
rmdir( mount_point);
2023d7c: 40 00 14 0e call 2028db4 <rmdir> <== NOT EXECUTED
2023d80: 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) {
2023d84: 80 a6 c0 1a cmp %i3, %i2 <== NOT EXECUTED
2023d88: 32 bf ff e4 bne,a 2023d18 <rtems_bdpart_mount+0xd8> <== NOT EXECUTED
2023d8c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
2023d90: 10 80 00 05 b 2023da4 <rtems_bdpart_mount+0x164> <== NOT EXECUTED
2023d94: a8 10 20 00 clr %l4 <== 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;
2023d98: 10 80 00 03 b 2023da4 <rtems_bdpart_mount+0x164> <== NOT EXECUTED
2023d9c: a8 10 20 03 mov 3, %l4 <== 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;
2023da0: a8 10 20 1b mov 0x1b, %l4 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2023da4: 7f ff 92 75 call 2008778 <free> <== NOT EXECUTED
2023da8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free( mount_point);
2023dac: 7f ff 92 73 call 2008778 <free> <== NOT EXECUTED
2023db0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
2023db4: 81 c7 e0 08 ret <== NOT EXECUTED
2023db8: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED
020243f8 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
const rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
20243f8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
20243fc: d0 06 80 00 ld [ %i2 ], %o0
2024400: 80 a2 20 00 cmp %o0, 0
2024404: 22 80 00 07 be,a 2024420 <rtems_bdpart_new_record+0x28>
2024408: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_sync( *block);
202440c: 7f ff 88 7f call 2006608 <rtems_bdbuf_sync>
2024410: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2024414: ba 92 20 00 orcc %o0, 0, %i5
2024418: 12 80 00 19 bne 202447c <rtems_bdpart_new_record+0x84> <== NEVER TAKEN
202441c: 90 10 00 18 mov %i0, %o0
return sc;
}
}
/* Read the new record block (this accounts for disk block sizes > 512) */
sc = rtems_bdbuf_read( dd, index, block);
2024420: 92 10 00 19 mov %i1, %o1
2024424: 7f ff 87 92 call 200626c <rtems_bdbuf_read>
2024428: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
202442c: ba 92 20 00 orcc %o0, 0, %i5
2024430: 12 80 00 13 bne 202447c <rtems_bdpart_new_record+0x84> <== NEVER TAKEN
2024434: 01 00 00 00 nop
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2024438: c2 06 80 00 ld [ %i2 ], %g1
202443c: 80 a0 60 00 cmp %g1, 0
2024440: 02 80 00 0e be 2024478 <rtems_bdpart_new_record+0x80> <== NEVER TAKEN
2024444: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
2024448: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
202444c: 40 00 83 e2 call 20453d4 <memset>
2024450: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
2024454: c2 06 80 00 ld [ %i2 ], %g1
2024458: 84 10 20 55 mov 0x55, %g2
202445c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2024460: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
2024464: c2 06 80 00 ld [ %i2 ], %g1
2024468: 84 10 3f aa mov -86, %g2
202446c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2024470: 10 80 00 03 b 202447c <rtems_bdpart_new_record+0x84>
2024474: 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;
2024478: 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;
}
202447c: 81 c7 e0 08 ret
2024480: 91 e8 00 1d restore %g0, %i5, %o0
02024134 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
2024134: 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;
2024138: 84 06 bf d0 add %i2, -48, %g2
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
202413c: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
2024140: c4 27 bf ec st %g2, [ %fp + -20 ]
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
2024144: 82 10 00 18 mov %i0, %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);
2024148: 80 a6 e0 00 cmp %i3, 0
202414c: 02 80 00 06 be 2024164 <rtems_bdpart_read+0x30> <== NEVER TAKEN
2024150: b8 10 20 00 clr %i4
2024154: c4 06 c0 00 ld [ %i3 ], %g2
2024158: 87 28 a0 04 sll %g2, 4, %g3
202415c: b9 28 a0 06 sll %g2, 6, %i4
2024160: b8 27 00 03 sub %i4, %g3, %i4
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;
2024164: 84 10 3f ff mov -1, %g2
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 */
2024168: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
202416c: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
2024170: c4 27 bf f8 st %g2, [ %fp + -8 ]
const rtems_disk_device *dd = NULL;
2024174: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2024178: 80 a6 a0 00 cmp %i2, 0
202417c: 02 80 00 8a be 20243a4 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2024180: b0 10 20 09 mov 9, %i0
2024184: 80 a6 60 00 cmp %i1, 0
2024188: 02 80 00 87 be 20243a4 <rtems_bdpart_read+0x270> <== NEVER TAKEN
202418c: 80 a6 e0 00 cmp %i3, 0
2024190: 02 80 00 85 be 20243a4 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2024194: 90 10 00 01 mov %g1, %o0
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
2024198: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
202419c: 92 07 bf f8 add %fp, -8, %o1
20241a0: 94 07 bf fc add %fp, -4, %o2
20241a4: 7f ff ff bb call 2024090 <rtems_bdpart_get_disk_data>
20241a8: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
20241ac: b0 92 20 00 orcc %o0, 0, %i0
20241b0: 12 80 00 7d bne 20243a4 <rtems_bdpart_read+0x270> <== NEVER TAKEN
20241b4: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
20241b8: 92 10 20 00 clr %o1
20241bc: 7f ff ff 4e call 2023ef4 <rtems_bdpart_read_record>
20241c0: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
20241c4: b0 92 20 00 orcc %o0, 0, %i0
20241c8: 12 80 00 6c bne 2024378 <rtems_bdpart_read+0x244> <== NEVER TAKEN
20241cc: 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;
20241d0: 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);
20241d4: 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;
20241d8: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20241dc: a0 07 bf ec add %fp, -20, %l0
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
20241e0: ba 04 a1 be add %l2, 0x1be, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20241e4: a2 07 bf f0 add %fp, -16, %l1
20241e8: 90 10 00 1d mov %i5, %o0
20241ec: 92 10 00 10 mov %l0, %o1
20241f0: 94 10 00 1c mov %i4, %o2
20241f4: 7f ff ff 6e call 2023fac <rtems_bdpart_read_mbr_partition>
20241f8: 96 10 00 11 mov %l1, %o3
if (sc != RTEMS_SUCCESSFUL) {
20241fc: b0 92 20 00 orcc %o0, 0, %i0
2024200: 32 80 00 5e bne,a 2024378 <rtems_bdpart_read+0x244> <== NEVER TAKEN
2024204: 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) {
2024208: c2 07 bf ec ld [ %fp + -20 ], %g1
202420c: c2 08 60 08 ldub [ %g1 + 8 ], %g1
2024210: 80 a0 60 ee cmp %g1, 0xee
2024214: 02 80 00 58 be 2024374 <rtems_bdpart_read+0x240> <== NEVER TAKEN
2024218: 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
202421c: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
2024220: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
2024224: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
2024228: 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(
202422c: 7f ff ff 27 call 2023ec8 <rtems_uint32_from_little_endian>
2024230: 90 02 21 b8 add %o0, 0x1b8, %o0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
2024234: 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(
2024238: d0 26 60 04 st %o0, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
202423c: 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;
2024240: ba 07 60 10 add %i5, 0x10, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2024244: 92 10 00 10 mov %l0, %o1
2024248: 90 10 00 1d mov %i5, %o0
202424c: 94 10 00 1c mov %i4, %o2
2024250: 7f ff ff 57 call 2023fac <rtems_bdpart_read_mbr_partition>
2024254: 96 10 00 11 mov %l1, %o3
if (sc != RTEMS_SUCCESSFUL) {
2024258: 80 a2 20 00 cmp %o0, 0
202425c: 12 80 00 43 bne 2024368 <rtems_bdpart_read+0x234> <== NEVER TAKEN
2024260: 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) {
2024264: 32 bf ff f8 bne,a 2024244 <rtems_bdpart_read+0x110>
2024268: ba 07 60 10 add %i5, 0x10, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
202426c: 10 80 00 2c b 202431c <rtems_bdpart_read+0x1e8>
2024270: f2 07 bf f0 ld [ %fp + -16 ], %i1
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
2024274: 92 10 00 19 mov %i1, %o1
2024278: 7f ff ff 1f call 2023ef4 <rtems_bdpart_read_record>
202427c: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2024280: 80 a2 20 00 cmp %o0, 0
2024284: 12 80 00 39 bne 2024368 <rtems_bdpart_read+0x234> <== NEVER TAKEN
2024288: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
202428c: 92 10 00 10 mov %l0, %o1
2024290: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2024294: 94 10 00 1c mov %i4, %o2
2024298: 90 02 21 be add %o0, 0x1be, %o0
202429c: 7f ff ff 44 call 2023fac <rtems_bdpart_read_mbr_partition>
20242a0: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
20242a4: 80 a2 20 00 cmp %o0, 0
20242a8: 12 80 00 30 bne 2024368 <rtems_bdpart_read+0x234> <== NEVER TAKEN
20242ac: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
20242b0: c6 00 40 00 ld [ %g1 ], %g3
20242b4: 84 06 40 03 add %i1, %g3, %g2
if (tmp > p->begin) {
20242b8: 80 a0 80 03 cmp %g2, %g3
20242bc: 08 80 00 2e bleu 2024374 <rtems_bdpart_read+0x240> <== NEVER TAKEN
20242c0: b0 10 20 1b mov 0x1b, %i0
p->begin = tmp;
20242c4: c4 20 40 00 st %g2, [ %g1 ]
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
20242c8: c4 00 60 04 ld [ %g1 + 4 ], %g2
20242cc: b2 06 40 02 add %i1, %g2, %i1
if (tmp > p->end) {
20242d0: 80 a6 40 02 cmp %i1, %g2
20242d4: 08 80 00 29 bleu 2024378 <rtems_bdpart_read+0x244> <== NEVER TAKEN
20242d8: d0 07 bf f8 ld [ %fp + -8 ], %o0
p->end = tmp;
20242dc: f2 20 60 04 st %i1, [ %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
20242e0: c2 07 bf e8 ld [ %fp + -24 ], %g1
20242e4: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
== RTEMS_BDPART_MBR_SIGNATURE_1;
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
20242e8: 7f ff fe f8 call 2023ec8 <rtems_uint32_from_little_endian>
20242ec: 90 07 61 d6 add %i5, 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) {
20242f0: c2 0f 61 d2 ldub [ %i5 + 0x1d2 ], %g1
20242f4: 80 a0 60 05 cmp %g1, 5
20242f8: 12 80 00 0d bne 202432c <rtems_bdpart_read+0x1f8>
20242fc: 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) {
2024300: 80 a2 20 00 cmp %o0, 0
2024304: 02 80 00 09 be 2024328 <rtems_bdpart_read+0x1f4> <== NEVER TAKEN
2024308: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
202430c: 82 02 00 01 add %o0, %g1, %g1
if (tmp > ebr) {
2024310: 80 a0 40 08 cmp %g1, %o0
2024314: 08 80 00 17 bleu 2024370 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
2024318: b2 10 00 01 mov %g1, %i1
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
202431c: 80 a6 60 00 cmp %i1, 0
2024320: 12 bf ff d5 bne 2024274 <rtems_bdpart_read+0x140> <== ALWAYS TAKEN
2024324: d0 07 bf fc ld [ %fp + -4 ], %o0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
2024328: 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;
202432c: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
2024330: b4 20 40 1a sub %g1, %i2, %i2
2024334: b5 3e a0 04 sra %i2, 4, %i2
2024338: 83 2e a0 02 sll %i2, 2, %g1
202433c: 82 00 40 1a add %g1, %i2, %g1
2024340: 85 28 60 04 sll %g1, 4, %g2
2024344: 82 00 40 02 add %g1, %g2, %g1
2024348: 85 28 60 08 sll %g1, 8, %g2
202434c: 82 00 40 02 add %g1, %g2, %g1
2024350: 85 28 60 10 sll %g1, 0x10, %g2
2024354: 82 00 40 02 add %g1, %g2, %g1
2024358: 82 20 00 01 neg %g1
202435c: 82 00 60 01 inc %g1
2024360: 10 80 00 05 b 2024374 <rtems_bdpart_read+0x240>
2024364: c2 26 c0 00 st %g1, [ %i3 ]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2024368: 10 80 00 03 b 2024374 <rtems_bdpart_read+0x240> <== NOT EXECUTED
202436c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
if (tmp > ebr) {
ebr = tmp;
} else {
esc = RTEMS_IO_ERROR;
2024370: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
2024374: d0 07 bf f8 ld [ %fp + -8 ], %o0
2024378: 80 a2 20 00 cmp %o0, 0
202437c: 26 80 00 05 bl,a 2024390 <rtems_bdpart_read+0x25c> <== NEVER TAKEN
2024380: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
2024384: 7f ff 90 44 call 2008494 <close>
2024388: 01 00 00 00 nop
}
if (block != NULL) {
202438c: d0 07 bf e8 ld [ %fp + -24 ], %o0
2024390: 80 a2 20 00 cmp %o0, 0
2024394: 02 80 00 06 be 20243ac <rtems_bdpart_read+0x278> <== NEVER TAKEN
2024398: 01 00 00 00 nop
rtems_bdbuf_release( block);
202439c: 7f ff 88 3e call 2006494 <rtems_bdbuf_release>
20243a0: 01 00 00 00 nop
20243a4: 81 c7 e0 08 ret
20243a8: 81 e8 00 00 restore
}
return esc;
}
20243ac: 81 c7 e0 08 ret <== NOT EXECUTED
20243b0: 81 e8 00 00 restore <== NOT EXECUTED
02023fac <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2023fac: 9d e3 bf a0 save %sp, -96, %sp
rtems_blkdev_bnum begin =
2023fb0: 7f ff ff c6 call 2023ec8 <rtems_uint32_from_little_endian>
2023fb4: 90 06 20 08 add %i0, 8, %o0
2023fb8: b8 10 00 08 mov %o0, %i4
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
2023fbc: 7f ff ff c3 call 2023ec8 <rtems_uint32_from_little_endian>
2023fc0: 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) {
2023fc4: e0 0e 20 04 ldub [ %i0 + 4 ], %l0
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2023fc8: ba 10 00 18 mov %i0, %i5
rtems_blkdev_bnum size =
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) {
2023fcc: 80 a4 20 00 cmp %l0, 0
2023fd0: 02 80 00 11 be 2024014 <rtems_bdpart_read_mbr_partition+0x68><== NEVER TAKEN
2023fd4: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
2023fd8: c2 06 40 00 ld [ %i1 ], %g1
2023fdc: 80 a0 40 1a cmp %g1, %i2
2023fe0: 02 80 00 0d be 2024014 <rtems_bdpart_read_mbr_partition+0x68><== NEVER TAKEN
2023fe4: b0 10 20 05 mov 5, %i0
{
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;
2023fe8: b4 02 00 1c add %o0, %i4, %i2
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
2023fec: 80 a7 00 1a cmp %i4, %i2
2023ff0: 1a 80 00 09 bcc 2024014 <rtems_bdpart_read_mbr_partition+0x68><== NEVER TAKEN
2023ff4: b0 10 20 1b mov 0x1b, %i0
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
2023ff8: 80 a4 20 05 cmp %l0, 5
2023ffc: 32 80 00 08 bne,a 202401c <rtems_bdpart_read_mbr_partition+0x70>
2024000: 90 00 60 30 add %g1, 0x30, %o0
if (ep_begin != NULL) {
2024004: 80 a6 e0 00 cmp %i3, 0
2024008: 02 80 00 03 be 2024014 <rtems_bdpart_read_mbr_partition+0x68><== NEVER TAKEN
202400c: b0 10 20 00 clr %i0
*ep_begin = begin;
2024010: f8 26 c0 00 st %i4, [ %i3 ]
2024014: 81 c7 e0 08 ret
2024018: 81 e8 00 00 restore
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
202401c: 92 10 20 00 clr %o1
2024020: 94 10 20 30 mov 0x30, %o2
2024024: 40 00 84 ec call 20453d4 <memset>
2024028: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
202402c: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
2024030: 90 10 00 10 mov %l0, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
2024034: f8 22 40 00 st %i4, [ %o1 ]
(*p)->end = end;
2024038: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
202403c: 7f ff ff d4 call 2023f8c <rtems_bdpart_to_partition_type>
2024040: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
2024044: c2 06 40 00 ld [ %i1 ], %g1
2024048: c4 0f 40 00 ldub [ %i5 ], %g2
}
return RTEMS_SUCCESSFUL;
202404c: b0 10 20 00 clr %i0
/* Set values */
(*p)->begin = begin;
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
2024050: c0 20 60 28 clr [ %g1 + 0x28 ]
2024054: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
}
return RTEMS_SUCCESSFUL;
}
2024058: 81 c7 e0 08 ret
202405c: 81 e8 00 00 restore
02023ef4 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
const rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
2023ef4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
2023ef8: d0 06 80 00 ld [ %i2 ], %o0
2023efc: 80 a2 20 00 cmp %o0, 0
2023f00: 02 80 00 07 be 2023f1c <rtems_bdpart_read_record+0x28>
2023f04: ba 10 00 18 mov %i0, %i5
sc = rtems_bdbuf_release( *block);
2023f08: 7f ff 89 63 call 2006494 <rtems_bdbuf_release>
2023f0c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2023f10: 80 a2 20 00 cmp %o0, 0
2023f14: 32 80 00 1c bne,a 2023f84 <rtems_bdpart_read_record+0x90><== NEVER TAKEN
2023f18: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
2023f1c: 90 10 00 1d mov %i5, %o0
2023f20: 92 10 00 19 mov %i1, %o1
2023f24: 7f ff 88 d2 call 200626c <rtems_bdbuf_read>
2023f28: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
2023f2c: 80 a2 20 00 cmp %o0, 0
2023f30: 32 80 00 15 bne,a 2023f84 <rtems_bdpart_read_record+0x90><== NEVER TAKEN
2023f34: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2023f38: c2 06 80 00 ld [ %i2 ], %g1
2023f3c: 80 a0 60 00 cmp %g1, 0
2023f40: 22 80 00 10 be,a 2023f80 <rtems_bdpart_read_record+0x8c> <== NEVER TAKEN
2023f44: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
2023f48: 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]
2023f4c: c6 08 a1 fe ldub [ %g2 + 0x1fe ], %g3
2023f50: 80 a0 e0 55 cmp %g3, 0x55
2023f54: 12 80 00 06 bne 2023f6c <rtems_bdpart_read_record+0x78> <== NEVER TAKEN
2023f58: 82 10 20 00 clr %g1
}
return RTEMS_SUCCESSFUL;
}
static rtems_status_code rtems_bdpart_read_record(
2023f5c: c2 08 a1 ff ldub [ %g2 + 0x1ff ], %g1
2023f60: 82 18 60 aa xor %g1, 0xaa, %g1
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]
2023f64: 80 a0 00 01 cmp %g0, %g1
2023f68: 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)) {
2023f6c: 80 a0 60 00 cmp %g1, 0
2023f70: 22 80 00 04 be,a 2023f80 <rtems_bdpart_read_record+0x8c> <== NEVER TAKEN
2023f74: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
2023f78: 81 c7 e0 08 ret
2023f7c: 91 e8 00 08 restore %g0, %o0, %o0
2023f80: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
2023f84: 81 c7 e0 08 ret <== NOT EXECUTED
2023f88: 81 e8 00 00 restore <== NOT EXECUTED
02006974 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2006974: 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);
2006978: 90 10 00 18 mov %i0, %o0
200697c: 40 01 08 e6 call 2048d14 <strlen>
2006980: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
2006984: 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
)
{
2006988: b8 10 00 18 mov %i0, %i4
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);
200698c: a6 10 00 08 mov %o0, %l3
size_t i = 0;
int fd = -1;
2006990: c2 27 bf f8 st %g1, [ %fp + -8 ]
const rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2006994: 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;
const rtems_disk_device *dd = NULL;
2006998: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
200699c: 92 07 bf f8 add %fp, -8, %o1
20069a0: 94 07 bf fc add %fp, -4, %o2
20069a4: 40 00 75 bb call 2024090 <rtems_bdpart_get_disk_data>
20069a8: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
20069ac: b0 92 20 00 orcc %o0, 0, %i0
20069b0: 12 80 00 31 bne 2006a74 <rtems_bdpart_register+0x100> <== NEVER TAKEN
20069b4: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
20069b8: d0 07 bf f8 ld [ %fp + -8 ], %o0
20069bc: 40 00 06 b6 call 2008494 <close>
20069c0: e0 18 40 00 ldd [ %g1 ], %l0
/* 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);
20069c4: 90 04 e0 04 add %l3, 4, %o0
20069c8: 40 00 08 ec call 2008d78 <malloc>
20069cc: b6 10 00 11 mov %l1, %i3
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
20069d0: b0 10 20 1a mov 0x1a, %i0
/* 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);
if (logical_disk_name == NULL) {
20069d4: 80 a2 20 00 cmp %o0, 0
20069d8: 02 80 00 27 be 2006a74 <rtems_bdpart_register+0x100> <== NEVER TAKEN
20069dc: ba 10 00 08 mov %o0, %i5
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
20069e0: 92 10 00 1c mov %i4, %o1
20069e4: 94 10 00 13 mov %l3, %o2
20069e8: 40 01 09 91 call 204902c <strncpy>
20069ec: 25 00 81 94 sethi %hi(0x2065000), %l2
logical_disk_marker = logical_disk_name + disk_name_size;
20069f0: a6 07 40 13 add %i5, %l3, %l3
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
20069f4: b8 10 20 00 clr %i4
20069f8: 10 80 00 17 b 2006a54 <rtems_bdpart_register+0xe0>
20069fc: a4 14 a2 e0 or %l2, 0x2e0, %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);
2006a00: 90 10 00 13 mov %l3, %o0
2006a04: 92 10 20 04 mov 4, %o1
2006a08: 94 10 00 12 mov %l2, %o2
2006a0c: 96 10 00 1c mov %i4, %o3
2006a10: 40 01 05 06 call 2047e28 <snprintf>
2006a14: b6 06 e0 01 inc %i3
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2006a18: 80 a2 20 03 cmp %o0, 3
2006a1c: 14 80 00 13 bg 2006a68 <rtems_bdpart_register+0xf4> <== NEVER TAKEN
2006a20: 90 10 00 10 mov %l0, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2006a24: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
2006a28: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2006a2c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
2006a30: 92 10 00 1b mov %i3, %o1
2006a34: 94 10 00 10 mov %l0, %o2
2006a38: 96 10 00 11 mov %l1, %o3
2006a3c: 9a 23 40 0c sub %o5, %o4, %o5
2006a40: 40 00 02 e5 call 20075d4 <rtems_disk_create_log>
2006a44: b2 06 60 30 add %i1, 0x30, %i1
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
2006a48: 80 a2 20 00 cmp %o0, 0
2006a4c: 12 80 00 08 bne 2006a6c <rtems_bdpart_register+0xf8> <== NEVER TAKEN
2006a50: 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) {
2006a54: 80 a7 00 1a cmp %i4, %i2
2006a58: 32 bf ff ea bne,a 2006a00 <rtems_bdpart_register+0x8c>
2006a5c: b8 07 20 01 inc %i4
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2006a60: 10 80 00 03 b 2006a6c <rtems_bdpart_register+0xf8>
2006a64: b0 10 20 00 clr %i0
2006a68: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2006a6c: 40 00 07 43 call 2008778 <free>
2006a70: 90 10 00 1d mov %i5, %o0
return esc;
}
2006a74: 81 c7 e0 08 ret
2006a78: 81 e8 00 00 restore
02006a7c <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
2006a7c: 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;
2006a80: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2006a84: 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;
2006a88: c2 27 bf fc st %g1, [ %fp + -4 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2006a8c: 92 07 bf e8 add %fp, -24, %o1
2006a90: 94 07 bc e8 add %fp, -792, %o2
2006a94: 40 00 75 a8 call 2024134 <rtems_bdpart_read>
2006a98: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
2006a9c: 80 a2 20 00 cmp %o0, 0
2006aa0: 12 80 00 05 bne 2006ab4 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
2006aa4: d4 07 bf fc ld [ %fp + -4 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
2006aa8: 90 10 00 18 mov %i0, %o0
2006aac: 7f ff ff b2 call 2006974 <rtems_bdpart_register>
2006ab0: 92 07 bc e8 add %fp, -792, %o1
}
2006ab4: 81 c7 e0 08 ret
2006ab8: 91 e8 00 08 restore %g0, %o0, %o0
02023dbc <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2023dbc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
2023dc0: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2023dc4: 40 00 98 0f call 2049e00 <strrchr> <== NOT EXECUTED
2023dc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2023dcc: ba 10 00 08 mov %o0, %i5 <== 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);
2023dd0: 40 00 93 d1 call 2048d14 <strlen> <== NOT EXECUTED
2023dd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2023dd8: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2023ddc: 40 00 93 ce call 2048d14 <strlen> <== NOT EXECUTED
2023de0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
disk_file_name += 1;
disk_file_name_size = strlen( disk_file_name);
} else {
disk_file_name = disk_name;
2023de4: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
2023de8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2023dec: 02 80 00 06 be 2023e04 <rtems_bdpart_unmount+0x48> <== NOT EXECUTED
2023df0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
disk_file_name += 1;
2023df4: a0 07 60 01 add %i5, 1, %l0 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
2023df8: 40 00 93 c7 call 2048d14 <strlen> <== NOT EXECUTED
2023dfc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2023e00: b2 10 00 08 mov %o0, %i1 <== 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);
2023e04: a2 06 40 1c add %i1, %i4, %l1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
2023e08: 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);
2023e0c: 7f ff 93 db call 2008d78 <malloc> <== NOT EXECUTED
2023e10: 90 04 60 05 add %l1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
2023e14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023e18: 02 80 00 28 be 2023eb8 <rtems_bdpart_unmount+0xfc> <== NOT EXECUTED
2023e1c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
2023e20: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2023e24: 40 00 94 82 call 204902c <strncpy> <== NOT EXECUTED
2023e28: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
2023e2c: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
2023e30: c2 2f 40 1c stb %g1, [ %i5 + %i4 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2023e34: b8 07 20 01 inc %i4 <== NOT EXECUTED
2023e38: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2023e3c: 90 07 40 1c add %i5, %i4, %o0 <== NOT EXECUTED
2023e40: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2023e44: b6 04 60 01 add %l1, 1, %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);
2023e48: 40 00 94 79 call 204902c <strncpy> <== NOT EXECUTED
2023e4c: 31 00 81 94 sethi %hi(0x2065000), %i0 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2023e50: b6 07 40 1b add %i5, %i3, %i3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2023e54: b8 10 20 00 clr %i4 <== NOT EXECUTED
2023e58: 10 80 00 14 b 2023ea8 <rtems_bdpart_unmount+0xec> <== NOT EXECUTED
2023e5c: b0 16 22 e0 or %i0, 0x2e0, %i0 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2023e60: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2023e64: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2023e68: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2023e6c: 40 00 8f ef call 2047e28 <snprintf> <== NOT EXECUTED
2023e70: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2023e74: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2023e78: 34 80 00 10 bg,a 2023eb8 <rtems_bdpart_unmount+0xfc> <== NOT EXECUTED
2023e7c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
2023e80: 40 00 15 42 call 2029388 <unmount> <== NOT EXECUTED
2023e84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv == 0) {
2023e88: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023e8c: 12 80 00 08 bne 2023eac <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
2023e90: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
2023e94: 40 00 13 c8 call 2028db4 <rmdir> <== NOT EXECUTED
2023e98: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
2023e9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023ea0: 32 80 00 06 bne,a 2023eb8 <rtems_bdpart_unmount+0xfc> <== NOT EXECUTED
2023ea4: 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) {
2023ea8: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
2023eac: 32 bf ff ed bne,a 2023e60 <rtems_bdpart_unmount+0xa4> <== NOT EXECUTED
2023eb0: b8 07 20 01 inc %i4 <== NOT EXECUTED
2023eb4: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
2023eb8: 7f ff 92 30 call 2008778 <free> <== NOT EXECUTED
2023ebc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
2023ec0: 81 c7 e0 08 ret <== NOT EXECUTED
2023ec4: 81 e8 00 00 restore <== NOT EXECUTED
02006abc <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
2006abc: 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;
2006ac0: 82 10 3f ff mov -1, %g1
const rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2006ac4: 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;
2006ac8: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
2006acc: c2 27 bf f8 st %g1, [ %fp + -8 ]
const rtems_disk_device *dd = NULL;
2006ad0: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2006ad4: 92 07 bf f8 add %fp, -8, %o1
2006ad8: 94 07 bf fc add %fp, -4, %o2
2006adc: 40 00 75 6d call 2024090 <rtems_bdpart_get_disk_data>
2006ae0: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2006ae4: b0 92 20 00 orcc %o0, 0, %i0
2006ae8: 12 80 00 12 bne 2006b30 <rtems_bdpart_unregister+0x74> <== NEVER TAKEN
2006aec: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
2006af0: 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;
2006af4: f6 00 40 00 ld [ %g1 ], %i3
2006af8: f8 00 60 04 ld [ %g1 + 4 ], %i4
2006afc: 40 00 06 66 call 2008494 <close>
2006b00: ba 10 20 00 clr %i5
/* 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) {
2006b04: 10 80 00 09 b 2006b28 <rtems_bdpart_unregister+0x6c>
2006b08: 80 a7 40 1a cmp %i5, %i2
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
2006b0c: 90 10 00 1b mov %i3, %o0
2006b10: 40 00 02 ec call 20076c0 <rtems_disk_delete>
2006b14: 92 10 00 1c mov %i4, %o1
if (sc != RTEMS_SUCCESSFUL) {
2006b18: 80 a2 20 00 cmp %o0, 0
2006b1c: 12 80 00 07 bne 2006b38 <rtems_bdpart_unregister+0x7c> <== NEVER TAKEN
2006b20: ba 07 60 01 inc %i5
/* 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) {
2006b24: 80 a7 40 1a cmp %i5, %i2
2006b28: 12 bf ff f9 bne 2006b0c <rtems_bdpart_unregister+0x50>
2006b2c: b8 07 20 01 inc %i4
2006b30: 81 c7 e0 08 ret
2006b34: 81 e8 00 00 restore
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
2006b38: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
2006b3c: 81 c7 e0 08 ret <== NOT EXECUTED
2006b40: 81 e8 00 00 restore <== NOT EXECUTED
02024484 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
2024484: 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;
2024488: a2 10 20 00 clr %l1
202448c: 80 a6 60 00 cmp %i1, 0
2024490: 02 80 00 06 be 20244a8 <rtems_bdpart_write+0x24> <== NEVER TAKEN
2024494: 82 10 00 18 mov %i0, %g1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
2024498: c4 06 40 00 ld [ %i1 ], %g2
202449c: 80 a0 a0 00 cmp %g2, 0
20244a0: 22 80 00 02 be,a 20244a8 <rtems_bdpart_write+0x24> <== ALWAYS TAKEN
20244a4: e2 0e 60 08 ldub [ %i1 + 8 ], %l1
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
20244a8: 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;
20244ac: 84 10 3f ff mov -1, %g2
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 =
20244b0: 80 a0 00 1d cmp %g0, %i5
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;
rtems_bdbuf_buffer *block = NULL;
20244b4: c0 27 bf ec clr [ %fp + -20 ]
rtems_blkdev_bnum disk_end = 0;
20244b8: c0 27 bf f0 clr [ %fp + -16 ]
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;
20244bc: c4 27 bf f4 st %g2, [ %fp + -12 ]
const rtems_disk_device *dd = NULL;
20244c0: c0 27 bf f8 clr [ %fp + -8 ]
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 =
20244c4: b8 40 3f ff addx %g0, -1, %i4
const rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
20244c8: 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 =
20244cc: b8 0f 3f c2 and %i4, -62, %i4
uint8_t *data = NULL;
int fd = -1;
const rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
20244d0: 80 a6 e0 00 cmp %i3, 0
20244d4: 02 80 00 d0 be 2024814 <rtems_bdpart_write+0x390> <== NEVER TAKEN
20244d8: b8 07 20 3f add %i4, 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
20244dc: 80 a6 a0 00 cmp %i2, 0
20244e0: 02 80 00 cd be 2024814 <rtems_bdpart_write+0x390> <== NEVER TAKEN
20244e4: b0 10 20 09 mov 9, %i0
20244e8: 80 a6 60 00 cmp %i1, 0
20244ec: 02 80 00 ca be 2024814 <rtems_bdpart_write+0x390> <== NEVER TAKEN
20244f0: 90 10 00 01 mov %g1, %o0
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
20244f4: 92 07 bf f4 add %fp, -12, %o1
20244f8: 94 07 bf f8 add %fp, -8, %o2
20244fc: 7f ff fe e5 call 2024090 <rtems_bdpart_get_disk_data>
2024500: 96 07 bf f0 add %fp, -16, %o3
if (sc != RTEMS_SUCCESSFUL) {
2024504: b0 92 20 00 orcc %o0, 0, %i0
2024508: 12 80 00 c3 bne 2024814 <rtems_bdpart_write+0x390> <== NEVER TAKEN
202450c: 80 a7 60 00 cmp %i5, 0
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2024510: 02 80 00 09 be 2024534 <rtems_bdpart_write+0xb0> <== NEVER TAKEN
2024514: c8 07 bf f0 ld [ %fp + -16 ], %g4
disk_end -= (disk_end % record_space);
2024518: fa 07 bf f0 ld [ %fp + -16 ], %i5
202451c: 92 10 00 1c mov %i4, %o1
2024520: 40 00 dc 78 call 205b700 <.urem>
2024524: 90 10 00 1d mov %i5, %o0
2024528: ba 27 40 08 sub %i5, %o0, %i5
202452c: fa 27 bf f0 st %i5, [ %fp + -16 ]
/* 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) {
2024530: c8 07 bf f0 ld [ %fp + -16 ], %g4
2024534: a0 10 00 1a mov %i2, %l0
2024538: 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) {
202453c: 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) {
2024540: c6 00 40 00 ld [ %g1 ], %g3
2024544: 80 a0 c0 04 cmp %g3, %g4
2024548: 3a 80 00 a7 bcc,a 20247e4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
202454c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
2024550: fa 00 60 04 ld [ %g1 + 4 ], %i5
2024554: 80 a7 40 04 cmp %i5, %g4
2024558: 18 80 00 9e bgu 20247d0 <rtems_bdpart_write+0x34c> <== NEVER TAKEN
202455c: 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) {
2024560: 1a 80 00 9c bcc 20247d0 <rtems_bdpart_write+0x34c> <== NEVER TAKEN
2024564: 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) {
2024568: 02 80 00 06 be 2024580 <rtems_bdpart_write+0xfc>
202456c: 84 00 a0 01 inc %g2
2024570: fa 00 7f d4 ld [ %g1 + -44 ], %i5
2024574: 80 a7 40 03 cmp %i5, %g3
2024578: 38 80 00 9b bgu,a 20247e4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
202457c: 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) {
2024580: 80 a0 80 1b cmp %g2, %i3
2024584: 12 bf ff ef bne 2024540 <rtems_bdpart_write+0xbc>
2024588: 82 00 60 30 add %g1, 0x30, %g1
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
202458c: c2 06 40 00 ld [ %i1 ], %g1
2024590: 80 a0 60 00 cmp %g1, 0
2024594: 12 80 00 94 bne 20247e4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024598: 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;
202459c: 80 a6 e0 04 cmp %i3, 4
20245a0: 08 80 00 03 bleu 20245ac <rtems_bdpart_write+0x128> <== NEVER TAKEN
20245a4: ba 10 00 1b mov %i3, %i5
20245a8: 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) {
20245ac: 82 10 00 1d mov %i5, %g1
20245b0: 80 8c 60 ff btst 0xff, %l1
20245b4: 02 80 00 10 be 20245f4 <rtems_bdpart_write+0x170> <== NEVER TAKEN
20245b8: 84 10 20 00 clr %g2
20245bc: c2 06 80 00 ld [ %i2 ], %g1
20245c0: 80 a0 60 3f cmp %g1, 0x3f
20245c4: 12 80 00 88 bne 20247e4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
20245c8: b0 10 20 0a mov 0xa, %i0
20245cc: 10 80 00 0a b 20245f4 <rtems_bdpart_write+0x170>
20245d0: 82 10 00 1d mov %i5, %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) {
20245d4: f0 00 c0 02 ld [ %g3 + %g2 ], %i0
20245d8: c8 01 3f d4 ld [ %g4 + -44 ], %g4
20245dc: 88 26 00 04 sub %i0, %g4, %g4
20245e0: 80 a1 00 1c cmp %g4, %i4
20245e4: 0a 80 00 7b bcs 20247d0 <rtems_bdpart_write+0x34c> <== NEVER TAKEN
20245e8: 84 00 a0 30 add %g2, 0x30, %g2
* 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) {
20245ec: 10 80 00 06 b 2024604 <rtems_bdpart_write+0x180>
20245f0: 82 00 60 01 inc %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
20245f4: 87 2f 60 04 sll %i5, 4, %g3
20245f8: 89 2f 60 06 sll %i5, 6, %g4
20245fc: 86 21 00 03 sub %g4, %g3, %g3
2024600: 86 06 80 03 add %i2, %g3, %g3
* 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) {
2024604: 80 a0 40 1b cmp %g1, %i3
2024608: 0a bf ff f3 bcs 20245d4 <rtems_bdpart_write+0x150>
202460c: 88 00 c0 02 add %g3, %g2, %g4
2024610: b0 10 00 1a mov %i2, %i0
2024614: a2 10 20 00 clr %l1
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
2024618: c0 2f bf ff clrb [ %fp + -1 ]
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
202461c: 90 06 20 08 add %i0, 8, %o0
2024620: 7f ff fe 90 call 2024060 <rtems_bdpart_to_mbr_partition_type>
2024624: 92 07 bf ff add %fp, -1, %o1
2024628: 80 8a 20 ff btst 0xff, %o0
202462c: 22 80 00 6e be,a 20247e4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024630: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2024634: b0 06 20 30 add %i0, 0x30, %i0
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2024638: c2 06 3f f8 ld [ %i0 + -8 ], %g1
202463c: 80 a0 60 00 cmp %g1, 0
2024640: 32 80 00 69 bne,a 20247e4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024644: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2024648: c2 06 3f fc ld [ %i0 + -4 ], %g1
202464c: 80 a0 60 ff cmp %g1, 0xff
2024650: 18 80 00 62 bgu 20247d8 <rtems_bdpart_write+0x354> <== NEVER TAKEN
2024654: a2 04 60 01 inc %l1
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
2024658: 80 a4 40 1b cmp %l1, %i3
202465c: 32 bf ff f0 bne,a 202461c <rtems_bdpart_write+0x198>
2024660: c0 2f bf ff clrb [ %fp + -1 ]
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
2024664: d0 07 bf f8 ld [ %fp + -8 ], %o0
2024668: 92 10 20 00 clr %o1
202466c: 7f ff ff 63 call 20243f8 <rtems_bdpart_new_record>
2024670: 94 07 bf ec add %fp, -20, %o2
if (sc != RTEMS_SUCCESSFUL) {
2024674: b0 92 20 00 orcc %o0, 0, %i0
2024678: 12 80 00 5c bne 20247e8 <rtems_bdpart_write+0x364> <== NEVER TAKEN
202467c: d0 07 bf f4 ld [ %fp + -12 ], %o0
}
/* Write disk ID */
rtems_uint32_to_little_endian(
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2024680: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
2024684: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2024688: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
202468c: 82 10 20 00 clr %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2024690: 88 00 c0 01 add %g3, %g1, %g4
data [i] = (uint8_t) value;
2024694: c4 29 21 b8 stb %g2, [ %g4 + 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) {
2024698: 82 00 60 01 inc %g1
202469c: 80 a0 60 04 cmp %g1, 4
20246a0: 12 bf ff fc bne 2024690 <rtems_bdpart_write+0x20c>
20246a4: 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;
20246a8: c2 07 bf ec ld [ %fp + -20 ], %g1
for (i = 0; i < ppc; ++i) {
20246ac: 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;
20246b0: e2 00 60 1c ld [ %g1 + 0x1c ], %l1
20246b4: a2 04 61 be add %l1, 0x1be, %l1
for (i = 0; i < ppc; ++i) {
20246b8: 10 80 00 0b b 20246e4 <rtems_bdpart_write+0x260>
20246bc: b0 10 00 11 mov %l1, %i0
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
20246c0: d4 04 20 04 ld [ %l0 + 4 ], %o2
20246c4: d6 0c 20 08 ldub [ %l0 + 8 ], %o3
20246c8: d8 0c 20 2f ldub [ %l0 + 0x2f ], %o4
20246cc: 90 10 00 18 mov %i0, %o0
20246d0: 94 22 80 09 sub %o2, %o1, %o2
20246d4: 7f ff ff 38 call 20243b4 <rtems_bdpart_write_mbr_partition>
20246d8: 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) {
20246dc: b2 06 60 01 inc %i1
20246e0: a0 04 20 30 add %l0, 0x30, %l0
20246e4: 80 a6 40 1d cmp %i1, %i5
20246e8: 32 bf ff f6 bne,a 20246c0 <rtems_bdpart_write+0x23c>
20246ec: d2 04 00 00 ld [ %l0 ], %o1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
20246f0: 83 2f 60 04 sll %i5, 4, %g1
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
20246f4: b0 10 20 00 clr %i0
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
20246f8: 80 a7 40 1b cmp %i5, %i3
20246fc: 02 80 00 3a be 20247e4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024700: 90 04 40 01 add %l1, %g1, %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;
2024704: 85 2f 60 06 sll %i5, 6, %g2
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2024708: d4 07 bf f0 ld [ %fp + -16 ], %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;
202470c: 82 20 80 01 sub %g2, %g1, %g1
2024710: e0 06 80 01 ld [ %i2 + %g1 ], %l0
2024714: b2 06 80 01 add %i2, %g1, %i1
2024718: a0 24 00 1c sub %l0, %i4, %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
202471c: 96 10 20 05 mov 5, %o3
2024720: 92 10 00 10 mov %l0, %o1
2024724: 94 22 80 10 sub %o2, %l0, %o2
2024728: 98 10 20 00 clr %o4
202472c: 7f ff ff 22 call 20243b4 <rtems_bdpart_write_mbr_partition>
2024730: b4 06 60 04 add %i1, 4, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2024734: 10 80 00 22 b 20247bc <rtems_bdpart_write+0x338>
2024738: b2 10 00 1d mov %i5, %i1
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
202473c: 28 80 00 0e bleu,a 2024774 <rtems_bdpart_write+0x2f0>
2024740: d2 06 bf fc ld [ %i2 + -4 ], %o1
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
2024744: c4 07 bf ec ld [ %fp + -20 ], %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;
2024748: c2 06 bf fc ld [ %i2 + -4 ], %g1
rtems_bdpart_write_mbr_partition(
202474c: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
2024750: d4 07 bf f0 ld [ %fp + -16 ], %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;
2024754: 82 20 40 1c sub %g1, %i4, %g1
rtems_bdpart_write_mbr_partition(
2024758: 90 02 21 ce add %o0, 0x1ce, %o0
202475c: 92 20 40 10 sub %g1, %l0, %o1
2024760: 94 22 80 01 sub %o2, %g1, %o2
2024764: 96 10 20 05 mov 5, %o3
2024768: 7f ff ff 13 call 20243b4 <rtems_bdpart_write_mbr_partition>
202476c: 98 10 20 00 clr %o4
0
);
}
/* New EBR */
ebr = p->begin - record_space;
2024770: d2 06 bf fc ld [ %i2 + -4 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
2024774: d0 07 bf f8 ld [ %fp + -8 ], %o0
2024778: 92 22 40 1c sub %o1, %i4, %o1
202477c: 7f ff ff 1f call 20243f8 <rtems_bdpart_new_record>
2024780: 94 07 bf ec add %fp, -20, %o2
if (sc != RTEMS_SUCCESSFUL) {
2024784: 80 a2 20 00 cmp %o0, 0
2024788: 12 80 00 16 bne 20247e0 <rtems_bdpart_write+0x35c> <== NEVER TAKEN
202478c: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2024790: d4 06 80 00 ld [ %i2 ], %o2
2024794: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2024798: d6 0e a0 04 ldub [ %i2 + 4 ], %o3
202479c: c2 06 bf fc ld [ %i2 + -4 ], %g1
20247a0: d8 0e a0 2b ldub [ %i2 + 0x2b ], %o4
20247a4: 90 02 21 be add %o0, 0x1be, %o0
20247a8: 92 10 00 1c mov %i4, %o1
20247ac: 94 22 80 01 sub %o2, %g1, %o2
20247b0: 7f ff ff 01 call 20243b4 <rtems_bdpart_write_mbr_partition>
20247b4: b2 06 60 01 inc %i1
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
20247b8: b4 06 a0 30 add %i2, 0x30, %i2
20247bc: 80 a6 40 1b cmp %i1, %i3
20247c0: 0a bf ff df bcs 202473c <rtems_bdpart_write+0x2b8>
20247c4: 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;
20247c8: 10 80 00 07 b 20247e4 <rtems_bdpart_write+0x360>
20247cc: 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;
20247d0: 10 80 00 05 b 20247e4 <rtems_bdpart_write+0x360> <== NOT EXECUTED
20247d4: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
esc = RTEMS_INVALID_ID;
20247d8: 10 80 00 03 b 20247e4 <rtems_bdpart_write+0x360> <== NOT EXECUTED
20247dc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
);
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
20247e0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
20247e4: d0 07 bf f4 ld [ %fp + -12 ], %o0
20247e8: 80 a2 20 00 cmp %o0, 0
20247ec: 26 80 00 05 bl,a 2024800 <rtems_bdpart_write+0x37c> <== NEVER TAKEN
20247f0: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED
close( fd);
20247f4: 7f ff 8f 28 call 2008494 <close>
20247f8: 01 00 00 00 nop
}
if (block != NULL) {
20247fc: d0 07 bf ec ld [ %fp + -20 ], %o0
2024800: 80 a2 20 00 cmp %o0, 0
2024804: 02 80 00 06 be 202481c <rtems_bdpart_write+0x398> <== NEVER TAKEN
2024808: 01 00 00 00 nop
rtems_bdbuf_sync( block);
202480c: 7f ff 87 7f call 2006608 <rtems_bdbuf_sync>
2024810: 01 00 00 00 nop
2024814: 81 c7 e0 08 ret
2024818: 81 e8 00 00 restore
}
return esc;
}
202481c: 81 c7 e0 08 ret <== NOT EXECUTED
2024820: 81 e8 00 00 restore <== NOT EXECUTED
020039fc <rtems_blkdev_create>:
uint32_t block_size,
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data
)
{
20039fc: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block_size > 0 && block_count > 0) {
2003a00: 80 a6 a0 00 cmp %i2, 0
2003a04: 02 80 00 2a be 2003aac <rtems_blkdev_create+0xb0>
2003a08: ba 10 00 18 mov %i0, %i5
2003a0c: 80 a6 60 00 cmp %i1, 0
2003a10: 02 80 00 25 be 2003aa4 <rtems_blkdev_create+0xa8>
2003a14: b0 10 20 0a mov 0xa, %i0
rtems_blkdev_imfs_context *ctx = calloc(1, sizeof(*ctx));
2003a18: 90 10 20 01 mov 1, %o0
2003a1c: 92 10 20 40 mov 0x40, %o1
2003a20: 40 00 05 19 call 2004e84 <calloc>
2003a24: b0 10 20 1a mov 0x1a, %i0
if (ctx != NULL) {
2003a28: 80 a2 20 00 cmp %o0, 0
2003a2c: 02 80 00 1e be 2003aa4 <rtems_blkdev_create+0xa8>
2003a30: a0 10 00 08 mov %o0, %l0
rtems_disk_device *dd = &ctx->dd;
int rv;
ctx->fd = -1;
2003a34: 82 10 3f ff mov -1, %g1
2003a38: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
dd->phys_dev = dd;
2003a3c: d0 24 20 08 st %o0, [ %l0 + 8 ]
dd->size = block_count;
2003a40: f4 22 20 1c st %i2, [ %o0 + 0x1c ]
dd->media_block_size = block_size;
2003a44: f2 22 20 24 st %i1, [ %o0 + 0x24 ]
dd->block_size = block_size;
2003a48: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
dd->ioctl = handler;
2003a4c: f6 22 20 28 st %i3, [ %o0 + 0x28 ]
dd->driver_data = driver_data;
2003a50: f8 22 20 2c st %i4, [ %o0 + 0x2c ]
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) != 0) {
2003a54: 13 08 00 10 sethi %hi(0x20004000), %o1
2003a58: 94 02 20 0c add %o0, 0xc, %o2
2003a5c: 9f c6 c0 00 call %i3
2003a60: 92 12 62 08 or %o1, 0x208, %o1
2003a64: 80 a2 20 00 cmp %o0, 0
2003a68: 32 80 00 02 bne,a 2003a70 <rtems_blkdev_create+0x74> <== ALWAYS TAKEN
2003a6c: c0 24 20 0c clr [ %l0 + 0xc ]
dd->capabilities = 0;
}
rv = IMFS_make_generic_node(
2003a70: 90 10 00 1d mov %i5, %o0
2003a74: 13 00 00 18 sethi %hi(0x6000), %o1
2003a78: 15 00 80 7d sethi %hi(0x201f400), %o2
2003a7c: 92 12 61 ff or %o1, 0x1ff, %o1
2003a80: 94 12 a1 20 or %o2, 0x120, %o2
2003a84: 96 10 00 10 mov %l0, %o3
2003a88: 40 00 03 58 call 20047e8 <IMFS_make_generic_node>
2003a8c: b0 10 20 00 clr %i0
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
2003a90: 80 a2 20 00 cmp %o0, 0
2003a94: 02 80 00 04 be 2003aa4 <rtems_blkdev_create+0xa8>
2003a98: 90 10 00 10 mov %l0, %o0
free(ctx);
2003a9c: 40 00 05 ca call 20051c4 <free>
2003aa0: b0 10 20 0d mov 0xd, %i0
2003aa4: 81 c7 e0 08 ret
2003aa8: 81 e8 00 00 restore
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_NUMBER;
2003aac: b0 10 20 0a mov 0xa, %i0
}
return sc;
}
2003ab0: 81 c7 e0 08 ret
2003ab4: 81 e8 00 00 restore
02003ab8 <rtems_blkdev_create_partition>:
const char *partition,
const char *device,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count
)
{
2003ab8: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(device, O_RDWR);
2003abc: 92 10 20 02 mov 2, %o1
2003ac0: 90 10 00 19 mov %i1, %o0
2003ac4: 40 00 0a 05 call 20062d8 <open>
2003ac8: ba 10 00 18 mov %i0, %i5
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
}
} else {
sc = RTEMS_INVALID_ID;
2003acc: b0 10 20 04 mov 4, %i0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(device, O_RDWR);
if (fd >= 0) {
2003ad0: 80 a2 20 00 cmp %o0, 0
2003ad4: 06 80 00 3b bl 2003bc0 <rtems_blkdev_create_partition+0x108>
2003ad8: b2 10 00 08 mov %o0, %i1
int rv;
struct stat st;
rv = fstat(fd, &st);
2003adc: 92 07 bf b0 add %fp, -80, %o1
2003ae0: 40 00 05 e3 call 200526c <fstat>
2003ae4: b0 10 20 15 mov 0x15, %i0
if (rv == 0 && S_ISBLK(st.st_mode)) {
2003ae8: 80 a2 20 00 cmp %o0, 0
2003aec: 12 80 00 33 bne 2003bb8 <rtems_blkdev_create_partition+0x100><== NEVER TAKEN
2003af0: e0 07 bf bc ld [ %fp + -68 ], %l0
2003af4: 03 00 00 3c sethi %hi(0xf000), %g1
2003af8: a0 0c 00 01 and %l0, %g1, %l0
2003afc: 03 00 00 18 sethi %hi(0x6000), %g1
2003b00: 80 a4 00 01 cmp %l0, %g1
2003b04: 12 80 00 2d bne 2003bb8 <rtems_blkdev_create_partition+0x100>
2003b08: 90 10 00 19 mov %i1, %o0
rtems_disk_device *dd;
rv = ioctl(fd, RTEMS_BLKIO_GETDISKDEV, &dd);
2003b0c: 13 10 01 10 sethi %hi(0x40044000), %o1
2003b10: 94 07 bf fc add %fp, -4, %o2
2003b14: 92 12 62 09 or %o1, 0x209, %o1
2003b18: 40 00 06 2c call 20053c8 <ioctl>
2003b1c: b0 10 20 18 mov 0x18, %i0
if (rv == 0) {
2003b20: 80 a2 20 00 cmp %o0, 0
2003b24: 12 80 00 25 bne 2003bb8 <rtems_blkdev_create_partition+0x100>
2003b28: e2 07 bf fc ld [ %fp + -4 ], %l1
rtems_blkdev_bnum device_block_count = rtems_disk_get_block_count(dd);
if (
2003b2c: 80 a6 e0 00 cmp %i3, 0
2003b30: 02 80 00 1f be 2003bac <rtems_blkdev_create_partition+0xf4>
2003b34: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
2003b38: 80 a6 80 01 cmp %i2, %g1
2003b3c: 1a 80 00 1f bcc 2003bb8 <rtems_blkdev_create_partition+0x100>
2003b40: b0 10 20 0a mov 0xa, %i0
block_begin < device_block_count
&& block_count > 0
&& block_count <= device_block_count - block_begin
2003b44: 82 20 40 1a sub %g1, %i2, %g1
2003b48: 80 a6 c0 01 cmp %i3, %g1
2003b4c: 18 80 00 1b bgu 2003bb8 <rtems_blkdev_create_partition+0x100>
2003b50: 01 00 00 00 nop
) {
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
2003b54: 40 00 07 b2 call 2005a1c <malloc>
2003b58: 90 10 20 40 mov 0x40, %o0 ! 40 <PROM_START+0x40>
if (ctx != NULL) {
2003b5c: b8 92 20 00 orcc %o0, 0, %i4
2003b60: 02 80 00 15 be 2003bb4 <rtems_blkdev_create_partition+0xfc>
2003b64: 92 10 00 11 mov %l1, %o1
memcpy(&ctx->dd, dd, sizeof(ctx->dd));
2003b68: 40 00 42 de call 20146e0 <memcpy>
2003b6c: 94 10 20 38 mov 0x38, %o2
ctx->dd.start = block_begin;
ctx->dd.size = block_count;
ctx->fd = fd;
rv = IMFS_make_generic_node(
2003b70: 90 10 00 1d mov %i5, %o0
if (ctx != NULL) {
memcpy(&ctx->dd, dd, sizeof(ctx->dd));
ctx->dd.start = block_begin;
ctx->dd.size = block_count;
2003b74: f4 3f 20 18 std %i2, [ %i4 + 0x18 ]
ctx->fd = fd;
2003b78: f2 27 20 38 st %i1, [ %i4 + 0x38 ]
rv = IMFS_make_generic_node(
2003b7c: 92 14 21 ff or %l0, 0x1ff, %o1
2003b80: 15 00 80 7d sethi %hi(0x201f400), %o2
2003b84: 96 10 00 1c mov %i4, %o3
2003b88: 94 12 a1 20 or %o2, 0x120, %o2
2003b8c: 40 00 03 17 call 20047e8 <IMFS_make_generic_node>
2003b90: b0 10 20 00 clr %i0
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
2003b94: 80 a2 20 00 cmp %o0, 0
2003b98: 02 80 00 0a be 2003bc0 <rtems_blkdev_create_partition+0x108>
2003b9c: 90 10 00 1c mov %i4, %o0
free(ctx);
2003ba0: 40 00 05 89 call 20051c4 <free>
2003ba4: b0 10 20 0d mov 0xd, %i0
2003ba8: 30 80 00 04 b,a 2003bb8 <rtems_blkdev_create_partition+0x100>
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_NUMBER;
2003bac: 10 80 00 03 b 2003bb8 <rtems_blkdev_create_partition+0x100>
2003bb0: b0 10 20 0a mov 0xa, %i0
if (rv != 0) {
free(ctx);
sc = RTEMS_UNSATISFIED;
}
} else {
sc = RTEMS_NO_MEMORY;
2003bb4: b0 10 20 1a mov 0x1a, %i0
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
2003bb8: 40 00 04 ca call 2004ee0 <close>
2003bbc: 90 10 00 19 mov %i1, %o0
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
2003bc0: 81 c7 e0 08 ret
2003bc4: 81 e8 00 00 restore
0200f124 <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)
{
200f124: 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;
200f128: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
200f12c: 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;
200f130: d0 00 60 40 ld [ %g1 + 0x40 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
200f134: 03 30 06 10 sethi %hi(0xc0184000), %g1
200f138: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
200f13c: 80 a2 40 01 cmp %o1, %g1
200f140: 02 80 00 07 be 200f15c <rtems_blkdev_generic_ioctl+0x38> <== NEVER TAKEN
200f144: 82 10 3f ff mov -1, %g1
{
args->ioctl_return = dd->ioctl(dd,
200f148: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
200f14c: 9f c0 40 00 call %g1
200f150: d4 06 a0 08 ld [ %i2 + 8 ], %o2
200f154: 10 80 00 03 b 200f160 <rtems_blkdev_generic_ioctl+0x3c>
200f158: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
200f15c: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
200f160: 81 c7 e0 08 ret
200f164: 91 e8 20 00 restore %g0, 0, %o0
0200ef04 <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)
{
200ef04: 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;
200ef08: 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);
200ef0c: 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;
200ef10: e2 00 60 40 ld [ %g1 + 0x40 ], %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);
200ef14: 92 10 00 1d mov %i5, %o1
{
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;
200ef18: f2 04 60 20 ld [ %l1 + 0x20 ], %i1
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200ef1c: 94 10 20 00 clr %o2
200ef20: 96 10 00 19 mov %i1, %o3
200ef24: 40 00 36 b2 call 201c9ec <__divdi3>
200ef28: 90 10 00 1c mov %i4, %o0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200ef2c: 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);
200ef30: a4 10 00 09 mov %o1, %l2
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200ef34: 94 10 20 00 clr %o2
200ef38: 92 10 00 1d mov %i5, %o1
200ef3c: 96 10 00 19 mov %i1, %o3
200ef40: 40 00 37 91 call 201cd84 <__moddi3>
200ef44: 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;
200ef48: 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);
200ef4c: a6 10 00 09 mov %o1, %l3
args->bytes_moved = 0;
200ef50: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200ef54: 10 80 00 1c b 200efc4 <rtems_blkdev_generic_read+0xc0>
200ef58: ba 10 20 00 clr %i5
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200ef5c: 90 10 00 11 mov %l1, %o0
200ef60: 7f ff fd eb call 200e70c <rtems_bdbuf_read>
200ef64: 94 07 bf fc add %fp, -4, %o2
if (rc != RTEMS_SUCCESSFUL)
200ef68: 80 a2 20 00 cmp %o0, 0
200ef6c: 12 80 00 1a bne 200efd4 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200ef70: b8 26 40 13 sub %i1, %l3, %i4
break;
copy = block_size - blkofs;
200ef74: 80 a7 00 1b cmp %i4, %i3
200ef78: 38 80 00 02 bgu,a 200ef80 <rtems_blkdev_generic_read+0x7c><== NEVER TAKEN
200ef7c: b8 10 00 1b mov %i3, %i4 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
200ef80: c2 07 bf fc ld [ %fp + -4 ], %g1
200ef84: 94 10 00 1c mov %i4, %o2
200ef88: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
200ef8c: 90 10 00 10 mov %l0, %o0
200ef90: 40 00 13 bd call 2013e84 <memcpy>
200ef94: 92 02 40 13 add %o1, %l3, %o1
rc = rtems_bdbuf_release(diskbuf);
200ef98: d0 07 bf fc ld [ %fp + -4 ], %o0
200ef9c: 7f ff fe 66 call 200e934 <rtems_bdbuf_release>
200efa0: ba 07 60 01 inc %i5
args->bytes_moved += copy;
200efa4: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
if (rc != RTEMS_SUCCESSFUL)
200efa8: 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;
200efac: 82 00 40 1c add %g1, %i4, %g1
if (rc != RTEMS_SUCCESSFUL)
200efb0: 12 80 00 09 bne 200efd4 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200efb4: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
200efb8: b6 26 c0 1c sub %i3, %i4, %i3
buf += copy;
200efbc: a0 04 00 1c add %l0, %i4, %l0
blkofs = 0;
200efc0: a6 10 20 00 clr %l3
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)
200efc4: 80 a6 e0 00 cmp %i3, 0
200efc8: 12 bf ff e5 bne 200ef5c <rtems_blkdev_generic_read+0x58>
200efcc: 92 07 40 12 add %i5, %l2, %o1
200efd0: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200efd4: 81 c7 e0 08 ret
200efd8: 91 e8 00 08 restore %g0, %o0, %o0
0200efdc <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)
{
200efdc: 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;
200efe0: 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);
200efe4: 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;
200efe8: e2 00 60 40 ld [ %g1 + 0x40 ], %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);
200efec: 92 10 00 1d mov %i5, %o1
{
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;
200eff0: f2 04 60 20 ld [ %l1 + 0x20 ], %i1
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200eff4: 94 10 20 00 clr %o2
200eff8: 96 10 00 19 mov %i1, %o3
200effc: 40 00 36 7c call 201c9ec <__divdi3>
200f000: 90 10 00 1c mov %i4, %o0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f004: 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);
200f008: a4 10 00 09 mov %o1, %l2
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f00c: 94 10 20 00 clr %o2
200f010: 92 10 00 1d mov %i5, %o1
200f014: 96 10 00 19 mov %i1, %o3
200f018: 40 00 37 5b call 201cd84 <__moddi3>
200f01c: 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;
200f020: 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);
200f024: ba 10 00 09 mov %o1, %i5
args->bytes_moved = 0;
200f028: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200f02c: 10 80 00 26 b 200f0c4 <rtems_blkdev_generic_write+0xe8>
200f030: a6 10 20 00 clr %l3
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200f034: 90 10 00 11 mov %l1, %o0
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
200f038: 80 a6 c0 19 cmp %i3, %i1
200f03c: 0a 80 00 09 bcs 200f060 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f040: 94 07 bf fc add %fp, -4, %o2
200f044: 80 a7 60 00 cmp %i5, 0
200f048: 12 80 00 06 bne 200f060 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f04c: 01 00 00 00 nop
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200f050: 7f ff fd 86 call 200e668 <rtems_bdbuf_get>
200f054: 01 00 00 00 nop
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
200f058: 10 80 00 05 b 200f06c <rtems_blkdev_generic_write+0x90>
200f05c: 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);
200f060: 7f ff fd ab call 200e70c <rtems_bdbuf_read> <== NOT EXECUTED
200f064: 01 00 00 00 nop <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
200f068: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200f06c: 12 80 00 1a bne 200f0d4 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f070: b8 26 40 1d sub %i1, %i5, %i4
break;
copy = block_size - blkofs;
200f074: 80 a7 00 1b cmp %i4, %i3
200f078: 38 80 00 02 bgu,a 200f080 <rtems_blkdev_generic_write+0xa4><== NEVER TAKEN
200f07c: b8 10 00 1b mov %i3, %i4 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
200f080: c2 07 bf fc ld [ %fp + -4 ], %g1
200f084: 92 10 00 10 mov %l0, %o1
200f088: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
200f08c: 94 10 00 1c mov %i4, %o2
200f090: 40 00 13 7d call 2013e84 <memcpy>
200f094: 90 02 00 1d add %o0, %i5, %o0
args->bytes_moved += copy;
200f098: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
200f09c: 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;
200f0a0: 82 00 40 1c add %g1, %i4, %g1
rc = rtems_bdbuf_release_modified(diskbuf);
200f0a4: a6 04 e0 01 inc %l3
200f0a8: 7f ff fe 5c call 200ea18 <rtems_bdbuf_release_modified>
200f0ac: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
200f0b0: 80 a2 20 00 cmp %o0, 0
200f0b4: 12 80 00 08 bne 200f0d4 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f0b8: b6 26 c0 1c sub %i3, %i4, %i3
break;
count -= copy;
buf += copy;
200f0bc: a0 04 00 1c add %l0, %i4, %l0
blkofs = 0;
200f0c0: ba 10 20 00 clr %i5
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)
200f0c4: 80 a6 e0 00 cmp %i3, 0
200f0c8: 12 bf ff db bne 200f034 <rtems_blkdev_generic_write+0x58>
200f0cc: 92 04 c0 12 add %l3, %l2, %o1
200f0d0: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200f0d4: 81 c7 e0 08 ret
200f0d8: 91 e8 00 08 restore %g0, %o0, %o0
02003974 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
2003974: 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;
2003978: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
int rv = 0;
200397c: b0 10 20 00 clr %i0 <== NOT EXECUTED
const rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
const rtems_disk_device *dd = &ctx->dd;
rtems_status_code sc = rtems_bdbuf_syncdev(dd);
2003980: 40 00 2f 48 call 200f6a0 <rtems_bdbuf_syncdev> <== NOT EXECUTED
2003984: d0 00 60 50 ld [ %g1 + 0x50 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
2003988: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200398c: 02 80 00 06 be 20039a4 <rtems_blkdev_imfs_fsync_or_fdatasync+0x30><== NOT EXECUTED
2003990: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
2003994: 40 00 40 c9 call 2013cb8 <__errno> <== NOT EXECUTED
2003998: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
200399c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20039a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20039a4: 81 c7 e0 08 ret <== NOT EXECUTED
20039a8: 81 e8 00 00 restore <== NOT EXECUTED
020039ac <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
20039ac: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
20039b0: 03 30 06 10 sethi %hi(0xc0184000), %g1
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
20039b4: 92 10 00 19 mov %i1, %o1
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
20039b8: 82 10 62 01 or %g1, 0x201, %g1
20039bc: 80 a6 40 01 cmp %i1, %g1
20039c0: 02 80 00 09 be 20039e4 <rtems_blkdev_imfs_ioctl+0x38> <== NEVER TAKEN
20039c4: 94 10 00 1a mov %i2, %o2
20039c8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
20039cc: 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);
20039d0: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
20039d4: 9f c0 40 00 call %g1
20039d8: 01 00 00 00 nop
20039dc: 81 c7 e0 08 ret
20039e0: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
20039e4: 40 00 40 b5 call 2013cb8 <__errno> <== NOT EXECUTED
20039e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20039ec: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20039f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20039f4: 81 c7 e0 08 ret <== NOT EXECUTED
20039f8: 81 e8 00 00 restore <== NOT EXECUTED
0200380c <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
200380c: 9d e3 bf 98 save %sp, -104, %sp
2003810: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
int rv;
const rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
const rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
2003814: f8 1e 20 10 ldd [ %i0 + 0x10 ], %i4
2003818: e2 00 60 50 ld [ %g1 + 0x50 ], %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
200381c: 90 10 00 1c mov %i4, %o0
int rv;
const rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
const 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);
2003820: f6 04 60 20 ld [ %l1 + 0x20 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003824: 92 10 00 1d mov %i5, %o1
2003828: b1 3e e0 1f sra %i3, 0x1f, %i0
200382c: 96 10 00 1b mov %i3, %o3
2003830: 40 00 66 bd call 201d324 <__divdi3>
2003834: 94 10 00 18 mov %i0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003838: 90 10 00 1c mov %i4, %o0
const rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
const 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);
200383c: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
2003840: 94 10 00 18 mov %i0, %o2
2003844: 92 10 00 1d mov %i5, %o1
2003848: 96 10 00 1b mov %i3, %o3
200384c: 40 00 67 9c call 201d6bc <__moddi3>
2003850: b8 10 00 1a mov %i2, %i4
char *dst = buffer;
while (remaining > 0) {
2003854: 10 80 00 1a b 20038bc <rtems_blkdev_imfs_read+0xb0>
2003858: ba 10 00 09 mov %o1, %i5
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
200385c: 92 10 00 10 mov %l0, %o1
2003860: 40 00 2e 54 call 200f1b0 <rtems_bdbuf_read>
2003864: 94 07 bf fc add %fp, -4, %o2
if (sc == RTEMS_SUCCESSFUL) {
2003868: 80 a2 20 00 cmp %o0, 0
200386c: 12 80 00 1a bne 20038d4 <rtems_blkdev_imfs_read+0xc8> <== NEVER TAKEN
2003870: 01 00 00 00 nop
ssize_t copy = block_size - block_offset;
2003874: b0 26 c0 1d sub %i3, %i5, %i0
2003878: 80 a6 00 1c cmp %i0, %i4
200387c: 34 80 00 02 bg,a 2003884 <rtems_blkdev_imfs_read+0x78>
2003880: b0 10 00 1c mov %i4, %i0
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
2003884: c2 07 bf fc ld [ %fp + -4 ], %g1
2003888: 94 10 00 18 mov %i0, %o2
200388c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2003890: 90 10 00 19 mov %i1, %o0
2003894: 40 00 43 93 call 20146e0 <memcpy>
2003898: 92 02 40 1d add %o1, %i5, %o1
sc = rtems_bdbuf_release(bd);
200389c: 40 00 2e cf call 200f3d8 <rtems_bdbuf_release>
20038a0: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
20038a4: 80 a2 20 00 cmp %o0, 0
20038a8: 12 80 00 0b bne 20038d4 <rtems_blkdev_imfs_read+0xc8> <== NEVER TAKEN
20038ac: b8 27 00 18 sub %i4, %i0, %i4
block_offset = 0;
remaining -= copy;
dst += copy;
20038b0: b2 06 40 18 add %i1, %i0, %i1
++block;
20038b4: 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;
20038b8: ba 10 20 00 clr %i5
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) {
20038bc: 80 a7 20 00 cmp %i4, 0
20038c0: 14 bf ff e7 bg 200385c <rtems_blkdev_imfs_read+0x50>
20038c4: 90 10 00 11 mov %l1, %o0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20038c8: 80 a7 20 00 cmp %i4, 0
20038cc: 02 80 00 06 be 20038e4 <rtems_blkdev_imfs_read+0xd8> <== ALWAYS TAKEN
20038d0: b0 10 00 1a mov %i2, %i0
rv = (ssize_t) count;
} else {
errno = EIO;
20038d4: 40 00 40 f9 call 2013cb8 <__errno> <== NOT EXECUTED
20038d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20038dc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20038e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20038e4: 81 c7 e0 08 ret
20038e8: 81 e8 00 00 restore
020036f4 <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
20036f4: 9d e3 bf 98 save %sp, -104, %sp
20036f8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
int rv;
const rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
const rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
20036fc: f8 1e 20 10 ldd [ %i0 + 0x10 ], %i4
2003700: e2 00 60 50 ld [ %g1 + 0x50 ], %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003704: 90 10 00 1c mov %i4, %o0
int rv;
const rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
const 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);
2003708: f6 04 60 20 ld [ %l1 + 0x20 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
200370c: 92 10 00 1d mov %i5, %o1
2003710: b1 3e e0 1f sra %i3, 0x1f, %i0
2003714: 96 10 00 1b mov %i3, %o3
2003718: 40 00 67 03 call 201d324 <__divdi3>
200371c: 94 10 00 18 mov %i0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003720: 90 10 00 1c mov %i4, %o0
const rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
const 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);
2003724: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
2003728: 94 10 00 18 mov %i0, %o2
200372c: 92 10 00 1d mov %i5, %o1
2003730: 96 10 00 1b mov %i3, %o3
2003734: 40 00 67 e2 call 201d6bc <__moddi3>
2003738: b8 10 00 1a mov %i2, %i4
const char *src = buffer;
while (remaining > 0) {
200373c: 10 80 00 28 b 20037dc <rtems_blkdev_imfs_write+0xe8>
2003740: ba 10 00 09 mov %o1, %i5
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
2003744: 16 80 00 03 bge 2003750 <rtems_blkdev_imfs_write+0x5c>
2003748: 82 10 20 01 mov 1, %g1
200374c: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
2003750: 90 10 00 11 mov %l1, %o0
2003754: 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) {
2003758: 80 88 60 ff btst 0xff, %g1
200375c: 02 80 00 09 be 2003780 <rtems_blkdev_imfs_write+0x8c>
2003760: 94 07 bf fc add %fp, -4, %o2
2003764: 80 a7 60 00 cmp %i5, 0
2003768: 12 80 00 06 bne 2003780 <rtems_blkdev_imfs_write+0x8c>
200376c: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
2003770: 40 00 2e 67 call 200f10c <rtems_bdbuf_get>
2003774: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
2003778: 10 80 00 05 b 200378c <rtems_blkdev_imfs_write+0x98>
200377c: 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);
2003780: 40 00 2e 8c call 200f1b0 <rtems_bdbuf_read>
2003784: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
2003788: 80 a2 20 00 cmp %o0, 0
200378c: 12 80 00 1a bne 20037f4 <rtems_blkdev_imfs_write+0x100> <== NEVER TAKEN
2003790: 01 00 00 00 nop
ssize_t copy = block_size - block_offset;
2003794: b0 26 c0 1d sub %i3, %i5, %i0
2003798: 80 a6 00 1c cmp %i0, %i4
200379c: 34 80 00 02 bg,a 20037a4 <rtems_blkdev_imfs_write+0xb0>
20037a0: b0 10 00 1c mov %i4, %i0
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
20037a4: c2 07 bf fc ld [ %fp + -4 ], %g1
20037a8: 92 10 00 19 mov %i1, %o1
20037ac: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20037b0: 94 10 00 18 mov %i0, %o2
20037b4: 40 00 43 cb call 20146e0 <memcpy>
20037b8: 90 02 00 1d add %o0, %i5, %o0
sc = rtems_bdbuf_release_modified(bd);
20037bc: 40 00 2f 40 call 200f4bc <rtems_bdbuf_release_modified>
20037c0: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
20037c4: 80 a2 20 00 cmp %o0, 0
20037c8: 12 80 00 0b bne 20037f4 <rtems_blkdev_imfs_write+0x100> <== NEVER TAKEN
20037cc: b8 27 00 18 sub %i4, %i0, %i4
block_offset = 0;
remaining -= copy;
src += copy;
20037d0: b2 06 40 18 add %i1, %i0, %i1
++block;
20037d4: 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;
20037d8: ba 10 20 00 clr %i5
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) {
20037dc: 80 a7 20 00 cmp %i4, 0
20037e0: 14 bf ff d9 bg 2003744 <rtems_blkdev_imfs_write+0x50>
20037e4: 80 a7 00 1b cmp %i4, %i3
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20037e8: 80 a7 20 00 cmp %i4, 0
20037ec: 02 80 00 06 be 2003804 <rtems_blkdev_imfs_write+0x110> <== ALWAYS TAKEN
20037f0: b0 10 00 1a mov %i2, %i0
rv = (ssize_t) count;
} else {
errno = EIO;
20037f4: 40 00 41 31 call 2013cb8 <__errno> <== NOT EXECUTED
20037f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20037fc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2003800: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003804: 81 c7 e0 08 ret
2003808: 81 e8 00 00 restore
0200ee14 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200ee14: 9d e3 bf a0 save %sp, -96, %sp
size_t *arg_size = argp;
int rc = 0;
switch (req)
200ee18: 03 10 01 10 sethi %hi(0x40044000), %g1
200ee1c: 84 10 62 03 or %g1, 0x203, %g2 ! 40044203 <RAM_END+0x3dc44203>
200ee20: 80 a6 40 02 cmp %i1, %g2
200ee24: 02 80 00 1d be 200ee98 <rtems_blkdev_ioctl+0x84>
200ee28: 90 10 00 18 mov %i0, %o0
200ee2c: 80 a6 40 02 cmp %i1, %g2
200ee30: 18 80 00 0c bgu 200ee60 <rtems_blkdev_ioctl+0x4c>
200ee34: 84 10 62 09 or %g1, 0x209, %g2
200ee38: 05 08 00 10 sethi %hi(0x20004000), %g2
200ee3c: 84 10 a2 06 or %g2, 0x206, %g2 ! 20004206 <RAM_END+0x1dc04206>
200ee40: 80 a6 40 02 cmp %i1, %g2
200ee44: 02 80 00 1c be 200eeb4 <rtems_blkdev_ioctl+0xa0>
200ee48: 82 10 62 02 or %g1, 0x202, %g1
200ee4c: 80 a6 40 01 cmp %i1, %g1
200ee50: 12 80 00 27 bne 200eeec <rtems_blkdev_ioctl+0xd8>
200ee54: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
200ee58: 10 80 00 0e b 200ee90 <rtems_blkdev_ioctl+0x7c>
200ee5c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
switch (req)
200ee60: 80 a6 40 02 cmp %i1, %g2
200ee64: 02 80 00 1f be 200eee0 <rtems_blkdev_ioctl+0xcc>
200ee68: 05 20 01 10 sethi %hi(0x80044000), %g2
200ee6c: 84 10 a2 04 or %g2, 0x204, %g2 ! 80044204 <RAM_END+0x7dc44204>
200ee70: 80 a6 40 02 cmp %i1, %g2
200ee74: 02 80 00 0b be 200eea0 <rtems_blkdev_ioctl+0x8c>
200ee78: 82 10 62 05 or %g1, 0x205, %g1
200ee7c: 80 a6 40 01 cmp %i1, %g1
200ee80: 12 80 00 1b bne 200eeec <rtems_blkdev_ioctl+0xd8> <== NEVER TAKEN
200ee84: 01 00 00 00 nop
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
200ee88: 10 80 00 09 b 200eeac <rtems_blkdev_ioctl+0x98>
200ee8c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
200ee90: 10 80 00 15 b 200eee4 <rtems_blkdev_ioctl+0xd0>
200ee94: c2 26 80 00 st %g1, [ %i2 ]
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
200ee98: 10 80 00 05 b 200eeac <rtems_blkdev_ioctl+0x98>
200ee9c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
200eea0: c2 06 80 00 ld [ %i2 ], %g1
200eea4: 10 80 00 10 b 200eee4 <rtems_blkdev_ioctl+0xd0>
200eea8: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
200eeac: 10 80 00 0e b 200eee4 <rtems_blkdev_ioctl+0xd0>
200eeb0: c2 26 80 00 st %g1, [ %i2 ]
break;
case RTEMS_BLKIO_SYNCDEV:
{
rtems_status_code sc = rtems_bdbuf_syncdev(dd);
200eeb4: 7f ff ff 52 call 200ebfc <rtems_bdbuf_syncdev>
200eeb8: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL) {
200eebc: 80 a2 20 00 cmp %o0, 0
200eec0: 02 80 00 0f be 200eefc <rtems_blkdev_ioctl+0xe8> <== ALWAYS TAKEN
200eec4: 01 00 00 00 nop
errno = EIO;
200eec8: 40 00 11 93 call 2013514 <__errno> <== NOT EXECUTED
200eecc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
200eed0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
200eed4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200eed8: 81 c7 e0 08 ret <== NOT EXECUTED
200eedc: 81 e8 00 00 restore <== NOT EXECUTED
}
case RTEMS_BLKIO_GETDISKDEV:
{
rtems_disk_device **dd_ptr = argp;
*dd_ptr = dd;
200eee0: f0 26 80 00 st %i0, [ %i2 ]
break;
200eee4: 81 c7 e0 08 ret
200eee8: 91 e8 20 00 restore %g0, 0, %o0
}
default:
errno = EINVAL;
200eeec: 40 00 11 8a call 2013514 <__errno>
200eef0: b0 10 3f ff mov -1, %i0
200eef4: 82 10 20 16 mov 0x16, %g1
200eef8: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
break;
}
return rc;
}
200eefc: 81 c7 e0 08 ret
200ef00: 81 e8 00 00 restore
020084a8 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
20084a8: 9d e3 bf 98 save %sp, -104, %sp
20084ac: 10 80 00 09 b 20084d0 <rtems_chain_get_with_wait+0x28>
20084b0: ba 10 00 18 mov %i0, %i5
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
20084b4: 92 10 20 00 clr %o1
20084b8: 94 10 00 1a mov %i2, %o2
20084bc: 7f ff fd 03 call 20078c8 <rtems_event_receive>
20084c0: 96 07 bf fc add %fp, -4, %o3
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
20084c4: 80 a2 20 00 cmp %o0, 0
20084c8: 32 80 00 09 bne,a 20084ec <rtems_chain_get_with_wait+0x44><== ALWAYS TAKEN
20084cc: f8 26 c0 00 st %i4, [ %i3 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
20084d0: 40 00 01 87 call 2008aec <_Chain_Get>
20084d4: 90 10 00 1d mov %i5, %o0
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
20084d8: b8 92 20 00 orcc %o0, 0, %i4
20084dc: 02 bf ff f6 be 20084b4 <rtems_chain_get_with_wait+0xc>
20084e0: 90 10 00 19 mov %i1, %o0
20084e4: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
20084e8: f8 26 c0 00 st %i4, [ %i3 ]
return sc;
}
20084ec: 81 c7 e0 08 ret
20084f0: 91 e8 00 08 restore %g0, %o0, %o0
02003ba4 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2003ba4: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
2003ba8: 80 a6 60 00 cmp %i1, 0
2003bac: 02 80 00 7c be 2003d9c <rtems_cpu_usage_report_with_plugin+0x1f8><== NEVER TAKEN
2003bb0: 03 00 80 83 sethi %hi(0x2020c00), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
2003bb4: c0 27 bf e8 clr [ %fp + -24 ]
2003bb8: c0 27 bf ec clr [ %fp + -20 ]
* 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;
2003bbc: e8 18 61 00 ldd [ %g1 + 0x100 ], %l4
}
}
}
#endif
(*print)(
2003bc0: 90 10 00 18 mov %i0, %o0
2003bc4: 13 00 80 75 sethi %hi(0x201d400), %o1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2003bc8: 23 00 80 75 sethi %hi(0x201d400), %l1
}
}
}
#endif
(*print)(
2003bcc: 92 12 62 28 or %o1, 0x228, %o1
2003bd0: 9f c6 40 00 call %i1
2003bd4: 25 00 80 75 sethi %hi(0x201d400), %l2
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003bd8: a0 10 20 01 mov 1, %l0
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2003bdc: a2 14 63 a0 or %l1, 0x3a0, %l1
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003be0: a4 14 a3 b8 or %l2, 0x3b8, %l2
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
2003be4: 83 2c 20 02 sll %l0, 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 ];
2003be8: 05 00 80 81 sethi %hi(0x2020400), %g2
2003bec: 84 10 a2 88 or %g2, 0x288, %g2 ! 2020688 <_Objects_Information_table>
2003bf0: c2 00 80 01 ld [ %g2 + %g1 ], %g1
2003bf4: f4 00 60 04 ld [ %g1 + 4 ], %i2
if ( information ) {
2003bf8: 80 a6 a0 00 cmp %i2, 0
2003bfc: 12 80 00 49 bne 2003d20 <rtems_cpu_usage_report_with_plugin+0x17c><== ALWAYS TAKEN
2003c00: b6 10 20 01 mov 1, %i3
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003c04: 10 80 00 4c b 2003d34 <rtems_cpu_usage_report_with_plugin+0x190><== NOT EXECUTED
2003c08: a0 04 20 01 inc %l0 <== NOT EXECUTED
#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 ];
2003c0c: 83 2e e0 02 sll %i3, 2, %g1
2003c10: f8 00 80 01 ld [ %g2 + %g1 ], %i4
if ( !the_thread )
2003c14: 80 a7 20 00 cmp %i4, 0
2003c18: 02 80 00 41 be 2003d1c <rtems_cpu_usage_report_with_plugin+0x178><== NEVER TAKEN
2003c1c: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2003c20: d0 07 20 08 ld [ %i4 + 8 ], %o0
2003c24: 40 00 13 c2 call 2008b2c <rtems_object_get_name>
2003c28: 94 07 bf d0 add %fp, -48, %o2
(*print)(
2003c2c: d4 07 20 08 ld [ %i4 + 8 ], %o2
2003c30: 90 10 00 18 mov %i0, %o0
2003c34: 92 10 00 11 mov %l1, %o1
2003c38: 9f c6 40 00 call %i1
2003c3c: 96 07 bf d0 add %fp, -48, %o3
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2003c40: c4 1f 20 80 ldd [ %i4 + 0x80 ], %g2
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2003c44: 03 00 80 83 sethi %hi(0x2020c00), %g1
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2003c48: c4 3f bf f0 std %g2, [ %fp + -16 ]
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2003c4c: 82 10 60 a0 or %g1, 0xa0, %g1
2003c50: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2003c54: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2003c58: c4 07 20 08 ld [ %i4 + 8 ], %g2
2003c5c: 80 a0 c0 02 cmp %g3, %g2
2003c60: 12 80 00 0d bne 2003c94 <rtems_cpu_usage_report_with_plugin+0xf0>
2003c64: 01 00 00 00 nop
*time_of_context_switch = _Thread_Time_of_last_context_switch;
2003c68: 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 );
2003c6c: 40 00 18 b6 call 2009f44 <_TOD_Get_uptime>
2003c70: 90 07 bf e0 add %fp, -32, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003c74: c4 1f bf e0 ldd [ %fp + -32 ], %g2
2003c78: ba a0 c0 1d subcc %g3, %i5, %i5
2003c7c: b8 60 80 1c subx %g2, %i4, %i4
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2003c80: c4 1f bf f0 ldd [ %fp + -16 ], %g2
2003c84: ba 80 c0 1d addcc %g3, %i5, %i5
2003c88: b8 40 80 1c addx %g2, %i4, %i4
2003c8c: 10 80 00 04 b 2003c9c <rtems_cpu_usage_report_with_plugin+0xf8>
2003c90: f8 3f bf f0 std %i4, [ %fp + -16 ]
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
2003c94: 40 00 18 ac call 2009f44 <_TOD_Get_uptime>
2003c98: 90 07 bf e0 add %fp, -32, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003c9c: c4 1f bf e0 ldd [ %fp + -32 ], %g2
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
2003ca0: 90 07 bf f0 add %fp, -16, %o0
2003ca4: 86 a0 c0 15 subcc %g3, %l5, %g3
2003ca8: 84 60 80 14 subx %g2, %l4, %g2
2003cac: 92 07 bf e8 add %fp, -24, %o1
2003cb0: c4 3f bf e8 std %g2, [ %fp + -24 ]
2003cb4: 94 07 bf f8 add %fp, -8, %o2
2003cb8: 40 00 22 22 call 200c540 <_Timestamp64_Divide>
2003cbc: 96 07 bf fc add %fp, -4, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
2003cc0: f8 1f bf f0 ldd [ %fp + -16 ], %i4
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003cc4: 94 10 20 00 clr %o2
2003cc8: 90 10 00 1c mov %i4, %o0
2003ccc: 92 10 00 1d mov %i5, %o1
2003cd0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003cd4: 40 00 5c 4f call 201ae10 <__divdi3>
2003cd8: 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);
2003cdc: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003ce0: a6 10 00 09 mov %o1, %l3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003ce4: 90 10 00 1c mov %i4, %o0
2003ce8: 92 10 00 1d mov %i5, %o1
2003cec: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003cf0: 40 00 5d 2e call 201b1a8 <__moddi3>
2003cf4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003cf8: 90 10 00 09 mov %o1, %o0
2003cfc: 40 00 5a ed call 201a8b0 <.udiv>
2003d00: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003d04: d8 1f bf f8 ldd [ %fp + -8 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003d08: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003d0c: 92 10 00 12 mov %l2, %o1
2003d10: 90 10 00 18 mov %i0, %o0
2003d14: 9f c6 40 00 call %i1
2003d18: 94 10 00 13 mov %l3, %o2
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
2003d1c: b6 06 e0 01 inc %i3
2003d20: c2 16 a0 10 lduh [ %i2 + 0x10 ], %g1
2003d24: 80 a6 c0 01 cmp %i3, %g1
2003d28: 28 bf ff b9 bleu,a 2003c0c <rtems_cpu_usage_report_with_plugin+0x68>
2003d2c: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003d30: a0 04 20 01 inc %l0
2003d34: 80 a4 20 04 cmp %l0, 4
2003d38: 12 bf ff ac bne 2003be8 <rtems_cpu_usage_report_with_plugin+0x44>
2003d3c: 83 2c 20 02 sll %l0, 2, %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
2003d40: 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);
2003d44: 94 10 20 00 clr %o2
2003d48: 90 10 00 1c mov %i4, %o0
2003d4c: 92 10 00 1d mov %i5, %o1
2003d50: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003d54: 40 00 5c 2f call 201ae10 <__divdi3>
2003d58: 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);
2003d5c: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003d60: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003d64: 90 10 00 1c mov %i4, %o0
2003d68: 92 10 00 1d mov %i5, %o1
2003d6c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003d70: 40 00 5d 0e call 201b1a8 <__moddi3>
2003d74: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003d78: 90 10 00 09 mov %o1, %o0
2003d7c: 40 00 5a cd call 201a8b0 <.udiv>
2003d80: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003d84: 13 00 80 75 sethi %hi(0x201d400), %o1
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003d88: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003d8c: 92 12 63 d0 or %o1, 0x3d0, %o1
2003d90: 90 10 00 18 mov %i0, %o0
2003d94: 9f c6 40 00 call %i1
2003d98: 94 10 00 1b mov %i3, %o2
2003d9c: 81 c7 e0 08 ret
2003da0: 81 e8 00 00 restore
0200f78c <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
200f78c: 9d e3 bf a0 save %sp, -96, %sp
200f790: 82 10 00 18 mov %i0, %g1
if (sc == RTEMS_SUCCESSFUL) {
200f794: 80 a0 60 00 cmp %g1, 0
200f798: 02 80 00 0c be 200f7c8 <rtems_deviceio_errno+0x3c>
200f79c: b0 10 20 00 clr %i0
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
200f7a0: 80 a0 60 1c cmp %g1, 0x1c
200f7a4: 18 80 00 06 bgu 200f7bc <rtems_deviceio_errno+0x30> <== NEVER TAKEN
200f7a8: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
200f7ac: 83 28 60 02 sll %g1, 2, %g1
200f7b0: 05 00 80 70 sethi %hi(0x201c000), %g2
200f7b4: 84 10 a0 ac or %g2, 0xac, %g2 ! 201c0ac <status_code_to_errno>
200f7b8: fa 00 80 01 ld [ %g2 + %g1 ], %i5
}
errno = eno;
200f7bc: 40 00 00 2e call 200f874 <__errno>
200f7c0: b0 10 3f ff mov -1, %i0
200f7c4: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
200f7c8: 81 c7 e0 08 ret
200f7cc: 81 e8 00 00 restore
020039c4 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
20039c4: 9d e3 bf 98 save %sp, -104, %sp
20039c8: a0 10 00 18 mov %i0, %l0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum end_block = begin_block + block_count;
sc = disk_lock();
20039cc: 7f ff ff 45 call 20036e0 <disk_lock>
20039d0: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
20039d4: b0 92 20 00 orcc %o0, 0, %i0
20039d8: 12 80 00 0e bne 2003a10 <rtems_disk_create_log+0x4c> <== NEVER TAKEN
20039dc: 90 10 00 1a mov %i2, %o0
return sc;
}
physical_disk = get_disk_entry(phys, true);
20039e0: 92 10 00 1b mov %i3, %o1
20039e4: 7f ff ff 07 call 2003600 <get_disk_entry>
20039e8: 94 10 20 01 mov 1, %o2
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
20039ec: 80 a2 20 00 cmp %o0, 0
20039f0: 02 80 00 06 be 2003a08 <rtems_disk_create_log+0x44>
20039f4: 01 00 00 00 nop
}
static bool
is_physical_disk(const rtems_disk_device *dd)
{
return dd->phys_dev == dd;
20039f8: f4 02 20 08 ld [ %o0 + 8 ], %i2
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
physical_disk = get_disk_entry(phys, true);
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
20039fc: 80 a6 80 08 cmp %i2, %o0
2003a00: 02 80 00 06 be 2003a18 <rtems_disk_create_log+0x54>
2003a04: 84 07 40 1c add %i5, %i4, %g2
disk_unlock();
2003a08: 7f ff ff 45 call 200371c <disk_unlock>
2003a0c: b0 10 20 04 mov 4, %i0
return RTEMS_INVALID_ID;
2003a10: 81 c7 e0 08 ret
2003a14: 81 e8 00 00 restore
}
if (
2003a18: 80 a7 00 02 cmp %i4, %g2
2003a1c: 1a 80 00 07 bcc 2003a38 <rtems_disk_create_log+0x74>
2003a20: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
2003a24: 80 a7 00 01 cmp %i4, %g1
2003a28: 1a 80 00 04 bcc 2003a38 <rtems_disk_create_log+0x74> <== NEVER TAKEN
2003a2c: 80 a0 80 01 cmp %g2, %g1
begin_block >= physical_disk->size
|| end_block <= begin_block
|| end_block > physical_disk->size
2003a30: 08 80 00 06 bleu 2003a48 <rtems_disk_create_log+0x84>
2003a34: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
) {
disk_unlock();
2003a38: 7f ff ff 39 call 200371c <disk_unlock>
2003a3c: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
2003a40: 81 c7 e0 08 ret
2003a44: 81 e8 00 00 restore
}
sc = create_disk(dev, name, &dd);
2003a48: 90 10 00 10 mov %l0, %o0
2003a4c: 92 10 00 19 mov %i1, %o1
2003a50: 7f ff ff 40 call 2003750 <create_disk>
2003a54: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003a58: b0 92 20 00 orcc %o0, 0, %i0
2003a5c: 02 80 00 06 be 2003a74 <rtems_disk_create_log+0xb0>
2003a60: c2 07 bf fc ld [ %fp + -4 ], %g1
disk_unlock();
2003a64: 7f ff ff 2e call 200371c <disk_unlock>
2003a68: 01 00 00 00 nop
return sc;
2003a6c: 81 c7 e0 08 ret
2003a70: 81 e8 00 00 restore
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
dd->size = block_count;
2003a74: f8 38 60 18 std %i4, [ %g1 + 0x18 ]
dd->block_size = dd->media_block_size = physical_disk->block_size;
2003a78: c4 06 a0 20 ld [ %i2 + 0x20 ], %g2
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
2003a7c: f4 20 60 08 st %i2, [ %g1 + 8 ]
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
2003a80: c4 20 60 24 st %g2, [ %g1 + 0x24 ]
2003a84: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
dd->ioctl = physical_disk->ioctl;
2003a88: c4 06 a0 28 ld [ %i2 + 0x28 ], %g2
2003a8c: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
dd->driver_data = physical_disk->driver_data;
2003a90: c4 06 a0 2c ld [ %i2 + 0x2c ], %g2
2003a94: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
++physical_disk->uses;
2003a98: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
2003a9c: 82 00 60 01 inc %g1
disk_unlock();
2003aa0: 7f ff ff 1f call 200371c <disk_unlock>
2003aa4: c2 26 a0 14 st %g1, [ %i2 + 0x14 ]
return RTEMS_SUCCESSFUL;
}
2003aa8: 81 c7 e0 08 ret
2003aac: 81 e8 00 00 restore
02003918 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
2003918: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
200391c: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
2003920: a0 10 00 18 mov %i0, %l0
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
2003924: 80 a7 20 00 cmp %i4, 0
2003928: 02 80 00 13 be 2003974 <rtems_disk_create_phys+0x5c>
200392c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
}
if (block_size == 0) {
2003930: 80 a6 a0 00 cmp %i2, 0
2003934: 02 80 00 10 be 2003974 <rtems_disk_create_phys+0x5c>
2003938: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
}
sc = disk_lock();
200393c: 7f ff ff 69 call 20036e0 <disk_lock>
2003940: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003944: b0 92 20 00 orcc %o0, 0, %i0
2003948: 12 80 00 0b bne 2003974 <rtems_disk_create_phys+0x5c> <== NEVER TAKEN
200394c: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
return sc;
}
sc = create_disk(dev, name, &dd);
2003950: 90 10 00 10 mov %l0, %o0
2003954: 92 10 00 19 mov %i1, %o1
2003958: 7f ff ff 7e call 2003750 <create_disk>
200395c: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003960: b0 92 20 00 orcc %o0, 0, %i0
2003964: 02 80 00 06 be 200397c <rtems_disk_create_phys+0x64>
2003968: d0 07 bf fc ld [ %fp + -4 ], %o0
disk_unlock();
200396c: 7f ff ff 6c call 200371c <disk_unlock>
2003970: 01 00 00 00 nop
return sc;
2003974: 81 c7 e0 08 ret
2003978: 81 e8 00 00 restore
dd->size = block_count;
dd->block_size = dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
200397c: 13 08 00 10 sethi %hi(0x20004000), %o1
disk_unlock();
return sc;
}
dd->phys_dev = dd;
2003980: d0 22 20 08 st %o0, [ %o0 + 8 ]
dd->start = 0;
2003984: c0 22 20 18 clr [ %o0 + 0x18 ]
dd->size = block_count;
2003988: f6 22 20 1c st %i3, [ %o0 + 0x1c ]
dd->block_size = dd->media_block_size = block_size;
200398c: f4 22 20 24 st %i2, [ %o0 + 0x24 ]
2003990: f4 22 20 20 st %i2, [ %o0 + 0x20 ]
dd->ioctl = handler;
dd->driver_data = driver_data;
2003994: f8 3a 20 28 std %i4, [ %o0 + 0x28 ]
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
2003998: 92 12 62 08 or %o1, 0x208, %o1
200399c: 9f c7 00 00 call %i4
20039a0: 94 02 20 0c add %o0, 0xc, %o2
20039a4: 80 a2 20 00 cmp %o0, 0
20039a8: 16 80 00 03 bge 20039b4 <rtems_disk_create_phys+0x9c> <== NEVER TAKEN
20039ac: c2 07 bf fc ld [ %fp + -4 ], %g1
dd->capabilities = 0;
20039b0: c0 20 60 0c clr [ %g1 + 0xc ]
}
disk_unlock();
20039b4: 7f ff ff 5a call 200371c <disk_unlock>
20039b8: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
20039bc: 81 c7 e0 08 ret
20039c0: 81 e8 00 00 restore
02003ab0 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
2003ab0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
2003ab4: 7f ff ff 0b call 20036e0 <disk_lock>
2003ab8: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
2003abc: b0 92 20 00 orcc %o0, 0, %i0
2003ac0: 12 80 00 0a bne 2003ae8 <rtems_disk_delete+0x38> <== NEVER TAKEN
2003ac4: 90 10 00 1c mov %i4, %o0
return sc;
}
dd = get_disk_entry(dev, true);
2003ac8: 92 10 00 19 mov %i1, %o1
2003acc: 7f ff fe cd call 2003600 <get_disk_entry>
2003ad0: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
2003ad4: 82 92 20 00 orcc %o0, 0, %g1
2003ad8: 32 80 00 06 bne,a 2003af0 <rtems_disk_delete+0x40> <== ALWAYS TAKEN
2003adc: f6 00 60 08 ld [ %g1 + 8 ], %i3
disk_unlock();
2003ae0: 7f ff ff 0f call 200371c <disk_unlock> <== NOT EXECUTED
2003ae4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
return RTEMS_INVALID_ID;
2003ae8: 81 c7 e0 08 ret <== NOT EXECUTED
2003aec: 81 e8 00 00 restore <== NOT EXECUTED
}
dd->deleted = true;
2003af0: 84 10 20 01 mov 1, %g2
2003af4: c4 28 60 30 stb %g2, [ %g1 + 0x30 ]
{
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) {
2003af8: c4 0e e0 30 ldub [ %i3 + 0x30 ], %g2
2003afc: 80 a0 a0 00 cmp %g2, 0
2003b00: 22 80 00 3d be,a 2003bf4 <rtems_disk_delete+0x144>
2003b04: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
dev_t dev = physical_disk->dev;
2003b08: f8 1e c0 00 ldd [ %i3 ], %i4
unsigned deleted_count = 0;
2003b0c: a0 10 20 00 clr %l0
for (major = 0; major < disktab_size; ++major) {
2003b10: b4 10 20 00 clr %i2
2003b14: 29 00 80 84 sethi %hi(0x2021000), %l4
rtems_disk_device_table *dtab = disktab + major;
2003b18: 27 00 80 84 sethi %hi(0x2021000), %l3
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
2003b1c: 10 80 00 23 b 2003ba8 <rtems_disk_delete+0xf8>
2003b20: a4 10 20 01 mov 1, %l2
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;
2003b24: 83 2e a0 03 sll %i2, 3, %g1
for (minor = 0; minor < dtab->size; ++minor) {
2003b28: b2 10 20 00 clr %i1
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;
2003b2c: 10 80 00 1a b 2003b94 <rtems_disk_delete+0xe4>
2003b30: a2 04 40 01 add %l1, %g1, %l1
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
2003b34: 83 2e 60 02 sll %i1, 2, %g1
2003b38: d0 01 00 01 ld [ %g4 + %g1 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
2003b3c: 80 a2 20 00 cmp %o0, 0
2003b40: 02 80 00 14 be 2003b90 <rtems_disk_delete+0xe0>
2003b44: 80 a2 00 1b cmp %o0, %i3
2003b48: 22 80 00 13 be,a 2003b94 <rtems_disk_delete+0xe4>
2003b4c: b2 06 60 01 inc %i1
2003b50: c4 02 20 08 ld [ %o0 + 8 ], %g2
2003b54: c4 18 80 00 ldd [ %g2 ], %g2
2003b58: 84 1f 00 02 xor %i4, %g2, %g2
2003b5c: 86 1f 40 03 xor %i5, %g3, %g3
2003b60: 80 90 80 03 orcc %g2, %g3, %g0
2003b64: 32 80 00 0c bne,a 2003b94 <rtems_disk_delete+0xe4> <== NEVER TAKEN
2003b68: b2 06 60 01 inc %i1 <== NOT EXECUTED
if (dd->uses == 0) {
2003b6c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
2003b70: 80 a0 a0 00 cmp %g2, 0
2003b74: 32 80 00 07 bne,a 2003b90 <rtems_disk_delete+0xe0>
2003b78: e4 2a 20 30 stb %l2, [ %o0 + 0x30 ]
++deleted_count;
2003b7c: a0 04 20 01 inc %l0
dtab->minor [minor] = NULL;
free_disk_device(dd);
2003b80: 7f ff fe c3 call 200368c <free_disk_device>
2003b84: c0 21 00 01 clr [ %g4 + %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) {
2003b88: 10 80 00 03 b 2003b94 <rtems_disk_delete+0xe4>
2003b8c: b2 06 60 01 inc %i1
2003b90: b2 06 60 01 inc %i1
2003b94: c2 04 60 04 ld [ %l1 + 4 ], %g1
2003b98: 80 a6 40 01 cmp %i1, %g1
2003b9c: 2a bf ff e6 bcs,a 2003b34 <rtems_disk_delete+0x84>
2003ba0: c8 04 40 00 ld [ %l1 ], %g4
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2003ba4: b4 06 a0 01 inc %i2
2003ba8: c2 05 23 a8 ld [ %l4 + 0x3a8 ], %g1
2003bac: 80 a6 80 01 cmp %i2, %g1
2003bb0: 2a bf ff dd bcs,a 2003b24 <rtems_disk_delete+0x74>
2003bb4: e2 04 e3 ac ld [ %l3 + 0x3ac ], %l1
}
}
}
}
physical_disk->uses -= deleted_count;
2003bb8: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
2003bbc: a0 20 40 10 sub %g1, %l0, %l0
if (physical_disk->uses == 0) {
2003bc0: 80 a4 20 00 cmp %l0, 0
2003bc4: 12 80 00 1b bne 2003c30 <rtems_disk_delete+0x180>
2003bc8: e0 26 e0 14 st %l0, [ %i3 + 0x14 ]
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2003bcc: c4 06 c0 00 ld [ %i3 ], %g2
disktab [major].minor [minor] = NULL;
2003bd0: 07 00 80 84 sethi %hi(0x2021000), %g3
2003bd4: c6 00 e3 ac ld [ %g3 + 0x3ac ], %g3 ! 20213ac <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2003bd8: c2 06 e0 04 ld [ %i3 + 4 ], %g1
disktab [major].minor [minor] = NULL;
2003bdc: 85 28 a0 03 sll %g2, 3, %g2
2003be0: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2003be4: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
2003be8: 90 10 00 1b mov %i3, %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;
2003bec: 10 80 00 0f b 2003c28 <rtems_disk_delete+0x178>
2003bf0: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
2003bf4: 80 a0 a0 00 cmp %g2, 0
2003bf8: 12 80 00 0e bne 2003c30 <rtems_disk_delete+0x180> <== NEVER TAKEN
2003bfc: 07 00 80 84 sethi %hi(0x2021000), %g3
--physical_disk->uses;
2003c00: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
2003c04: 84 00 bf ff add %g2, -1, %g2
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2003c08: c6 00 e3 ac ld [ %g3 + 0x3ac ], %g3
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
2003c0c: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2003c10: c4 00 40 00 ld [ %g1 ], %g2
2003c14: c2 00 60 04 ld [ %g1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
2003c18: 85 28 a0 03 sll %g2, 3, %g2
2003c1c: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2003c20: 83 28 60 02 sll %g1, 2, %g1
2003c24: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(disk_to_remove);
2003c28: 7f ff fe 99 call 200368c <free_disk_device>
2003c2c: 01 00 00 00 nop
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2003c30: 7f ff fe bb call 200371c <disk_unlock>
2003c34: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
2003c38: 81 c7 e0 08 ret
2003c3c: 81 e8 00 00 restore
02003e08 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
2003e08: 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) {
2003e0c: 39 00 80 84 sethi %hi(0x2021000), %i4
2003e10: c2 07 23 a8 ld [ %i4 + 0x3a8 ], %g1 ! 20213a8 <disktab_size>
2003e14: 80 a0 60 00 cmp %g1, 0
2003e18: 12 80 00 19 bne 2003e7c <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
2003e1c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
2003e20: 90 10 20 08 mov 8, %o0
2003e24: 92 10 20 08 mov 8, %o1
2003e28: 40 00 02 1a call 2004690 <calloc>
2003e2c: 3b 00 80 84 sethi %hi(0x2021000), %i5
2003e30: d0 27 63 ac st %o0, [ %i5 + 0x3ac ] ! 20213ac <disktab>
if (disktab == NULL) {
2003e34: 80 a2 20 00 cmp %o0, 0
2003e38: 02 80 00 11 be 2003e7c <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
2003e3c: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
2003e40: 03 00 80 84 sethi %hi(0x2021000), %g1
sc = rtems_semaphore_create(
2003e44: 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;
2003e48: c0 28 63 a0 clrb [ %g1 + 0x3a0 ]
sc = rtems_semaphore_create(
2003e4c: 90 12 21 56 or %o0, 0x156, %o0
2003e50: 92 10 20 01 mov 1, %o1
2003e54: 94 10 20 10 mov 0x10, %o2
2003e58: 96 10 20 00 clr %o3
2003e5c: 37 00 80 84 sethi %hi(0x2021000), %i3
2003e60: 40 00 13 23 call 2008aec <rtems_semaphore_create>
2003e64: 98 16 e3 a4 or %i3, 0x3a4, %o4 ! 20213a4 <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
2003e68: 80 a2 20 00 cmp %o0, 0
2003e6c: 02 80 00 06 be 2003e84 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
2003e70: 01 00 00 00 nop
free(disktab);
2003e74: 40 00 02 d7 call 20049d0 <free> <== NOT EXECUTED
2003e78: d0 07 63 ac ld [ %i5 + 0x3ac ], %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
2003e7c: 81 c7 e0 08 ret <== NOT EXECUTED
2003e80: 81 e8 00 00 restore <== NOT EXECUTED
}
sc = rtems_bdbuf_init();
2003e84: 40 00 28 fd call 200e278 <rtems_bdbuf_init>
2003e88: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003e8c: 80 a2 20 00 cmp %o0, 0
2003e90: 02 80 00 09 be 2003eb4 <rtems_disk_io_initialize+0xac> <== ALWAYS TAKEN
2003e94: 82 10 20 08 mov 8, %g1
rtems_semaphore_delete(diskdevs_mutex);
2003e98: d0 06 e3 a4 ld [ %i3 + 0x3a4 ], %o0 <== NOT EXECUTED
2003e9c: 40 00 13 7f call 2008c98 <rtems_semaphore_delete> <== NOT EXECUTED
2003ea0: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
free(disktab);
2003ea4: 40 00 02 cb call 20049d0 <free> <== NOT EXECUTED
2003ea8: d0 07 63 ac ld [ %i5 + 0x3ac ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2003eac: 81 c7 e0 08 ret <== NOT EXECUTED
2003eb0: 81 e8 00 00 restore <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
2003eb4: b0 10 20 00 clr %i0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
2003eb8: c2 27 23 a8 st %g1, [ %i4 + 0x3a8 ]
return RTEMS_SUCCESSFUL;
}
2003ebc: 81 c7 e0 08 ret
2003ec0: 81 e8 00 00 restore
02003d04 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
2003d04: 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) {
2003d08: 80 a6 3f ff cmp %i0, -1
2003d0c: 12 80 00 05 bne 2003d20 <rtems_disk_next+0x1c>
2003d10: b8 06 60 01 add %i1, 1, %i4
2003d14: 80 a6 7f ff cmp %i1, -1
2003d18: 22 80 00 0c be,a 2003d48 <rtems_disk_next+0x44> <== ALWAYS TAKEN
2003d1c: b8 10 20 00 clr %i4
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
2003d20: 80 a7 00 19 cmp %i4, %i1
2003d24: 1a 80 00 0a bcc 2003d4c <rtems_disk_next+0x48> <== ALWAYS TAKEN
2003d28: ba 10 00 18 mov %i0, %i5
/* If major wraps around */
if ((major + 1) < major) {
2003d2c: ba 06 20 01 add %i0, 1, %i5 <== NOT EXECUTED
return NULL;
2003d30: b6 10 20 00 clr %i3 <== NOT EXECUTED
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
2003d34: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2003d38: 1a 80 00 05 bcc 2003d4c <rtems_disk_next+0x48> <== NOT EXECUTED
2003d3c: b8 10 20 00 clr %i4 <== NOT EXECUTED
disk_unlock();
return dtab->minor [minor];
}
}
}
2003d40: 81 c7 e0 08 ret <== NOT EXECUTED
2003d44: 91 e8 00 1b restore %g0, %i3, %o0 <== NOT EXECUTED
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
2003d48: ba 10 20 00 clr %i5
} else {
++minor;
}
}
sc = disk_lock();
2003d4c: 7f ff fe 65 call 20036e0 <disk_lock>
2003d50: b6 10 20 00 clr %i3
if (sc != RTEMS_SUCCESSFUL) {
2003d54: 80 a2 20 00 cmp %o0, 0
2003d58: 12 80 00 29 bne 2003dfc <rtems_disk_next+0xf8> <== NEVER TAKEN
2003d5c: 03 00 80 84 sethi %hi(0x2021000), %g1
return NULL;
}
if (major >= disktab_size) {
2003d60: c6 00 63 a8 ld [ %g1 + 0x3a8 ], %g3 ! 20213a8 <disktab_size>
2003d64: 80 a7 40 03 cmp %i5, %g3
2003d68: 0a 80 00 05 bcs 2003d7c <rtems_disk_next+0x78> <== ALWAYS TAKEN
2003d6c: 03 00 80 84 sethi %hi(0x2021000), %g1
disk_unlock();
2003d70: 7f ff fe 6b call 200371c <disk_unlock> <== NOT EXECUTED
2003d74: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED
return NULL;
2003d78: 30 80 00 22 b,a 2003e00 <rtems_disk_next+0xfc> <== NOT EXECUTED
}
dtab = disktab + major;
2003d7c: c4 00 63 ac ld [ %g1 + 0x3ac ], %g2
2003d80: b7 2f 60 03 sll %i5, 3, %i3
2003d84: b6 00 80 1b add %g2, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2003d88: c2 06 c0 00 ld [ %i3 ], %g1
2003d8c: 80 a0 60 00 cmp %g1, 0
2003d90: 22 80 00 07 be,a 2003dac <rtems_disk_next+0xa8>
2003d94: ba 07 60 01 inc %i5
2003d98: c8 06 e0 04 ld [ %i3 + 4 ], %g4
2003d9c: 80 a7 00 04 cmp %i4, %g4
2003da0: 0a 80 00 0d bcs 2003dd4 <rtems_disk_next+0xd0>
2003da4: b1 2f 20 02 sll %i4, 2, %i0
minor = 0;
++major;
2003da8: ba 07 60 01 inc %i5
if (major >= disktab_size) {
2003dac: 80 a7 40 03 cmp %i5, %g3
2003db0: 0a 80 00 06 bcs 2003dc8 <rtems_disk_next+0xc4>
2003db4: b7 2f 60 03 sll %i5, 3, %i3
disk_unlock();
2003db8: 7f ff fe 59 call 200371c <disk_unlock>
2003dbc: b6 10 20 00 clr %i3
return NULL;
2003dc0: 81 c7 e0 08 ret
2003dc4: 91 e8 00 1b restore %g0, %i3, %o0
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
2003dc8: b8 10 20 00 clr %i4
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
2003dcc: 10 bf ff ef b 2003d88 <rtems_disk_next+0x84>
2003dd0: b6 00 80 1b add %g2, %i3, %i3
} else if (dtab->minor [minor] == NULL) {
2003dd4: c2 00 40 18 ld [ %g1 + %i0 ], %g1
2003dd8: 80 a0 60 00 cmp %g1, 0
2003ddc: 02 bf ff eb be 2003d88 <rtems_disk_next+0x84>
2003de0: b8 07 20 01 inc %i4
++minor;
} else {
++dtab->minor [minor]->uses;
2003de4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
2003de8: 84 00 a0 01 inc %g2
disk_unlock();
2003dec: 7f ff fe 4c call 200371c <disk_unlock>
2003df0: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return dtab->minor [minor];
2003df4: c2 06 c0 00 ld [ %i3 ], %g1
2003df8: f6 00 40 18 ld [ %g1 + %i0 ], %i3
}
}
}
2003dfc: b0 10 00 1b mov %i3, %i0
2003e00: 81 c7 e0 08 ret
2003e04: 81 e8 00 00 restore
02003c40 <rtems_disk_obtain>:
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
2003c40: 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);
2003c44: 7f ff fc 7e call 2002e3c <sparc_disable_interrupts>
2003c48: b8 10 00 18 mov %i0, %i4
2003c4c: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
2003c50: 03 00 80 84 sethi %hi(0x2021000), %g1
2003c54: c2 08 63 a0 ldub [ %g1 + 0x3a0 ], %g1 ! 20213a0 <diskdevs_protected>
2003c58: 80 a0 60 00 cmp %g1, 0
2003c5c: 12 80 00 0a bne 2003c84 <rtems_disk_obtain+0x44> <== NEVER TAKEN
2003c60: 92 10 00 19 mov %i1, %o1
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
2003c64: 90 10 00 18 mov %i0, %o0
2003c68: 7f ff fe 66 call 2003600 <get_disk_entry>
2003c6c: 94 10 20 00 clr %o2
2003c70: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
2003c74: 7f ff fc 76 call 2002e4c <sparc_enable_interrupts>
2003c78: 90 10 00 1b mov %i3, %o0
2003c7c: 81 c7 e0 08 ret
2003c80: 81 e8 00 00 restore
} else {
rtems_interrupt_enable(level);
2003c84: 7f ff fc 72 call 2002e4c <sparc_enable_interrupts> <== NOT EXECUTED
2003c88: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
2003c8c: 7f ff fe 95 call 20036e0 <disk_lock> <== NOT EXECUTED
2003c90: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
2003c94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2003c98: 12 bf ff f9 bne 2003c7c <rtems_disk_obtain+0x3c> <== NOT EXECUTED
2003c9c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
2003ca0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2003ca4: 7f ff fe 57 call 2003600 <get_disk_entry> <== NOT EXECUTED
2003ca8: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
2003cac: 7f ff fe 9c call 200371c <disk_unlock> <== NOT EXECUTED
2003cb0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
2003cb4: 81 c7 e0 08 ret <== NOT EXECUTED
2003cb8: 81 e8 00 00 restore <== NOT EXECUTED
02007570 <rtems_fdisk_abort>:
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
2007570: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
va_list args;
va_start (args, format);
2007574: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
2007578: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
200757c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007580: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
2007584: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 ! 2035c18 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
2007588: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
200758c: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2007590: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2007594: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007598: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
200759c: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
20075a0: 40 00 66 4c call 2020ed0 <fputs> <== NOT EXECUTED
20075a4: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 2030bf0 <__FUNCTION__.6925+0x8e0><== NOT EXECUTED
vfprintf (stderr, format, args);
20075a8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
20075ac: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
20075b0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
20075b4: 40 00 88 a3 call 2029840 <vfprintf> <== NOT EXECUTED
20075b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
20075bc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
20075c0: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
20075c4: 40 00 66 0e call 2020dfc <fputc> <== NOT EXECUTED
20075c8: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
20075cc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
20075d0: 40 00 64 f6 call 20209a8 <fflush> <== NOT EXECUTED
20075d4: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
20075d8: 40 00 63 e7 call 2020574 <exit> <== NOT EXECUTED
20075dc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
020058fc <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)
{
20058fc: 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->unavail_blocks;
if (starvation)
2005900: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
2005904: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2005908: 80 a0 80 01 cmp %g2, %g1
200590c: 1a 80 00 0b bcc 2005938 <rtems_fdisk_compact+0x3c>
2005910: ba 10 00 18 mov %i0, %i5
fd->starvations++;
2005914: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
uint32_t compacted_segs = 0;
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005918: 90 06 20 3c add %i0, 0x3c, %o0
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->unavail_blocks;
if (starvation)
fd->starvations++;
200591c: 82 00 60 01 inc %g1
uint32_t compacted_segs = 0;
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005920: 7f ff fc be call 2004c18 <rtems_fdisk_segment_queue_pop_head>
2005924: c2 26 20 6c st %g1, [ %i0 + 0x6c ]
if (!ssc)
2005928: b8 92 20 00 orcc %o0, 0, %i4
200592c: 12 80 00 12 bne 2005974 <rtems_fdisk_compact+0x78> <== ALWAYS TAKEN
2005930: 01 00 00 00 nop
2005934: 30 80 00 0b b,a 2005960 <rtems_fdisk_compact+0x64> <== NOT EXECUTED
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005938: 25 00 80 c2 sethi %hi(0x2030800), %l2
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",
200593c: 23 00 80 c2 sethi %hi(0x2030800), %l1
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
break;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005940: 21 00 80 c2 sethi %hi(0x2030800), %l0
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
2005944: b6 10 20 00 clr %i3
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005948: a4 14 a3 60 or %l2, 0x360, %l2
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
200594c: b4 07 60 30 add %i5, 0x30, %i2
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",
2005950: a2 14 63 a8 or %l1, 0x3a8, %l1
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
break;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005954: a0 14 23 c8 or %l0, 0x3c8, %l0
* We now copy the pages to the new segment.
*/
while (pages)
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005958: 10 80 00 5e b 2005ad0 <rtems_fdisk_compact+0x1d4>
200595c: b2 07 60 3c add %i5, 0x3c, %i1
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (!ssc)
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
2005960: 7f ff fc ae call 2004c18 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
2005964: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED
if (ssc)
2005968: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
200596c: 02 80 00 12 be 20059b4 <rtems_fdisk_compact+0xb8> <== NOT EXECUTED
2005970: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005974: 7f ff fd 39 call 2004e58 <rtems_fdisk_seg_most_available>
2005978: 90 07 60 30 add %i5, 0x30, %o0
if (dsc)
200597c: 94 92 20 00 orcc %o0, 0, %o2
2005980: 02 80 00 0a be 20059a8 <rtems_fdisk_compact+0xac> <== NEVER TAKEN
2005984: 92 10 00 1c mov %i4, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005988: 90 10 00 1d mov %i5, %o0
200598c: 7f ff fe fd call 2005580 <rtems_fdisk_recycle_segment>
2005990: 96 07 bf fc add %fp, -4, %o3
if (ret)
2005994: 80 a2 20 00 cmp %o0, 0
2005998: 02 bf ff e9 be 200593c <rtems_fdisk_compact+0x40> <== ALWAYS TAKEN
200599c: 25 00 80 c2 sethi %hi(0x2030800), %l2
compacted_segs += segments;
}
return 0;
}
20059a0: 81 c7 e0 08 ret <== NOT EXECUTED
20059a4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
20059a8: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
20059ac: 10 80 00 0d b 20059e0 <rtems_fdisk_compact+0xe4> <== NOT EXECUTED
20059b0: 90 12 23 28 or %o0, 0x328, %o0 ! 2030b28 <__FUNCTION__.6925+0x818><== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
20059b4: 10 80 00 0b b 20059e0 <rtems_fdisk_compact+0xe4> <== NOT EXECUTED
20059b8: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
20059bc: 7f ff fd 59 call 2004f20 <rtems_fdisk_printf>
20059c0: 90 10 00 1d mov %i5, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
20059c4: 7f ff fd 25 call 2004e58 <rtems_fdisk_seg_most_available>
20059c8: 90 10 00 1a mov %i2, %o0
if (dsc == 0)
20059cc: b8 92 20 00 orcc %o0, 0, %i4
20059d0: 12 80 00 08 bne 20059f0 <rtems_fdisk_compact+0xf4> <== ALWAYS TAKEN
20059d4: 01 00 00 00 nop
{
rtems_fdisk_error ("compacting: no available segments to compact too");
20059d8: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
20059dc: 90 12 23 70 or %o0, 0x370, %o0 ! 2030b70 <__FUNCTION__.6925+0x860><== NOT EXECUTED
20059e0: 7f ff fe 26 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20059e4: 01 00 00 00 nop <== NOT EXECUTED
return EIO;
20059e8: 10 80 00 3f b 2005ae4 <rtems_fdisk_compact+0x1e8> <== NOT EXECUTED
20059ec: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
20059f0: 7f ff fd 12 call 2004e38 <rtems_fdisk_seg_pages_available>
20059f4: 01 00 00 00 nop
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
20059f8: d4 07 20 08 ld [ %i4 + 8 ], %o2
20059fc: d6 07 20 0c ld [ %i4 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
2005a00: f0 07 60 3c ld [ %i5 + 0x3c ], %i0
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005a04: a6 10 00 08 mov %o0, %l3
segments = 0;
pages = 0;
2005a08: c0 27 bf fc clr [ %fp + -4 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005a0c: 90 10 00 1d mov %i5, %o0
2005a10: 7f ff fd 44 call 2004f20 <rtems_fdisk_printf>
2005a14: 92 10 00 11 mov %l1, %o1
2005a18: 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 &&
2005a1c: 10 80 00 04 b 2005a2c <rtems_fdisk_compact+0x130>
2005a20: 9a 10 20 00 clr %o5
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
2005a24: 9a 03 60 01 inc %o5
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
2005a28: 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 &&
2005a2c: 80 a6 20 00 cmp %i0, 0
2005a30: 02 80 00 2d be 2005ae4 <rtems_fdisk_compact+0x1e8>
2005a34: 90 10 20 00 clr %o0
((pages + ssc->pages_active) < dst_pages) &&
2005a38: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
2005a3c: 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 &&
2005a40: 80 a0 40 13 cmp %g1, %l3
2005a44: 1a 80 00 2b bcc 2005af0 <rtems_fdisk_compact+0x1f4>
2005a48: 86 03 40 1b add %o5, %i3, %g3
((pages + ssc->pages_active) < dst_pages) &&
2005a4c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
2005a50: 80 a0 c0 02 cmp %g3, %g2
2005a54: 2a bf ff f4 bcs,a 2005a24 <rtems_fdisk_compact+0x128> <== ALWAYS TAKEN
2005a58: f0 06 00 00 ld [ %i0 ], %i0
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
2005a5c: 10 80 00 26 b 2005af4 <rtems_fdisk_compact+0x1f8> <== NOT EXECUTED
2005a60: 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))
2005a64: 80 a6 e0 01 cmp %i3, 1
2005a68: 02 80 00 1e be 2005ae0 <rtems_fdisk_compact+0x1e4> <== ALWAYS TAKEN
2005a6c: 92 10 00 10 mov %l0, %o1
break;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005a70: d4 06 20 08 ld [ %i0 + 8 ], %o2 <== NOT EXECUTED
2005a74: d6 06 20 0c ld [ %i0 + 0xc ], %o3 <== NOT EXECUTED
2005a78: 7f ff fd 2a call 2004f20 <rtems_fdisk_printf> <== NOT EXECUTED
2005a7c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
2005a80: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2005a84: 7f ff fc 87 call 2004ca0 <rtems_fdisk_segment_queue_remove><== NOT EXECUTED
2005a88: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
/*
* We now copy the pages to the new segment.
*/
while (pages)
2005a8c: 10 80 00 0e b 2005ac4 <rtems_fdisk_compact+0x1c8> <== NOT EXECUTED
2005a90: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005a94: 7f ff fc 61 call 2004c18 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
2005a98: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (ssc)
2005a9c: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
2005aa0: 02 80 00 09 be 2005ac4 <rtems_fdisk_compact+0x1c8> <== NOT EXECUTED
2005aa4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005aa8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2005aac: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2005ab0: 7f ff fe b4 call 2005580 <rtems_fdisk_recycle_segment> <== NOT EXECUTED
2005ab4: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
if (ret)
2005ab8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2005abc: 12 80 00 0a bne 2005ae4 <rtems_fdisk_compact+0x1e8> <== NOT EXECUTED
2005ac0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
/*
* We now copy the pages to the new segment.
*/
while (pages)
2005ac4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005ac8: 12 bf ff f3 bne 2005a94 <rtems_fdisk_compact+0x198> <== NOT EXECUTED
2005acc: 01 00 00 00 nop <== NOT EXECUTED
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
2005ad0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2005ad4: 80 a0 60 00 cmp %g1, 0
2005ad8: 12 bf ff b9 bne 20059bc <rtems_fdisk_compact+0xc0>
2005adc: 92 10 00 12 mov %l2, %o1
}
compacted_segs += segments;
}
return 0;
2005ae0: 90 10 20 00 clr %o0
}
2005ae4: b0 10 00 08 mov %o0, %i0
2005ae8: 81 c7 e0 08 ret
2005aec: 81 e8 00 00 restore
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
2005af0: 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))
2005af4: 80 a3 20 00 cmp %o4, 0
2005af8: 32 bf ff db bne,a 2005a64 <rtems_fdisk_compact+0x168>
2005afc: b6 06 c0 0d add %i3, %o5, %i3
}
compacted_segs += segments;
}
return 0;
2005b00: 10 bf ff f9 b 2005ae4 <rtems_fdisk_compact+0x1e8>
2005b04: 90 10 20 00 clr %o0
020052ec <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
20052ec: 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;
20052f0: d2 06 60 08 ld [ %i1 + 8 ], %o1
segment = sc->segment;
20052f4: 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;
20052f8: 85 2a 60 04 sll %o1, 4, %g2
20052fc: 83 2a 60 02 sll %o1, 2, %g1
2005300: 82 20 80 01 sub %g2, %g1, %g1
2005304: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
2005308: 89 2a a0 06 sll %o2, 6, %g4
200530c: 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;
2005310: 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;
2005314: 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);
2005318: 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;
200531c: 85 2a a0 04 sll %o2, 4, %g2
2005320: 84 21 00 02 sub %g4, %g2, %g2
2005324: 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);
2005328: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
200532c: d0 00 a0 04 ld [ %g2 + 4 ], %o0
2005330: 9f c0 40 00 call %g1
2005334: ba 10 00 18 mov %i0, %i5
if (ret)
2005338: b0 92 20 00 orcc %o0, 0, %i0
200533c: 22 80 00 18 be,a 200539c <rtems_fdisk_erase_segment+0xb0><== ALWAYS TAKEN
2005340: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
2005344: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2005348: 40 00 76 84 call 2022d58 <strerror> <== NOT EXECUTED
200534c: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
2005350: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2005354: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2005358: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
200535c: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2005360: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
2005364: 7f ff ff c5 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2005368: 90 12 21 10 or %o0, 0x110, %o0 <== NOT EXECUTED
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
200536c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2005370: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
2005374: 10 80 00 05 b 2005388 <rtems_fdisk_erase_segment+0x9c> <== NOT EXECUTED
2005378: c2 07 60 54 ld [ %i5 + 0x54 ], %g1 <== NOT EXECUTED
while (it)
{
if (it == sc)
200537c: 02 80 00 21 be 2005400 <rtems_fdisk_erase_segment+0x114> <== NOT EXECUTED
2005380: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
2005384: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2005388: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200538c: 12 bf ff fc bne 200537c <rtems_fdisk_erase_segment+0x90> <== NOT EXECUTED
2005390: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
2005394: 10 80 00 19 b 20053f8 <rtems_fdisk_erase_segment+0x10c> <== NOT EXECUTED
2005398: 90 07 60 54 add %i5, 0x54, %o0 <== NOT EXECUTED
return ret;
}
fd->erased_blocks += sc->pages;
200539c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
20053a0: 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;
20053a4: 82 00 80 01 add %g2, %g1, %g1
20053a8: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
sc->erased++;
20053ac: c2 06 60 2c ld [ %i1 + 0x2c ], %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
20053b0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
20053b4: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
20053b8: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
20053bc: 7f ff f4 42 call 20024c4 <.umul>
20053c0: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
20053c4: 92 10 20 ff mov 0xff, %o1
20053c8: 94 10 00 08 mov %o0, %o2
20053cc: 40 00 71 53 call 2021918 <memset>
20053d0: 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);
20053d4: 90 07 60 30 add %i5, 0x30, %o0
fd->erased_blocks += sc->pages;
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
sc->pages_active = 0;
20053d8: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
20053dc: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
20053e0: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
20053e4: 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);
20053e8: 7f ff fe 1c call 2004c58 <rtems_fdisk_segment_queue_push_tail>
20053ec: 92 10 00 19 mov %i1, %o1
return 0;
}
20053f0: 81 c7 e0 08 ret
20053f4: 81 e8 00 00 restore
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
20053f8: 7f ff fe 18 call 2004c58 <rtems_fdisk_segment_queue_push_tail><== NOT EXECUTED
20053fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2005400: 81 c7 e0 08 ret <== NOT EXECUTED
2005404: 81 e8 00 00 restore <== NOT EXECUTED
02005278 <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, ...)
{
2005278: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
200527c: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
2005280: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
2005284: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
2005288: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
200528c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 ! 2035c18 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
2005290: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2005294: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2005298: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
200529c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
20052a0: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
20052a4: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
20052a8: 40 00 6f 0a call 2020ed0 <fputs> <== NOT EXECUTED
20052ac: 90 12 21 00 or %o0, 0x100, %o0 ! 2030900 <__FUNCTION__.6925+0x5f0><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
20052b0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
20052b4: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
20052b8: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
20052bc: 40 00 91 61 call 2029840 <vfprintf> <== NOT EXECUTED
20052c0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
20052c4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
20052c8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
20052cc: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
20052d0: 40 00 6e cb call 2020dfc <fputc> <== NOT EXECUTED
20052d4: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
20052d8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
20052dc: 40 00 6d b3 call 20209a8 <fflush> <== NOT EXECUTED
20052e0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
20052e4: 81 c7 e0 08 ret <== NOT EXECUTED
20052e8: 81 e8 00 00 restore <== NOT EXECUTED
02004ea0 <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, ...)
{
2004ea0: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004ea4: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2004ea8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2004eac: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2004eb0: 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)
2004eb4: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
2004eb8: 80 a0 60 01 cmp %g1, 1
2004ebc: 08 80 00 17 bleu 2004f18 <rtems_fdisk_info+0x78> <== ALWAYS TAKEN
2004ec0: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
2004ec4: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
2004ec8: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004ecc: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
2004ed0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
2004ed4: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2004ed8: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2004edc: 40 00 6f fd call 2020ed0 <fputs> <== NOT EXECUTED
2004ee0: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
2004ee4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
2004ee8: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2004eec: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2004ef0: 40 00 92 54 call 2029840 <vfprintf> <== NOT EXECUTED
2004ef4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2004ef8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
2004efc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
2004f00: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2004f04: 40 00 6f be call 2020dfc <fputc> <== NOT EXECUTED
2004f08: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
2004f0c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
2004f10: 40 00 6e a6 call 20209a8 <fflush> <== NOT EXECUTED
2004f14: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2004f18: 81 c7 e0 08 ret
2004f1c: 81 e8 00 00 restore
0200706c <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
200706c: 9d e3 bf 78 save %sp, -136, %sp
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
2007070: 7f ff f6 94 call 2004ac0 <rtems_disk_io_initialize>
2007074: b4 10 00 18 mov %i0, %i2
if (sc != RTEMS_SUCCESSFUL)
2007078: b0 92 20 00 orcc %o0, 0, %i0
200707c: 12 80 01 2e bne 2007534 <rtems_fdisk_initialize+0x4c8> <== NEVER TAKEN
2007080: 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);
2007084: 40 00 06 48 call 20089a4 <malloc>
2007088: 90 10 22 00 mov 0x200, %o0 ! 200 <PROM_START+0x200>
200708c: 03 00 81 18 sethi %hi(0x2046000), %g1
2007090: d0 20 61 a8 st %o0, [ %g1 + 0x1a8 ] ! 20461a8 <rtems_fdisk_crc16_factor>
if (!rtems_fdisk_crc16_factor)
2007094: 80 a2 20 00 cmp %o0, 0
2007098: 02 80 00 85 be 20072ac <rtems_fdisk_initialize+0x240> <== NEVER TAKEN
200709c: b0 10 20 1a mov 0x1a, %i0
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;
20070a0: 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)
20070a4: 82 10 20 00 clr %g1
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;
20070a8: 88 11 20 08 or %g4, 8, %g4
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
20070ac: 84 10 00 01 mov %g1, %g2
20070b0: 10 80 00 06 b 20070c8 <rtems_fdisk_initialize+0x5c>
20070b4: 86 10 20 09 mov 9, %g3
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
20070b8: 80 88 a0 01 btst 1, %g2
20070bc: 02 80 00 03 be 20070c8 <rtems_fdisk_initialize+0x5c>
20070c0: 85 37 60 11 srl %i5, 0x11, %g2
20070c4: 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--;)
20070c8: 86 80 ff ff addcc %g3, -1, %g3
20070cc: 32 bf ff fb bne,a 20070b8 <rtems_fdisk_initialize+0x4c>
20070d0: bb 28 a0 10 sll %g2, 0x10, %i5
* @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,
20070d4: 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++)
20070d8: 82 00 60 01 inc %g1
20070dc: 80 a0 61 00 cmp %g1, 0x100
20070e0: 12 bf ff f3 bne 20070ac <rtems_fdisk_initialize+0x40>
20070e4: 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,
20070e8: 10 80 01 15 b 200753c <rtems_fdisk_initialize+0x4d0>
20070ec: 3b 00 80 d6 sethi %hi(0x2035800), %i5
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";
20070f0: 86 10 e0 64 or %g3, 0x64, %g3
20070f4: 05 0b d9 19 sethi %hi(0x2f646400), %g2
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
20070f8: 03 00 81 18 sethi %hi(0x2046000), %g1
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";
20070fc: 84 10 a1 76 or %g2, 0x176, %g2
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
2007100: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1
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";
2007104: c4 3f bf f0 std %g2, [ %fp + -16 ]
2007108: 07 00 00 18 sethi %hi(0x6000), %g3
200710c: 86 10 e1 00 or %g3, 0x100, %g3 ! 6100 <PROM_START+0x6100>
2007110: c6 37 bf f8 sth %g3, [ %fp + -8 ]
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
2007114: f6 2f bf f9 stb %i3, [ %fp + -7 ]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
2007118: ba 00 40 19 add %g1, %i1, %i5
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
200711c: f4 20 40 19 st %i2, [ %g1 + %i1 ]
fd->minor = minor;
fd->flags = c->flags;
2007120: 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;
2007124: 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;
2007128: c2 27 60 08 st %g1, [ %i5 + 8 ]
fd->compact_segs = c->compact_segs;
200712c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2007130: 84 10 00 19 mov %i1, %g2
2007134: c2 27 60 0c st %g1, [ %i5 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
2007138: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
200713c: 86 10 00 1a mov %i2, %g3
2007140: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
2007144: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
2007148: f6 27 60 04 st %i3, [ %i5 + 4 ]
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;
200714c: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
fd->info_level = c->info_level;
2007150: c2 07 20 1c ld [ %i4 + 0x1c ], %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;
2007154: e2 27 60 14 st %l1, [ %i5 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
2007158: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
for (device = 0; device < c->device_count; device++)
200715c: ee 07 20 04 ld [ %i4 + 4 ], %l7
2007160: a4 10 20 00 clr %l2
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;
2007164: a0 10 20 00 clr %l0
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++)
2007168: b0 10 20 00 clr %i0
200716c: 82 10 00 1d mov %i5, %g1
2007170: b2 10 00 1b mov %i3, %i1
2007174: 10 80 00 21 b 20071f8 <rtems_fdisk_initialize+0x18c>
2007178: b4 10 00 1c mov %i4, %i2
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++)
200717c: 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],
2007180: b8 01 00 12 add %g4, %l2, %i4
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++)
2007184: fa 01 00 12 ld [ %g4 + %l2 ], %i5
2007188: aa 10 20 00 clr %l5
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
200718c: 10 80 00 15 b 20071e0 <rtems_fdisk_initialize+0x174>
2007190: a8 10 20 00 clr %l4
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
2007194: 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];
2007198: 88 06 c0 13 add %i3, %l3, %g4
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
200719c: d0 01 20 08 ld [ %g4 + 8 ], %o0
20071a0: c2 27 bf ec st %g1, [ %fp + -20 ]
20071a4: 7f ff ed 02 call 20025ac <.udiv>
20071a8: c4 3f bf e0 std %g2, [ %fp + -32 ]
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;
20071ac: 92 10 00 11 mov %l1, %o1
20071b0: ac 02 3f ff add %o0, -1, %l6
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);
20071b4: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
20071b8: 7f ff ec fd call 20025ac <.udiv>
20071bc: 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;
20071c0: d2 16 c0 13 lduh [ %i3 + %l3 ], %o1
20071c4: 7f ff ec c0 call 20024c4 <.umul>
20071c8: 90 25 80 08 sub %l6, %o0, %o0
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++)
20071cc: c4 1f bf e0 ldd [ %fp + -32 ], %g2
20071d0: c2 07 bf ec ld [ %fp + -20 ], %g1
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
20071d4: a8 05 00 08 add %l4, %o0, %l4
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++)
20071d8: aa 05 60 01 inc %l5
20071dc: a6 04 e0 0c add %l3, 0xc, %l3
20071e0: 80 a5 40 1d cmp %l5, %i5
20071e4: 32 bf ff ec bne,a 2007194 <rtems_fdisk_initialize+0x128>
20071e8: f6 07 20 04 ld [ %i4 + 4 ], %i3
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],
20071ec: a0 04 00 14 add %l0, %l4, %l0
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++)
20071f0: b0 06 20 01 inc %i0
20071f4: a4 04 a0 0c add %l2, 0xc, %l2
20071f8: 80 a6 00 17 cmp %i0, %l7
20071fc: 32 bf ff e0 bne,a 200717c <rtems_fdisk_initialize+0x110>
2007200: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2007204: ba 10 00 01 mov %g1, %i5
2007208: b6 10 00 19 mov %i1, %i3
200720c: b8 10 00 1a mov %i2, %i4
2007210: b2 10 00 02 mov %g2, %i1
2007214: b4 10 00 03 mov %g3, %i2
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
2007218: 40 00 05 e3 call 20089a4 <malloc>
200721c: 90 10 00 11 mov %l1, %o0
if (!fd->copy_buffer)
2007220: 80 a2 20 00 cmp %o0, 0
2007224: 02 80 00 c1 be 2007528 <rtems_fdisk_initialize+0x4bc> <== NEVER TAKEN
2007228: d0 27 60 64 st %o0, [ %i5 + 0x64 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
200722c: 90 10 00 10 mov %l0, %o0
2007230: 40 00 02 cb call 2007d5c <calloc>
2007234: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
2007238: 80 a2 20 00 cmp %o0, 0
200723c: 02 80 00 bb be 2007528 <rtems_fdisk_initialize+0x4bc> <== NEVER TAKEN
2007240: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
2007244: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
2007248: 90 10 00 18 mov %i0, %o0
200724c: 40 00 02 c4 call 2007d5c <calloc>
2007250: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
2007254: 80 a2 20 00 cmp %o0, 0
2007258: 02 80 00 b6 be 2007530 <rtems_fdisk_initialize+0x4c4> <== NEVER TAKEN
200725c: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
2007260: 03 00 80 c4 sethi %hi(0x2031000), %g1
2007264: d0 00 63 cc ld [ %g1 + 0x3cc ], %o0 ! 20313cc <__FUNCTION__.6925+0x10bc>
2007268: 92 10 20 01 mov 1, %o1
200726c: 94 10 20 54 mov 0x54, %o2
2007270: 96 10 20 00 clr %o3
2007274: 40 00 16 02 call 200ca7c <rtems_semaphore_create>
2007278: 98 07 60 60 add %i5, 0x60, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
200727c: b0 92 20 00 orcc %o0, 0, %i0
2007280: 22 80 00 0d be,a 20072b4 <rtems_fdisk_initialize+0x248> <== ALWAYS TAKEN
2007284: d6 07 60 20 ld [ %i5 + 0x20 ], %o3
{
rtems_fdisk_error ("disk lock create failed");
2007288: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
200728c: 7f ff f7 fb call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2007290: 90 12 23 50 or %o0, 0x350, %o0 ! 2031350 <__FUNCTION__.6925+0x1040><== NOT EXECUTED
free (fd->copy_buffer);
2007294: 40 00 03 ae call 200814c <free> <== NOT EXECUTED
2007298: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->blocks);
200729c: 40 00 03 ac call 200814c <free> <== NOT EXECUTED
20072a0: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
20072a4: 40 00 03 aa call 200814c <free> <== NOT EXECUTED
20072a8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
return sc;
20072ac: 81 c7 e0 08 ret <== NOT EXECUTED
20072b0: 81 e8 00 00 restore <== NOT EXECUTED
}
sc = rtems_disk_create_phys(dev, c->block_size,
20072b4: d4 07 00 00 ld [ %i4 ], %o2
20072b8: 84 07 bf f0 add %fp, -16, %g2
20072bc: 90 10 00 1a mov %i2, %o0
20072c0: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
20072c4: 92 10 00 1b mov %i3, %o1
20072c8: 96 24 00 0b sub %l0, %o3, %o3
20072cc: 19 00 80 17 sethi %hi(0x2005c00), %o4
20072d0: 9a 10 20 00 clr %o5
20072d4: 7f ff f4 bf call 20045d0 <rtems_disk_create_phys>
20072d8: 98 13 22 54 or %o4, 0x254, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
20072dc: b0 92 20 00 orcc %o0, 0, %i0
20072e0: 22 80 00 52 be,a 2007428 <rtems_fdisk_initialize+0x3bc> <== ALWAYS TAKEN
20072e4: b0 10 20 00 clr %i0
{
rtems_semaphore_delete (fd->lock);
20072e8: 40 00 16 50 call 200cc28 <rtems_semaphore_delete> <== NOT EXECUTED
20072ec: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
20072f0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20072f4: 7f ff f5 1d call 2004768 <rtems_disk_delete> <== NOT EXECUTED
20072f8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
20072fc: 40 00 03 94 call 200814c <free> <== NOT EXECUTED
2007300: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007304: 40 00 03 92 call 200814c <free> <== NOT EXECUTED
2007308: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
200730c: 40 00 03 90 call 200814c <free> <== NOT EXECUTED
2007310: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
2007314: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2007318: 7f ff f7 d8 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
200731c: 90 12 23 68 or %o0, 0x368, %o0 ! 2031368 <__FUNCTION__.6925+0x1058><== NOT EXECUTED
return sc;
2007320: 81 c7 e0 08 ret <== NOT EXECUTED
2007324: 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++)
2007328: 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]);
200732c: a4 00 40 18 add %g1, %i0, %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++)
2007330: e8 00 40 18 ld [ %g1 + %i0 ], %l4
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
2007334: a2 10 20 00 clr %l1
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
2007338: 10 80 00 06 b 2007350 <rtems_fdisk_initialize+0x2e4>
200733c: 82 10 20 00 clr %g1
2007340: 82 00 60 01 inc %g1
count += dd->segments[segment].count;
2007344: c6 10 c0 02 lduh [ %g3 + %g2 ], %g3
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++)
2007348: 84 00 a0 0c add %g2, 0xc, %g2
count += dd->segments[segment].count;
200734c: 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++)
2007350: 80 a0 40 14 cmp %g1, %l4
2007354: 32 bf ff fb bne,a 2007340 <rtems_fdisk_initialize+0x2d4>
2007358: 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,
200735c: ea 07 60 28 ld [ %i5 + 0x28 ], %l5
2007360: 90 10 00 11 mov %l1, %o0
2007364: 40 00 02 7e call 2007d5c <calloc>
2007368: 92 10 20 30 mov 0x30, %o1
200736c: d0 25 40 18 st %o0, [ %l5 + %i0 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
2007370: 80 a2 20 00 cmp %o0, 0
2007374: 12 80 00 23 bne 2007400 <rtems_fdisk_initialize+0x394> <== ALWAYS TAKEN
2007378: a6 05 40 18 add %l5, %i0, %l3
{
rtems_disk_delete (dev);
200737c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2007380: 7f ff f4 fa call 2004768 <rtems_disk_delete> <== NOT EXECUTED
2007384: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007388: 40 00 16 28 call 200cc28 <rtems_semaphore_delete> <== NOT EXECUTED
200738c: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007390: 40 00 03 6f call 200814c <free> <== NOT EXECUTED
2007394: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007398: 40 00 03 6d call 200814c <free> <== NOT EXECUTED
200739c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
20073a0: 40 00 03 6b call 200814c <free> <== NOT EXECUTED
20073a4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
if (!fd->blocks)
return RTEMS_NO_MEMORY;
20073a8: 81 c7 e0 08 ret <== NOT EXECUTED
20073ac: 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++)
20073b0: 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];
20073b4: 9a 00 40 02 add %g1, %g2, %o5
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
20073b8: de 10 40 02 lduh [ %g1 + %g2 ], %o7
20073bc: 10 80 00 07 b 20073d8 <rtems_fdisk_initialize+0x36c>
20073c0: 82 10 00 08 mov %o0, %g1
{
sc->descriptor = sd;
20073c4: da 20 60 04 st %o5, [ %g1 + 4 ]
sc->device = device;
20073c8: e0 20 60 08 st %l0, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
20073cc: 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++)
20073d0: 86 00 e0 01 inc %g3
20073d4: 82 00 60 30 add %g1, 0x30, %g1
20073d8: 80 a0 c0 0f cmp %g3, %o7
20073dc: 2a bf ff fa bcs,a 20073c4 <rtems_fdisk_initialize+0x358>
20073e0: 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,
20073e4: 83 2b e0 04 sll %o7, 4, %g1
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
20073e8: 88 01 20 01 inc %g4
* @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,
20073ec: 9f 2b e0 06 sll %o7, 6, %o7
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
20073f0: 84 00 a0 0c add %g2, 0xc, %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,
20073f4: 9e 23 c0 01 sub %o7, %g1, %o7
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++)
20073f8: 10 80 00 04 b 2007408 <rtems_fdisk_initialize+0x39c>
20073fc: 90 02 00 0f add %o0, %o7, %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)
2007400: 84 10 20 00 clr %g2
2007404: 88 10 20 00 clr %g4
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
2007408: 80 a1 00 14 cmp %g4, %l4
200740c: 32 bf ff e9 bne,a 20073b0 <rtems_fdisk_initialize+0x344>
2007410: c2 04 a0 04 ld [ %l2 + 4 ], %g1
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
2007414: e2 24 e0 04 st %l1, [ %l3 + 4 ]
fd->devices[device].descriptor = &c->devices[device];
2007418: e4 24 e0 08 st %l2, [ %l3 + 8 ]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
200741c: a0 04 20 01 inc %l0
2007420: 10 80 00 03 b 200742c <rtems_fdisk_initialize+0x3c0>
2007424: b0 06 20 0c add %i0, 0xc, %i0
}
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
2007428: a0 10 20 00 clr %l0
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
200742c: c2 07 20 04 ld [ %i4 + 4 ], %g1
2007430: 80 a4 00 01 cmp %l0, %g1
2007434: 2a bf ff bd bcs,a 2007328 <rtems_fdisk_initialize+0x2bc>
2007438: 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;
200743c: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
ret = rtems_fdisk_recover_block_mappings (fd);
2007440: 7f ff f9 b2 call 2005b08 <rtems_fdisk_recover_block_mappings>
2007444: 90 10 00 1d mov %i5, %o0
if (ret)
2007448: b0 92 20 00 orcc %o0, 0, %i0
200744c: 22 80 00 13 be,a 2007498 <rtems_fdisk_initialize+0x42c> <== ALWAYS TAKEN
2007450: 90 10 00 1d mov %i5, %o0
{
rtems_disk_delete (dev);
2007454: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2007458: 7f ff f4 c4 call 2004768 <rtems_disk_delete> <== NOT EXECUTED
200745c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007460: 40 00 15 f2 call 200cc28 <rtems_semaphore_delete> <== NOT EXECUTED
2007464: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007468: 40 00 03 39 call 200814c <free> <== NOT EXECUTED
200746c: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007470: 40 00 03 37 call 200814c <free> <== NOT EXECUTED
2007474: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007478: 40 00 03 35 call 200814c <free> <== NOT EXECUTED
200747c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
2007480: 40 00 6e 36 call 2022d58 <strerror> <== NOT EXECUTED
2007484: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2007488: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
200748c: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2007490: 10 80 00 17 b 20074ec <rtems_fdisk_initialize+0x480> <== NOT EXECUTED
2007494: 90 12 23 80 or %o0, 0x380, %o0 ! 2031380 <__FUNCTION__.6925+0x1070><== NOT EXECUTED
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
2007498: 7f ff f9 19 call 20058fc <rtems_fdisk_compact>
200749c: b2 06 60 70 add %i1, 0x70, %i1
if (ret)
20074a0: 80 a2 20 00 cmp %o0, 0
20074a4: 02 80 00 16 be 20074fc <rtems_fdisk_initialize+0x490> <== ALWAYS TAKEN
20074a8: b0 10 00 08 mov %o0, %i0
{
rtems_disk_delete (dev);
20074ac: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20074b0: 7f ff f4 ae call 2004768 <rtems_disk_delete> <== NOT EXECUTED
20074b4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
20074b8: 40 00 15 dc call 200cc28 <rtems_semaphore_delete> <== NOT EXECUTED
20074bc: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
20074c0: 40 00 03 23 call 200814c <free> <== NOT EXECUTED
20074c4: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->blocks);
20074c8: 40 00 03 21 call 200814c <free> <== NOT EXECUTED
20074cc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
20074d0: 40 00 03 1f call 200814c <free> <== NOT EXECUTED
20074d4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
20074d8: 40 00 6e 20 call 2022d58 <strerror> <== NOT EXECUTED
20074dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20074e0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
20074e4: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
20074e8: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 20313a8 <__FUNCTION__.6925+0x1098><== NOT EXECUTED
20074ec: 7f ff f7 63 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20074f0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
strerror (ret), ret);
return ret;
20074f4: 81 c7 e0 08 ret <== NOT EXECUTED
20074f8: 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++)
20074fc: b6 06 e0 01 inc %i3
2007500: b8 07 20 20 add %i4, 0x20, %i4
2007504: 07 00 80 d6 sethi %hi(0x2035800), %g3
2007508: c2 00 e1 b4 ld [ %g3 + 0x1b4 ], %g1 ! 20359b4 <rtems_flashdisk_configuration_size>
200750c: 80 a6 c0 01 cmp %i3, %g1
2007510: 2a bf fe f8 bcs,a 20070f0 <rtems_fdisk_initialize+0x84>
2007514: 07 0b d9 99 sethi %hi(0x2f666400), %g3
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
2007518: 05 00 81 18 sethi %hi(0x2046000), %g2
200751c: c2 20 a1 b0 st %g1, [ %g2 + 0x1b0 ] ! 20461b0 <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
2007520: 81 c7 e0 08 ret
2007524: 91 e8 20 00 restore %g0, 0, %o0
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
if (!fd->blocks)
return RTEMS_NO_MEMORY;
2007528: 81 c7 e0 08 ret <== NOT EXECUTED
200752c: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
fd->block_count = blocks;
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
2007530: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
2007534: 81 c7 e0 08 ret <== NOT EXECUTED
2007538: 81 e8 00 00 restore <== NOT EXECUTED
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
200753c: d0 07 61 b4 ld [ %i5 + 0x1b4 ], %o0
2007540: 40 00 02 07 call 2007d5c <calloc>
2007544: 92 10 20 70 mov 0x70, %o1
2007548: 03 00 81 18 sethi %hi(0x2046000), %g1
200754c: d0 20 61 ac st %o0, [ %g1 + 0x1ac ] ! 20461ac <rtems_flashdisks>
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
2007550: 80 a2 20 00 cmp %o0, 0
2007554: 02 bf ff 56 be 20072ac <rtems_fdisk_initialize+0x240> <== NEVER TAKEN
2007558: b0 10 20 1a mov 0x1a, %i0
200755c: 39 00 80 bf sethi %hi(0x202fc00), %i4
2007560: b2 10 20 00 clr %i1
2007564: b8 17 22 ec or %i4, 0x2ec, %i4
2007568: 10 bf ff e7 b 2007504 <rtems_fdisk_initialize+0x498>
200756c: b6 10 20 00 clr %i3
02005e54 <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)
{
2005e54: 9d e3 bf 48 save %sp, -184, %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;
2005e58: 40 00 69 c4 call 2020568 <__errno>
2005e5c: f8 06 20 04 ld [ %i0 + 4 ], %i4
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
2005e60: 83 2f 20 04 sll %i4, 4, %g1
2005e64: b7 2f 20 07 sll %i4, 7, %i3
2005e68: 3b 00 81 18 sethi %hi(0x2046000), %i5
2005e6c: b6 26 c0 01 sub %i3, %g1, %i3
2005e70: c2 07 61 ac ld [ %i5 + 0x1ac ], %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;
2005e74: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
2005e78: 82 00 40 1b add %g1, %i3, %g1
2005e7c: d0 00 60 60 ld [ %g1 + 0x60 ], %o0
2005e80: 92 10 20 00 clr %o1
2005e84: 40 00 1b 98 call 200cce4 <rtems_semaphore_obtain>
2005e88: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
2005e8c: 80 a2 20 00 cmp %o0, 0
2005e90: 12 80 04 68 bne 2007030 <rtems_fdisk_ioctl+0x11dc> <== NEVER TAKEN
2005e94: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
2005e98: 40 00 69 b4 call 2020568 <__errno>
2005e9c: 01 00 00 00 nop
switch (req)
2005ea0: 03 08 00 10 sethi %hi(0x20004000), %g1
2005ea4: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_END+0x1dc04283>
2005ea8: 80 a6 40 02 cmp %i1, %g2
2005eac: 02 80 02 e3 be 2006a38 <rtems_fdisk_ioctl+0xbe4> <== NEVER TAKEN
2005eb0: c0 22 00 00 clr [ %o0 ]
2005eb4: 80 a6 40 02 cmp %i1, %g2
2005eb8: 38 80 00 0c bgu,a 2005ee8 <rtems_fdisk_ioctl+0x94>
2005ebc: 82 10 62 85 or %g1, 0x285, %g1
2005ec0: 84 10 62 81 or %g1, 0x281, %g2
2005ec4: 80 a6 40 02 cmp %i1, %g2
2005ec8: 02 80 02 be be 20069c0 <rtems_fdisk_ioctl+0xb6c> <== NEVER TAKEN
2005ecc: 01 00 00 00 nop
2005ed0: 18 80 02 c4 bgu 20069e0 <rtems_fdisk_ioctl+0xb8c> <== NEVER TAKEN
2005ed4: 82 10 62 80 or %g1, 0x280, %g1
2005ed8: 80 a6 40 01 cmp %i1, %g1
2005edc: 32 80 04 4a bne,a 2007004 <rtems_fdisk_ioctl+0x11b0> <== ALWAYS TAKEN
2005ee0: 90 10 00 18 mov %i0, %o0
2005ee4: 30 80 02 7b b,a 20068d0 <rtems_fdisk_ioctl+0xa7c> <== NOT EXECUTED
2005ee8: 80 a6 40 01 cmp %i1, %g1
2005eec: 02 80 03 40 be 2006bec <rtems_fdisk_ioctl+0xd98>
2005ef0: 01 00 00 00 nop
2005ef4: 0a 80 03 3b bcs 2006be0 <rtems_fdisk_ioctl+0xd8c> <== NEVER TAKEN
2005ef8: c2 07 61 ac ld [ %i5 + 0x1ac ], %g1
2005efc: 03 30 06 10 sethi %hi(0xc0184000), %g1
2005f00: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
2005f04: 80 a6 40 01 cmp %i1, %g1
2005f08: 12 80 04 3f bne 2007004 <rtems_fdisk_ioctl+0x11b0>
2005f0c: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
2005f10: 03 00 81 18 sethi %hi(0x2046000), %g1
2005f14: c2 00 61 b0 ld [ %g1 + 0x1b0 ], %g1 ! 20461b0 <rtems_flashdisk_count>
2005f18: 80 a7 00 01 cmp %i4, %g1
2005f1c: 1a 80 00 08 bcc 2005f3c <rtems_fdisk_ioctl+0xe8> <== NEVER TAKEN
2005f20: 01 00 00 00 nop
(rtems_flashdisks[minor].device_count == 0))
2005f24: c2 07 61 ac ld [ %i5 + 0x1ac ], %g1
2005f28: 82 00 40 1b add %g1, %i3, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
2005f2c: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
2005f30: 80 a0 60 00 cmp %g1, 0
2005f34: 32 80 00 06 bne,a 2005f4c <rtems_fdisk_ioctl+0xf8> <== ALWAYS TAKEN
2005f38: c2 06 80 00 ld [ %i2 ], %g1
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
2005f3c: 40 00 69 8b call 2020568 <__errno> <== NOT EXECUTED
2005f40: 01 00 00 00 nop <== NOT EXECUTED
2005f44: 10 80 02 61 b 20068c8 <rtems_fdisk_ioctl+0xa74> <== NOT EXECUTED
2005f48: 82 10 20 13 mov 0x13, %g1 ! 13 <PROM_START+0x13> <== NOT EXECUTED
}
else
{
switch (r->req)
2005f4c: 80 a0 60 00 cmp %g1, 0
2005f50: 02 80 00 05 be 2005f64 <rtems_fdisk_ioctl+0x110>
2005f54: 80 a0 60 01 cmp %g1, 1
2005f58: 12 80 02 59 bne 20068bc <rtems_fdisk_ioctl+0xa68> <== NEVER TAKEN
2005f5c: 01 00 00 00 nop
2005f60: 30 80 00 bf b,a 200625c <rtems_fdisk_ioctl+0x408>
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
2005f64: 40 00 69 81 call 2020568 <__errno>
2005f68: b0 06 a0 18 add %i2, 0x18, %i0
2005f6c: f8 07 61 ac ld [ %i5 + 0x1ac ], %i4
2005f70: d0 27 bf f4 st %o0, [ %fp + -12 ]
2005f74: 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++)
2005f78: ac 10 20 00 clr %l6
2005f7c: 10 80 00 a9 b 2006220 <rtems_fdisk_ioctl+0x3cc>
2005f80: aa 10 00 1b mov %i3, %l5
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
2005f84: d2 07 20 14 ld [ %i4 + 0x14 ], %o1
2005f88: 7f ff f1 89 call 20025ac <.udiv>
2005f8c: a6 10 00 15 mov %l5, %l3
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2005f90: a0 10 20 00 clr %l0
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;
2005f94: ae 10 00 08 mov %o0, %l7
data = sg->buffer;
2005f98: f2 06 20 08 ld [ %i0 + 8 ], %i1
2005f9c: 10 80 00 97 b 20061f8 <rtems_fdisk_ioctl+0x3a4>
2005fa0: aa 10 00 1a mov %i2, %l5
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);
2005fa4: 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);
2005fa8: b6 04 00 1b add %l0, %i3, %i3
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);
2005fac: 13 00 80 c3 sethi %hi(0x2030c00), %o1
2005fb0: 94 10 00 1b mov %i3, %o2
2005fb4: 7f ff fb bb call 2004ea0 <rtems_fdisk_info>
2005fb8: 92 12 61 48 or %o1, 0x148, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
2005fbc: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
2005fc0: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
2005fc4: 82 20 80 01 sub %g2, %g1, %g1
2005fc8: 80 a6 c0 01 cmp %i3, %g1
2005fcc: 2a 80 00 0a bcs,a 2005ff4 <rtems_fdisk_ioctl+0x1a0> <== ALWAYS TAKEN
2005fd0: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
2005fd4: b4 10 00 15 mov %l5, %i2 <== NOT EXECUTED
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
2005fd8: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005fdc: aa 10 00 13 mov %l3, %l5 <== NOT EXECUTED
2005fe0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2005fe4: 7f ff fc a5 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2005fe8: 90 12 21 58 or %o0, 0x158, %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)
2005fec: 10 80 00 89 b 2006210 <rtems_fdisk_ioctl+0x3bc> <== NOT EXECUTED
2005ff0: 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];
2005ff4: 83 2e e0 03 sll %i3, 3, %g1
if (!bc->segment)
2005ff8: fa 00 80 01 ld [ %g2 + %g1 ], %i5
2005ffc: 80 a7 60 00 cmp %i5, 0
2006000: 12 80 00 0d bne 2006034 <rtems_fdisk_ioctl+0x1e0>
2006004: a8 00 80 01 add %g2, %g1, %l4
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
2006008: 94 10 00 1b mov %i3, %o2
200600c: 90 10 00 1c mov %i4, %o0
2006010: 13 00 80 c3 sethi %hi(0x2030c00), %o1
2006014: 7f ff fb a3 call 2004ea0 <rtems_fdisk_info>
2006018: 92 12 61 80 or %o1, 0x180, %o1 ! 2030d80 <__FUNCTION__.6925+0xa70>
#endif
memset (buffer, 0xff, fd->block_size);
200601c: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
2006020: 90 10 00 19 mov %i1, %o0
2006024: 40 00 6e 3d call 2021918 <memset>
2006028: 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)
200602c: 10 80 04 0d b 2007060 <rtems_fdisk_ioctl+0x120c>
2006030: 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];
2006034: da 05 20 04 ld [ %l4 + 4 ], %o5
2006038: e2 07 60 10 ld [ %i5 + 0x10 ], %l1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
200603c: d4 07 40 00 ld [ %i5 ], %o2
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
2006040: b5 2b 60 03 sll %o5, 3, %i2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2006044: 13 00 80 c2 sethi %hi(0x2030800), %o1
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
2006048: a4 04 40 1a add %l1, %i2, %l2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
200604c: d6 07 60 08 ld [ %i5 + 8 ], %o3
2006050: d8 07 60 0c ld [ %i5 + 0xc ], %o4
2006054: de 07 60 14 ld [ %i5 + 0x14 ], %o7
2006058: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
200605c: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
2006060: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
2006064: 80 a2 a0 00 cmp %o2, 0
2006068: 02 80 00 04 be 2006078 <rtems_fdisk_ioctl+0x224> <== NEVER TAKEN
200606c: 82 12 61 60 or %o1, 0x160, %g1
2006070: 15 00 80 c2 sethi %hi(0x2030800), %o2
2006074: 82 12 a1 58 or %o2, 0x158, %g1 ! 2030958 <__FUNCTION__.6925+0x648>
2006078: de 23 a0 5c st %o7, [ %sp + 0x5c ]
200607c: c8 23 a0 60 st %g4, [ %sp + 0x60 ]
2006080: c6 23 a0 64 st %g3, [ %sp + 0x64 ]
2006084: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
2006088: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
200608c: c2 14 a0 02 lduh [ %l2 + 2 ], %g1
2006090: 90 10 00 1c mov %i4, %o0
2006094: c2 23 a0 70 st %g1, [ %sp + 0x70 ]
2006098: c2 14 40 1a lduh [ %l1 + %i2 ], %g1
200609c: 13 00 80 c3 sethi %hi(0x2030c00), %o1
20060a0: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
20060a4: c2 04 a0 04 ld [ %l2 + 4 ], %g1
20060a8: 92 12 61 a8 or %o1, 0x1a8, %o1
20060ac: c2 23 a0 78 st %g1, [ %sp + 0x78 ]
20060b0: 7f ff fb 7c call 2004ea0 <rtems_fdisk_info>
20060b4: 94 10 00 1b mov %i3, %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;
20060b8: c2 14 a0 02 lduh [ %l2 + 2 ], %g1
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))
20060bc: 80 88 60 01 btst 1, %g1
20060c0: 12 80 00 44 bne 20061d0 <rtems_fdisk_ioctl+0x37c> <== NEVER TAKEN
20060c4: d8 05 20 04 ld [ %l4 + 4 ], %o4
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
20060c8: 80 88 60 02 btst 2, %g1
20060cc: 22 80 00 3d be,a 20061c0 <rtems_fdisk_ioctl+0x36c> <== NEVER TAKEN
20060d0: b4 10 00 15 mov %l5, %i2 <== NOT EXECUTED
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);
20060d4: e4 07 20 14 ld [ %i4 + 0x14 ], %l2
/*
* 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,
20060d8: 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,
20060dc: 92 10 00 12 mov %l2, %o1
20060e0: 7f ff f0 f9 call 20024c4 <.umul>
20060e4: 90 02 00 0c add %o0, %o4, %o0
20060e8: 92 10 00 1d mov %i5, %o1
20060ec: 94 10 00 08 mov %o0, %o2
20060f0: 96 10 00 19 mov %i1, %o3
20060f4: 90 10 00 1c mov %i4, %o0
20060f8: 7f ff fb aa call 2004fa0 <rtems_fdisk_seg_read>
20060fc: 98 10 00 12 mov %l2, %o4
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
bc->page + sc->pages_desc, buffer);
if (ret)
2006100: 82 92 20 00 orcc %o0, 0, %g1
2006104: 22 80 00 14 be,a 2006154 <rtems_fdisk_ioctl+0x300> <== ALWAYS TAKEN
2006108: 03 00 81 18 sethi %hi(0x2046000), %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
200610c: f2 07 60 08 ld [ %i5 + 8 ], %i1 <== NOT EXECUTED
2006110: f6 07 60 0c ld [ %i5 + 0xc ], %i3 <== NOT EXECUTED
2006114: fa 05 20 04 ld [ %l4 + 4 ], %i5 <== NOT EXECUTED
2006118: b4 10 00 15 mov %l5, %i2 <== NOT EXECUTED
200611c: aa 10 00 13 mov %l3, %l5 <== NOT EXECUTED
2006120: 40 00 73 0e call 2022d58 <strerror> <== NOT EXECUTED
2006124: a6 10 00 01 mov %g1, %l3 <== NOT EXECUTED
2006128: 13 00 80 c3 sethi %hi(0x2030c00), %o1 <== NOT EXECUTED
200612c: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
2006130: e6 23 a0 5c st %l3, [ %sp + 0x5c ] <== NOT EXECUTED
2006134: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2006138: 92 12 61 f0 or %o1, 0x1f0, %o1 <== NOT EXECUTED
200613c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2006140: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
2006144: 7f ff fb 57 call 2004ea0 <rtems_fdisk_info> <== NOT EXECUTED
2006148: 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)
200614c: 10 80 00 31 b 2006210 <rtems_fdisk_ioctl+0x3bc> <== NOT EXECUTED
2006150: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
2006154: 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);
2006158: c4 00 61 a8 ld [ %g1 + 0x1a8 ], %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;
200615c: 94 10 3f ff mov -1, %o2
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2006160: 10 80 00 09 b 2006184 <rtems_fdisk_ioctl+0x330>
2006164: 82 10 20 00 clr %g1
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006168: c8 0e 40 01 ldub [ %i1 + %g1 ], %g4
200616c: 95 32 a0 10 srl %o2, 0x10, %o2
2006170: 94 19 00 0a xor %g4, %o2, %o2
2006174: 94 0a a0 ff and %o2, 0xff, %o2
2006178: 95 2a a0 01 sll %o2, 1, %o2
200617c: d4 10 80 0a lduh [ %g2 + %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++)
2006180: 82 00 60 01 inc %g1
2006184: 80 a0 40 03 cmp %g1, %g3
2006188: 12 bf ff f8 bne 2006168 <rtems_fdisk_ioctl+0x314>
200618c: 95 2a a0 10 sll %o2, 0x10, %o2
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
2006190: d6 14 40 1a lduh [ %l1 + %i2 ], %o3
2006194: 95 32 a0 10 srl %o2, 0x10, %o2
2006198: 80 a2 80 0b cmp %o2, %o3
200619c: 02 80 03 b0 be 200705c <rtems_fdisk_ioctl+0x1208> <== ALWAYS TAKEN
20061a0: b4 10 00 15 mov %l5, %i2
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
20061a4: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20061a8: aa 10 00 13 mov %l3, %l5 <== NOT EXECUTED
20061ac: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20061b0: 7f ff fc 32 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20061b4: 90 12 22 28 or %o0, 0x228, %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)
20061b8: 10 80 00 16 b 2006210 <rtems_fdisk_ioctl+0x3bc> <== NOT EXECUTED
20061bc: 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",
20061c0: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20061c4: aa 10 00 13 mov %l3, %l5 <== NOT EXECUTED
20061c8: 10 80 00 06 b 20061e0 <rtems_fdisk_ioctl+0x38c> <== NOT EXECUTED
20061cc: 90 12 22 60 or %o0, 0x260, %o0 <== NOT EXECUTED
20061d0: b4 10 00 15 mov %l5, %i2 <== NOT EXECUTED
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
20061d4: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20061d8: aa 10 00 13 mov %l3, %l5 <== NOT EXECUTED
20061dc: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED
20061e0: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
20061e4: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
20061e8: 7f ff fc 24 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20061ec: 92 10 00 1b mov %i3, %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)
20061f0: 10 80 00 08 b 2006210 <rtems_fdisk_ioctl+0x3bc> <== NOT EXECUTED
20061f4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
20061f8: 80 a4 00 17 cmp %l0, %l7
20061fc: 32 bf ff 6a bne,a 2005fa4 <rtems_fdisk_ioctl+0x150>
2006200: f6 06 00 00 ld [ %i0 ], %i3
2006204: b4 10 00 15 mov %l5, %i2
2006208: 82 10 20 00 clr %g1
200620c: aa 10 00 13 mov %l3, %l5
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2006210: ac 05 a0 01 inc %l6
2006214: 80 a0 60 00 cmp %g1, 0
2006218: 12 80 00 09 bne 200623c <rtems_fdisk_ioctl+0x3e8> <== NEVER TAKEN
200621c: b0 06 20 10 add %i0, 0x10, %i0
2006220: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2006224: 80 a5 80 01 cmp %l6, %g1
2006228: 2a bf ff 57 bcs,a 2005f84 <rtems_fdisk_ioctl+0x130>
200622c: d0 06 20 04 ld [ %i0 + 4 ], %o0
2006230: b6 10 00 15 mov %l5, %i3
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
2006234: 10 80 00 04 b 2006244 <rtems_fdisk_ioctl+0x3f0>
2006238: 92 10 20 00 clr %o1
200623c: b6 10 00 15 mov %l5, %i3 <== NOT EXECUTED
2006240: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
2006244: c2 06 a0 04 ld [ %i2 + 4 ], %g1
2006248: d0 06 a0 08 ld [ %i2 + 8 ], %o0
200624c: 9f c0 40 00 call %g1
2006250: d2 26 a0 0c st %o1, [ %i2 + 0xc ]
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]);
2006254: 10 80 03 6a b 2006ffc <rtems_fdisk_ioctl+0x11a8>
2006258: c4 07 bf f4 ld [ %fp + -12 ], %g2
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);
200625c: 40 00 68 c3 call 2020568 <__errno>
2006260: a0 06 a0 18 add %i2, 0x18, %l0
2006264: 03 00 81 18 sethi %hi(0x2046000), %g1
2006268: fa 00 61 ac ld [ %g1 + 0x1ac ], %i5 ! 20461ac <rtems_flashdisks>
200626c: d0 27 bf e8 st %o0, [ %fp + -24 ]
2006270: ba 07 40 1b add %i5, %i3, %i5
rtems_fdisk_compact (fd);
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
2006274: 82 07 60 30 add %i5, 0x30, %g1
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2006278: c0 27 bf f4 clr [ %fp + -12 ]
rtems_fdisk_compact (fd);
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
200627c: c2 27 bf f0 st %g1, [ %fp + -16 ]
2006280: 10 80 01 7e b 2006878 <rtems_fdisk_ioctl+0xa24>
2006284: f6 27 bf ec st %i3, [ %fp + -20 ]
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;
2006288: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
200628c: 7f ff f0 c8 call 20025ac <.udiv>
2006290: a2 10 20 00 clr %l1
2006294: ae 10 00 1a mov %i2, %l7
2006298: d0 27 bf e4 st %o0, [ %fp + -28 ]
data = sg->buffer;
200629c: 10 80 01 6b b 2006848 <rtems_fdisk_ioctl+0x9f4>
20062a0: f0 04 20 08 ld [ %l0 + 8 ], %i0
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
20062a4: 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);
20062a8: b6 04 40 1b add %l1, %i3, %i3
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
20062ac: 13 00 80 c3 sethi %hi(0x2030c00), %o1
20062b0: 94 10 00 1b mov %i3, %o2
20062b4: 7f ff fa fb call 2004ea0 <rtems_fdisk_info>
20062b8: 92 12 62 c8 or %o1, 0x2c8, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
20062bc: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
20062c0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
20062c4: 82 20 80 01 sub %g2, %g1, %g1
20062c8: 80 a6 c0 01 cmp %i3, %g1
20062cc: 2a 80 00 09 bcs,a 20062f0 <rtems_fdisk_ioctl+0x49c> <== ALWAYS TAKEN
20062d0: ea 07 60 18 ld [ %i5 + 0x18 ], %l5
20062d4: b4 10 00 17 mov %l7, %i2 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
20062d8: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20062dc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20062e0: 7f ff fb e6 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20062e4: 90 12 22 d8 or %o0, 0x2d8, %o0 <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
rtems_fdisk_queue_segment (fd, sc);
return EIO;
20062e8: 10 80 01 5e b 2006860 <rtems_fdisk_ioctl+0xa0c> <== NOT EXECUTED
20062ec: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
20062f0: ad 2e e0 03 sll %i3, 3, %l6
/*
* Does the page exist in flash ?
*/
if (bc->segment)
20062f4: f8 05 40 16 ld [ %l5 + %l6 ], %i4
20062f8: 80 a7 20 00 cmp %i4, 0
20062fc: 02 80 00 92 be 2006544 <rtems_fdisk_ioctl+0x6f0>
2006300: b4 05 40 16 add %l5, %l6, %i2
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006304: c6 06 a0 04 ld [ %i2 + 4 ], %g3
2006308: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
200630c: d4 07 20 08 ld [ %i4 + 8 ], %o2
2006310: d6 07 20 0c ld [ %i4 + 0xc ], %o3
2006314: 98 10 00 03 mov %g3, %o4
2006318: c6 27 bf d4 st %g3, [ %fp + -44 ]
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
200631c: c4 27 bf e0 st %g2, [ %fp + -32 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006320: 90 10 00 1d mov %i5, %o0
2006324: 13 00 80 c3 sethi %hi(0x2030c00), %o1
2006328: 7f ff fa de call 2004ea0 <rtems_fdisk_info>
200632c: 92 12 63 00 or %o1, 0x300, %o1 ! 2030f00 <__FUNCTION__.6925+0xbf0>
#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,
2006330: c2 06 a0 04 ld [ %i2 + 4 ], %g1
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);
2006334: e6 07 60 14 ld [ %i5 + 0x14 ], %l3
#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,
2006338: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
200633c: e4 07 20 08 ld [ %i4 + 8 ], %l2
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
2006340: 90 02 00 01 add %o0, %g1, %o0
2006344: 7f ff f0 60 call 20024c4 <.umul>
2006348: 92 10 00 13 mov %l3, %o1
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;
200634c: 89 2c a0 04 sll %l2, 4, %g4
2006350: 83 2c a0 02 sll %l2, 2, %g1
2006354: 82 21 00 01 sub %g4, %g1, %g1
2006358: c8 07 60 28 ld [ %i5 + 0x28 ], %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,
200635c: f2 07 20 0c ld [ %i4 + 0xc ], %i1
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;
2006360: 9e 01 00 01 add %g4, %g1, %o7
2006364: c8 01 00 01 ld [ %g4 + %g1 ], %g4
2006368: 9b 2e 60 06 sll %i1, 6, %o5
200636c: 83 2e 60 04 sll %i1, 4, %g1
2006370: 82 23 40 01 sub %o5, %g1, %g1
2006374: 82 01 00 01 add %g4, %g1, %g1
2006378: c8 00 60 04 ld [ %g1 + 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;
200637c: c2 03 e0 08 ld [ %o7 + 8 ], %g1
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
2006380: 84 10 00 08 mov %o0, %g2
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;
2006384: e8 00 60 08 ld [ %g1 + 8 ], %l4
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
2006388: 96 10 00 19 mov %i1, %o3
200638c: 98 10 00 02 mov %g2, %o4
2006390: 94 10 00 12 mov %l2, %o2
2006394: 9a 10 00 13 mov %l3, %o5
2006398: c4 27 bf d0 st %g2, [ %fp + -48 ]
200639c: c8 27 bf cc st %g4, [ %fp + -52 ]
20063a0: 90 10 00 1d mov %i5, %o0
20063a4: 13 00 80 c3 sethi %hi(0x2030c00), %o1
20063a8: 7f ff fa de call 2004f20 <rtems_fdisk_printf>
20063ac: 92 12 63 28 or %o1, 0x328, %o1 ! 2030f28 <__FUNCTION__.6925+0xc18>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
20063b0: c4 1f bf d0 ldd [ %fp + -48 ], %g2
20063b4: c2 05 20 0c ld [ %l4 + 0xc ], %g1
20063b8: c8 07 bf cc ld [ %fp + -52 ], %g4
20063bc: 94 10 00 19 mov %i1, %o2
20063c0: c6 27 bf d4 st %g3, [ %fp + -44 ]
20063c4: 90 10 00 04 mov %g4, %o0
20063c8: 92 10 00 12 mov %l2, %o1
20063cc: 96 10 00 02 mov %g2, %o3
20063d0: 98 10 00 18 mov %i0, %o4
20063d4: 9f c0 40 00 call %g1
20063d8: 9a 10 00 13 mov %l3, %o5
#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,
20063dc: c6 07 bf d4 ld [ %fp + -44 ], %g3
20063e0: 80 a2 20 00 cmp %o0, 0
20063e4: 12 80 00 0c bne 2006414 <rtems_fdisk_ioctl+0x5c0>
20063e8: f2 06 a0 04 ld [ %i2 + 4 ], %i1
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
20063ec: d6 07 20 08 ld [ %i4 + 8 ], %o3
20063f0: d8 07 20 0c ld [ %i4 + 0xc ], %o4
20063f4: 90 10 00 1d mov %i5, %o0
20063f8: 13 00 80 c3 sethi %hi(0x2030c00), %o1
20063fc: 94 10 00 1b mov %i3, %o2
2006400: 92 12 63 50 or %o1, 0x350, %o1
2006404: 7f ff fa a7 call 2004ea0 <rtems_fdisk_info>
2006408: 9a 10 00 19 mov %i1, %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)
200640c: 10 80 01 0d b 2006840 <rtems_fdisk_ioctl+0x9ec>
2006410: 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];
2006414: c2 07 bf e0 ld [ %fp + -32 ], %g1
2006418: 87 28 e0 03 sll %g3, 3, %g3
200641c: a4 00 40 03 add %g1, %g3, %l2
* 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;
2006420: c2 14 a0 02 lduh [ %l2 + 2 ], %g1
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)) +
2006424: a7 2e 60 03 sll %i1, 3, %l3
* 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;
2006428: 82 08 7f fd and %g1, -3, %g1
200642c: c2 34 a0 02 sth %g1, [ %l2 + 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))
2006430: c2 07 60 08 ld [ %i5 + 8 ], %g1
2006434: 80 88 60 08 btst 8, %g1
2006438: 02 80 00 1c be 20064a8 <rtems_fdisk_ioctl+0x654> <== NEVER TAKEN
200643c: a6 04 e0 02 add %l3, 2, %l3
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
2006440: 90 10 00 1d mov %i5, %o0
2006444: 92 10 00 1c mov %i4, %o1
2006448: 94 10 00 13 mov %l3, %o2
200644c: 96 07 bf fe add %fp, -2, %o3
2006450: 7f ff fa d4 call 2004fa0 <rtems_fdisk_seg_read>
2006454: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
2006458: a8 92 20 00 orcc %o0, 0, %l4
200645c: 12 80 00 1c bne 20064cc <rtems_fdisk_ioctl+0x678> <== NEVER TAKEN
2006460: d8 17 bf fe lduh [ %fp + -2 ], %o4
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
2006464: c2 14 a0 02 lduh [ %l2 + 2 ], %g1
2006468: 84 08 40 0c and %g1, %o4, %g2
200646c: 83 28 60 10 sll %g1, 0x10, %g1
2006470: 85 28 a0 10 sll %g2, 0x10, %g2
2006474: 80 a0 80 01 cmp %g2, %g1
2006478: 02 80 00 0c be 20064a8 <rtems_fdisk_ioctl+0x654> <== ALWAYS TAKEN
200647c: 9b 30 60 10 srl %g1, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
2006480: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
2006484: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
2006488: 99 2b 20 10 sll %o4, 0x10, %o4 <== NOT EXECUTED
200648c: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2006490: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2006494: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
2006498: 7f ff fb 78 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
200649c: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
20064a0: 10 80 00 1b b 200650c <rtems_fdisk_ioctl+0x6b8> <== NOT EXECUTED
20064a4: 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,
20064a8: 90 10 00 1d mov %i5, %o0
20064ac: 92 10 00 1c mov %i4, %o1
20064b0: 94 10 00 13 mov %l3, %o2
20064b4: 96 04 a0 02 add %l2, 2, %o3
20064b8: 7f ff fa fd call 20050ac <rtems_fdisk_seg_write>
20064bc: 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)
20064c0: a8 92 20 00 orcc %o0, 0, %l4
20064c4: 22 80 00 12 be,a 200650c <rtems_fdisk_ioctl+0x6b8> <== ALWAYS TAKEN
20064c8: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
20064cc: e6 07 20 08 ld [ %i4 + 8 ], %l3 <== NOT EXECUTED
20064d0: e4 07 20 0c ld [ %i4 + 0xc ], %l2 <== NOT EXECUTED
20064d4: f2 06 a0 04 ld [ %i2 + 4 ], %i1 <== NOT EXECUTED
20064d8: 40 00 72 20 call 2022d58 <strerror> <== NOT EXECUTED
20064dc: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
20064e0: 13 00 80 c3 sethi %hi(0x2030c00), %o1 <== NOT EXECUTED
20064e4: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
20064e8: e8 23 a0 5c st %l4, [ %sp + 0x5c ] <== NOT EXECUTED
20064ec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20064f0: 92 12 63 d0 or %o1, 0x3d0, %o1 <== NOT EXECUTED
20064f4: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
20064f8: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
20064fc: 7f ff fa 69 call 2004ea0 <rtems_fdisk_info> <== NOT EXECUTED
2006500: 98 10 00 19 mov %i1, %o4 <== 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);
2006504: 10 80 00 08 b 2006524 <rtems_fdisk_ioctl+0x6d0> <== NOT EXECUTED
2006508: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
200650c: 82 00 7f ff add %g1, -1, %g1
2006510: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
sc->pages_used++;
2006514: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
2006518: 82 00 60 01 inc %g1
200651c: 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);
2006520: 90 10 00 1d mov %i5, %o0
2006524: 7f ff fb b9 call 2005408 <rtems_fdisk_queue_segment>
2006528: 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)
200652c: c2 07 60 08 ld [ %i5 + 8 ], %g1
2006530: 80 88 60 02 btst 2, %g1
2006534: 32 80 00 05 bne,a 2006548 <rtems_fdisk_ioctl+0x6f4> <== NEVER TAKEN
2006538: c4 07 60 30 ld [ %i5 + 0x30 ], %g2 <== NOT EXECUTED
rtems_fdisk_compact (fd);
200653c: 7f ff fc f0 call 20058fc <rtems_fdisk_compact>
2006540: 90 10 00 1d mov %i5, %o0
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006544: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
uint32_t count = 0;
2006548: 10 80 00 03 b 2006554 <rtems_fdisk_ioctl+0x700>
200654c: 82 10 20 00 clr %g1
while (sc)
{
count++;
2006550: 82 00 60 01 inc %g1
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006554: 80 a0 a0 00 cmp %g2, 0
2006558: 32 bf ff fe bne,a 2006550 <rtems_fdisk_ioctl+0x6fc>
200655c: c4 00 80 00 ld [ %g2 ], %g2
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
2006560: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
2006564: 80 a0 40 02 cmp %g1, %g2
2006568: 18 80 00 04 bgu 2006578 <rtems_fdisk_ioctl+0x724> <== ALWAYS TAKEN
200656c: 01 00 00 00 nop
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
2006570: 7f ff fc e3 call 20058fc <rtems_fdisk_compact> <== NOT EXECUTED
2006574: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
2006578: 7f ff f9 a8 call 2004c18 <rtems_fdisk_segment_queue_pop_head>
200657c: d0 07 bf f0 ld [ %fp + -16 ], %o0
/*
* Is the flash disk full ?
*/
if (!sc)
2006580: b8 92 20 00 orcc %o0, 0, %i4
2006584: 32 80 00 14 bne,a 20065d4 <rtems_fdisk_ioctl+0x780> <== ALWAYS TAKEN
2006588: c2 07 60 68 ld [ %i5 + 0x68 ], %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))
200658c: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
2006590: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2006594: 02 80 00 04 be 20065a4 <rtems_fdisk_ioctl+0x750> <== NOT EXECUTED
2006598: 01 00 00 00 nop <== NOT EXECUTED
rtems_fdisk_compact (fd);
200659c: 7f ff fc d8 call 20058fc <rtems_fdisk_compact> <== NOT EXECUTED
20065a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* Try again for some free space.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
20065a4: 7f ff f9 9d call 2004c18 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
20065a8: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
if (!sc)
20065ac: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20065b0: 32 80 00 09 bne,a 20065d4 <rtems_fdisk_ioctl+0x780> <== NOT EXECUTED
20065b4: c2 07 60 68 ld [ %i5 + 0x68 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: no available pages");
20065b8: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
20065bc: b4 10 00 17 mov %l7, %i2 <== NOT EXECUTED
20065c0: 90 12 20 10 or %o0, 0x10, %o0 <== NOT EXECUTED
20065c4: 7f ff fb 2d call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20065c8: b6 10 20 1c mov 0x1c, %i3 <== 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++)
20065cc: 10 80 00 a6 b 2006864 <rtems_fdisk_ioctl+0xa10> <== NOT EXECUTED
20065d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
20065d4: 80 a0 60 02 cmp %g1, 2
20065d8: 28 80 00 0f bleu,a 2006614 <rtems_fdisk_ioctl+0x7c0> <== ALWAYS TAKEN
20065dc: f2 07 20 10 ld [ %i4 + 0x10 ], %i1
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
20065e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20065e4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20065e8: 7f ff f9 e0 call 2004d68 <rtems_fdisk_queue_status> <== NOT EXECUTED
20065ec: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
20065f0: d6 07 20 08 ld [ %i4 + 8 ], %o3 <== NOT EXECUTED
20065f4: d8 07 20 0c ld [ %i4 + 0xc ], %o4 <== NOT EXECUTED
20065f8: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
20065fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006600: 92 12 60 30 or %o1, 0x30, %o1 <== NOT EXECUTED
2006604: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2006608: 7f ff fa 26 call 2004ea0 <rtems_fdisk_info> <== NOT EXECUTED
200660c: 9a 07 bf f8 add %fp, -8, %o5 <== NOT EXECUTED
/*
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
2006610: f2 07 20 10 ld [ %i4 + 0x10 ], %i1 <== NOT EXECUTED
for (page = 0; page < sc->pages; page++, pd++)
2006614: 10 80 00 78 b 20067f4 <rtems_fdisk_ioctl+0x9a0>
2006618: a4 10 20 00 clr %l2
{
if (rtems_fdisk_page_desc_erased (pd))
200661c: 7f ff f9 fd call 2004e10 <rtems_fdisk_page_desc_erased>
2006620: 90 10 00 19 mov %i1, %o0
2006624: 80 8a 20 ff btst 0xff, %o0
2006628: 22 80 00 72 be,a 20067f0 <rtems_fdisk_ioctl+0x99c>
200662c: a4 04 a0 01 inc %l2
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006630: 03 00 81 18 sethi %hi(0x2046000), %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);
2006634: 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);
2006638: c6 00 61 a8 ld [ %g1 + 0x1a8 ], %g3
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++)
200663c: 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;
2006640: 10 80 00 07 b 200665c <rtems_fdisk_ioctl+0x808>
2006644: 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);
2006648: 82 08 60 ff and %g1, 0xff, %g1
200664c: 82 18 40 0f xor %g1, %o7, %g1
2006650: 83 28 60 01 sll %g1, 1, %g1
2006654: c2 10 c0 01 lduh [ %g3 + %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++)
2006658: 84 00 a0 01 inc %g2
200665c: 80 a0 80 04 cmp %g2, %g4
2006660: 32 bf ff fa bne,a 2006648 <rtems_fdisk_ioctl+0x7f4>
2006664: de 0e 00 02 ldub [ %i0 + %g2 ], %o7
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);
2006668: c2 36 40 00 sth %g1, [ %i1 ]
pd->block = block;
200666c: f6 26 60 04 st %i3, [ %i1 + 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;
2006670: c4 16 60 02 lduh [ %i1 + 2 ], %g2
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
2006674: f8 25 40 16 st %i4, [ %l5 + %l6 ]
bc->page = page;
2006678: e4 26 a0 04 st %l2, [ %i2 + 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: " \
200667c: d4 07 00 00 ld [ %i4 ], %o2
* 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;
2006680: 84 08 bf fe and %g2, -2, %g2
2006684: c4 36 60 02 sth %g2, [ %i1 + 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: " \
2006688: 07 00 80 c2 sethi %hi(0x2030800), %g3
200668c: d6 07 20 08 ld [ %i4 + 8 ], %o3
2006690: d8 07 20 0c ld [ %i4 + 0xc ], %o4
2006694: da 07 20 1c ld [ %i4 + 0x1c ], %o5
2006698: de 07 20 20 ld [ %i4 + 0x20 ], %o7
200669c: c8 07 20 24 ld [ %i4 + 0x24 ], %g4
20066a0: 80 a2 a0 00 cmp %o2, 0
20066a4: 02 80 00 04 be 20066b4 <rtems_fdisk_ioctl+0x860> <== ALWAYS TAKEN
20066a8: 86 10 e1 60 or %g3, 0x160, %g3
20066ac: 07 00 80 c2 sethi %hi(0x2030800), %g3 <== NOT EXECUTED
20066b0: 86 10 e1 58 or %g3, 0x158, %g3 ! 2030958 <__FUNCTION__.6925+0x648><== NOT EXECUTED
20066b4: 85 28 a0 10 sll %g2, 0x10, %g2
20066b8: 83 28 60 10 sll %g1, 0x10, %g1
20066bc: 85 30 a0 10 srl %g2, 0x10, %g2
20066c0: 83 30 60 10 srl %g1, 0x10, %g1
20066c4: 94 10 00 1b mov %i3, %o2
20066c8: da 23 a0 60 st %o5, [ %sp + 0x60 ]
20066cc: de 23 a0 64 st %o7, [ %sp + 0x64 ]
20066d0: c8 23 a0 68 st %g4, [ %sp + 0x68 ]
20066d4: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
20066d8: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
20066dc: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
20066e0: f6 23 a0 78 st %i3, [ %sp + 0x78 ]
20066e4: 9a 10 00 12 mov %l2, %o5
20066e8: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
20066ec: 90 10 00 1d mov %i5, %o0
20066f0: 13 00 80 c4 sethi %hi(0x2031000), %o1
20066f4: 7f ff f9 eb call 2004ea0 <rtems_fdisk_info>
20066f8: 92 12 60 58 or %o1, 0x58, %o1 ! 2031058 <__FUNCTION__.6925+0xd48>
/*
* 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);
20066fc: d4 07 20 18 ld [ %i4 + 0x18 ], %o2
2006700: 90 10 00 1d mov %i5, %o0
2006704: 92 10 00 1c mov %i4, %o1
2006708: 94 04 80 0a add %l2, %o2, %o2
200670c: 7f ff fa 9f call 2005188 <rtems_fdisk_seg_write_page>
2006710: 96 10 00 18 mov %i0, %o3
if (ret)
2006714: b6 92 20 00 orcc %o0, 0, %i3
2006718: 22 80 00 0e be,a 2006750 <rtems_fdisk_ioctl+0x8fc> <== ALWAYS TAKEN
200671c: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
2006720: f2 07 20 08 ld [ %i4 + 8 ], %i1 <== NOT EXECUTED
2006724: 40 00 71 8d call 2022d58 <strerror> <== NOT EXECUTED
2006728: f4 07 20 0c ld [ %i4 + 0xc ], %i2 <== NOT EXECUTED
200672c: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
2006730: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
2006734: f6 23 a0 5c st %i3, [ %sp + 0x5c ] <== NOT EXECUTED
2006738: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200673c: 92 12 60 a8 or %o1, 0xa8, %o1 <== NOT EXECUTED
2006740: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2006744: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
2006748: 10 80 00 15 b 200679c <rtems_fdisk_ioctl+0x948> <== NOT EXECUTED
200674c: 98 10 00 12 mov %l2, %o4 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
2006750: 92 10 00 1c mov %i4, %o1
2006754: 94 10 00 12 mov %l2, %o2
2006758: 7f ff fa 7b call 2005144 <rtems_fdisk_seg_write_page_desc>
200675c: 96 10 00 19 mov %i1, %o3
if (ret)
2006760: b6 92 20 00 orcc %o0, 0, %i3
2006764: 22 80 00 12 be,a 20067ac <rtems_fdisk_ioctl+0x958> <== ALWAYS TAKEN
2006768: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
200676c: e4 07 20 08 ld [ %i4 + 8 ], %l2 <== NOT EXECUTED
2006770: f2 07 20 0c ld [ %i4 + 0xc ], %i1 <== NOT EXECUTED
2006774: 40 00 71 79 call 2022d58 <strerror> <== NOT EXECUTED
2006778: f4 06 a0 04 ld [ %i2 + 4 ], %i2 <== NOT EXECUTED
200677c: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
2006780: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
2006784: f6 23 a0 5c st %i3, [ %sp + 0x5c ] <== NOT EXECUTED
2006788: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200678c: 92 12 60 e0 or %o1, 0xe0, %o1 <== NOT EXECUTED
2006790: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2006794: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2006798: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
200679c: 7f ff f9 c1 call 2004ea0 <rtems_fdisk_info> <== NOT EXECUTED
20067a0: 01 00 00 00 nop <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
20067a4: 10 80 00 05 b 20067b8 <rtems_fdisk_ioctl+0x964> <== NOT EXECUTED
20067a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
20067ac: 82 00 60 01 inc %g1
20067b0: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
}
}
rtems_fdisk_queue_segment (fd, sc);
20067b4: 90 10 00 1d mov %i5, %o0
20067b8: 7f ff fb 14 call 2005408 <rtems_fdisk_queue_segment>
20067bc: 92 10 00 1c mov %i4, %o1
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->unavail_blocks;
if (starvation)
20067c0: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
20067c4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
20067c8: 80 a0 80 01 cmp %g2, %g1
20067cc: 3a 80 00 1a bcc,a 2006834 <rtems_fdisk_ioctl+0x9e0>
20067d0: 80 a6 e0 00 cmp %i3, 0
fd->starvations++;
20067d4: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
20067d8: 90 10 00 1d mov %i5, %o0
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->unavail_blocks;
if (starvation)
fd->starvations++;
20067dc: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
20067e0: 7f ff fc 47 call 20058fc <rtems_fdisk_compact>
20067e4: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
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)
20067e8: 10 80 00 13 b 2006834 <rtems_fdisk_ioctl+0x9e0>
20067ec: 80 a6 e0 00 cmp %i3, 0
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
20067f0: b2 06 60 08 add %i1, 8, %i1
20067f4: e6 07 20 14 ld [ %i4 + 0x14 ], %l3
20067f8: 80 a4 80 13 cmp %l2, %l3
20067fc: 0a bf ff 88 bcs 200661c <rtems_fdisk_ioctl+0x7c8> <== ALWAYS TAKEN
2006800: 11 00 80 c4 sethi %hi(0x2031000), %o0
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
2006804: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
2006808: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
200680c: 7f ff fa 9b call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2006810: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
2006814: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2006818: b4 10 00 17 mov %l7, %i2 <== NOT EXECUTED
200681c: c2 27 20 28 st %g1, [ %i4 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
2006820: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006824: 7f ff fa f9 call 2005408 <rtems_fdisk_queue_segment> <== NOT EXECUTED
2006828: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
return EIO;
200682c: 10 80 00 0d b 2006860 <rtems_fdisk_ioctl+0xa0c> <== NOT EXECUTED
2006830: b6 10 20 05 mov 5, %i3 <== 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)
2006834: 12 80 00 0b bne 2006860 <rtems_fdisk_ioctl+0xa0c> <== NEVER TAKEN
2006838: b4 10 00 17 mov %l7, %i2
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)
200683c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2006840: a2 04 60 01 inc %l1
2006844: b0 06 00 01 add %i0, %g1, %i0
2006848: c4 07 bf e4 ld [ %fp + -28 ], %g2
200684c: 80 a4 40 02 cmp %l1, %g2
2006850: 32 bf fe 95 bne,a 20062a4 <rtems_fdisk_ioctl+0x450>
2006854: f6 04 00 00 ld [ %l0 ], %i3
2006858: b4 10 00 17 mov %l7, %i2
200685c: b6 10 20 00 clr %i3
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2006860: c2 07 bf f4 ld [ %fp + -12 ], %g1
2006864: a0 04 20 10 add %l0, 0x10, %l0
2006868: 82 00 60 01 inc %g1
200686c: 80 a6 e0 00 cmp %i3, 0
2006870: 12 80 00 0a bne 2006898 <rtems_fdisk_ioctl+0xa44> <== NEVER TAKEN
2006874: c2 27 bf f4 st %g1, [ %fp + -12 ]
2006878: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
200687c: c4 07 bf f4 ld [ %fp + -12 ], %g2
2006880: 80 a0 80 01 cmp %g2, %g1
2006884: 2a bf fe 81 bcs,a 2006288 <rtems_fdisk_ioctl+0x434>
2006888: d0 04 20 04 ld [ %l0 + 4 ], %o0
200688c: f6 07 bf ec ld [ %fp + -20 ], %i3
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
2006890: 10 80 00 04 b 20068a0 <rtems_fdisk_ioctl+0xa4c>
2006894: 92 10 20 00 clr %o1
2006898: f6 07 bf ec ld [ %fp + -20 ], %i3 <== NOT EXECUTED
200689c: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
20068a0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
20068a4: d0 06 a0 08 ld [ %i2 + 8 ], %o0
20068a8: 9f c0 40 00 call %g1
20068ac: 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);
20068b0: c2 07 bf e8 ld [ %fp + -24 ], %g1
break;
20068b4: 10 80 01 d7 b 2007010 <rtems_fdisk_ioctl+0x11bc>
20068b8: c0 20 40 00 clr [ %g1 ]
default:
errno = EINVAL;
20068bc: 40 00 67 2b call 2020568 <__errno> <== NOT EXECUTED
20068c0: 01 00 00 00 nop <== NOT EXECUTED
20068c4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
break;
20068c8: 10 80 01 d2 b 2007010 <rtems_fdisk_ioctl+0x11bc> <== NOT EXECUTED
20068cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
20068d0: 40 00 67 26 call 2020568 <__errno> <== NOT EXECUTED
20068d4: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED
20068d8: fa 07 61 ac ld [ %i5 + 0x1ac ], %i5 <== NOT EXECUTED
20068dc: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
20068e0: 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");
20068e4: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
20068e8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20068ec: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
20068f0: 7f ff f9 6c call 2004ea0 <rtems_fdisk_info> <== NOT EXECUTED
20068f4: 31 00 80 c4 sethi %hi(0x2031000), %i0 <== NOT EXECUTED
20068f8: 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++)
20068fc: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
2006900: a0 14 21 68 or %l0, 0x168, %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);
2006904: 10 80 00 17 b 2006960 <rtems_fdisk_ioctl+0xb0c> <== NOT EXECUTED
2006908: b0 16 21 80 or %i0, 0x180, %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);
200690c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2006910: 7f ff f9 64 call 2004ea0 <rtems_fdisk_info> <== NOT EXECUTED
2006914: 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;
2006918: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
200691c: 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;
2006920: 82 00 40 1a add %g1, %i2, %g1 <== NOT EXECUTED
2006924: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006928: 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;
200692c: e2 00 60 08 ld [ %g1 + 8 ], %l1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006930: 7f ff f9 7c call 2004f20 <rtems_fdisk_printf> <== NOT EXECUTED
2006934: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
2006938: c4 07 60 28 ld [ %i5 + 0x28 ], %g2 <== NOT EXECUTED
200693c: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 <== NOT EXECUTED
2006940: 84 00 80 1a add %g2, %i2, %g2 <== NOT EXECUTED
2006944: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
2006948: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
200694c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006950: 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)
2006954: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2006958: 12 80 00 18 bne 20069b8 <rtems_fdisk_ioctl+0xb64> <== NOT EXECUTED
200695c: 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++)
2006960: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
2006964: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2006968: 0a bf ff e9 bcs 200690c <rtems_fdisk_ioctl+0xab8> <== NOT EXECUTED
200696c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2006970: b4 10 20 00 clr %i2 <== NOT EXECUTED
2006974: 10 80 00 0d b 20069a8 <rtems_fdisk_ioctl+0xb54> <== NOT EXECUTED
2006978: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
200697c: c2 00 40 1a ld [ %g1 + %i2 ], %g1 <== NOT EXECUTED
2006980: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006984: 02 80 00 0d be 20069b8 <rtems_fdisk_ioctl+0xb64> <== NOT EXECUTED
2006988: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
200698c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006990: 7f ff fc 5e call 2005b08 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
2006994: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
if (ret)
2006998: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200699c: 12 80 00 07 bne 20069b8 <rtems_fdisk_ioctl+0xb64> <== NOT EXECUTED
20069a0: 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++)
20069a4: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
20069a8: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
20069ac: 2a bf ff f4 bcs,a 200697c <rtems_fdisk_ioctl+0xb28> <== NOT EXECUTED
20069b0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
20069b4: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
break;
20069b8: 10 80 01 96 b 2007010 <rtems_fdisk_ioctl+0x11bc> <== NOT EXECUTED
20069bc: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
20069c0: 40 00 66 ea call 2020568 <__errno> <== NOT EXECUTED
20069c4: 01 00 00 00 nop <== NOT EXECUTED
20069c8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
20069cc: d0 07 61 ac ld [ %i5 + 0x1ac ], %o0 <== NOT EXECUTED
20069d0: 7f ff fb cb call 20058fc <rtems_fdisk_compact> <== NOT EXECUTED
20069d4: 90 02 00 1b add %o0, %i3, %o0 <== NOT EXECUTED
break;
20069d8: 10 80 01 8e b 2007010 <rtems_fdisk_ioctl+0x11bc> <== NOT EXECUTED
20069dc: d0 27 00 00 st %o0, [ %i4 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
20069e0: 40 00 66 e2 call 2020568 <__errno> <== NOT EXECUTED
20069e4: 01 00 00 00 nop <== NOT EXECUTED
20069e8: f8 07 61 ac ld [ %i5 + 0x1ac ], %i4 <== NOT EXECUTED
20069ec: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
20069f0: 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;
20069f4: ba 10 20 00 clr %i5 <== NOT EXECUTED
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
20069f8: 10 80 00 09 b 2006a1c <rtems_fdisk_ioctl+0xbc8> <== NOT EXECUTED
20069fc: b2 07 20 48 add %i4, 0x48, %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);
2006a00: 7f ff fa 3b call 20052ec <rtems_fdisk_erase_segment> <== NOT EXECUTED
2006a04: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret && !latched_ret)
2006a08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2006a0c: 02 80 00 04 be 2006a1c <rtems_fdisk_ioctl+0xbc8> <== NOT EXECUTED
2006a10: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2006a14: 22 80 00 02 be,a 2006a1c <rtems_fdisk_ioctl+0xbc8> <== NOT EXECUTED
2006a18: 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)))
2006a1c: 7f ff f8 7f call 2004c18 <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
2006a20: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2006a24: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
2006a28: 12 bf ff f6 bne 2006a00 <rtems_fdisk_ioctl+0xbac> <== NOT EXECUTED
2006a2c: 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;
2006a30: 10 80 01 78 b 2007010 <rtems_fdisk_ioctl+0x11bc> <== NOT EXECUTED
2006a34: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
2006a38: 40 00 66 cc call 2020568 <__errno> <== NOT EXECUTED
2006a3c: 01 00 00 00 nop <== NOT EXECUTED
2006a40: c2 07 61 ac ld [ %i5 + 0x1ac ], %g1 <== NOT EXECUTED
2006a44: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
2006a48: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
data->block_count = fd->block_count;
2006a4c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
2006a50: f2 00 60 2c ld [ %g1 + 0x2c ], %i1 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
2006a54: c4 26 80 00 st %g2, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
2006a58: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
2006a5c: c6 26 a0 04 st %g3, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
2006a60: c4 26 a0 08 st %g2, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
2006a64: f2 26 a0 0c st %i1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
2006a68: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
2006a6c: 10 80 00 0a b 2006a94 <rtems_fdisk_ioctl+0xc40> <== NOT EXECUTED
2006a70: 84 10 20 00 clr %g2 <== NOT EXECUTED
if (fd->blocks[i].segment)
2006a74: 89 28 a0 03 sll %g2, 3, %g4 <== NOT EXECUTED
2006a78: c8 07 40 04 ld [ %i5 + %g4 ], %g4 <== NOT EXECUTED
2006a7c: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
2006a80: 02 80 00 05 be 2006a94 <rtems_fdisk_ioctl+0xc40> <== NOT EXECUTED
2006a84: 84 00 a0 01 inc %g2 <== NOT EXECUTED
data->blocks_used++;
2006a88: c8 06 a0 18 ld [ %i2 + 0x18 ], %g4 <== NOT EXECUTED
2006a8c: 88 01 20 01 inc %g4 <== NOT EXECUTED
2006a90: c8 26 a0 18 st %g4, [ %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++)
2006a94: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
2006a98: 32 bf ff f7 bne,a 2006a74 <rtems_fdisk_ioctl+0xc20> <== NOT EXECUTED
2006a9c: fa 00 60 18 ld [ %g1 + 0x18 ], %i5 <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006aa0: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 <== NOT EXECUTED
uint32_t count = 0;
2006aa4: 10 80 00 03 b 2006ab0 <rtems_fdisk_ioctl+0xc5c> <== NOT EXECUTED
2006aa8: 84 10 20 00 clr %g2 <== NOT EXECUTED
while (sc)
{
count++;
2006aac: 84 00 a0 01 inc %g2 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006ab0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006ab4: 32 bf ff fe bne,a 2006aac <rtems_fdisk_ioctl+0xc58> <== NOT EXECUTED
2006ab8: c6 00 c0 00 ld [ %g3 ], %g3 <== NOT EXECUTED
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
2006abc: c4 26 a0 1c st %g2, [ %i2 + 0x1c ] <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006ac0: c6 00 60 3c ld [ %g1 + 0x3c ], %g3 <== NOT EXECUTED
uint32_t count = 0;
2006ac4: 10 80 00 03 b 2006ad0 <rtems_fdisk_ioctl+0xc7c> <== NOT EXECUTED
2006ac8: 84 10 20 00 clr %g2 <== NOT EXECUTED
while (sc)
{
count++;
2006acc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006ad0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006ad4: 32 bf ff fe bne,a 2006acc <rtems_fdisk_ioctl+0xc78> <== NOT EXECUTED
2006ad8: c6 00 c0 00 ld [ %g3 ], %g3 <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
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);
2006adc: c4 26 a0 20 st %g2, [ %i2 + 0x20 ] <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006ae0: c6 00 60 54 ld [ %g1 + 0x54 ], %g3 <== NOT EXECUTED
uint32_t count = 0;
2006ae4: 10 80 00 03 b 2006af0 <rtems_fdisk_ioctl+0xc9c> <== NOT EXECUTED
2006ae8: 84 10 20 00 clr %g2 <== NOT EXECUTED
while (sc)
{
count++;
2006aec: 84 00 a0 01 inc %g2 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006af0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006af4: 32 bf ff fe bne,a 2006aec <rtems_fdisk_ioctl+0xc98> <== NOT EXECUTED
2006af8: c6 00 c0 00 ld [ %g3 ], %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);
2006afc: c4 26 a0 24 st %g2, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
2006b00: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
2006b04: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
2006b08: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
2006b0c: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
2006b10: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
2006b14: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
2006b18: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
2006b1c: 10 80 00 2a b 2006bc4 <rtems_fdisk_ioctl+0xd70> <== NOT EXECUTED
2006b20: 88 10 20 00 clr %g4 <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
2006b24: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2 <== NOT EXECUTED
2006b28: 9e 03 c0 04 add %o7, %g4, %o7 <== NOT EXECUTED
2006b2c: f0 03 e0 04 ld [ %o7 + 4 ], %i0 <== NOT EXECUTED
2006b30: b8 10 20 00 clr %i4 <== NOT EXECUTED
2006b34: 84 00 80 18 add %g2, %i0, %g2 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
2006b38: ba 10 20 00 clr %i5 <== 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;
2006b3c: 10 80 00 1d b 2006bb0 <rtems_fdisk_ioctl+0xd5c> <== NOT EXECUTED
2006b40: c4 26 a0 10 st %g2, [ %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;
2006b44: 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];
2006b48: 84 00 80 1c add %g2, %i4, %g2 <== NOT EXECUTED
data->page_count += sc->pages;
2006b4c: da 00 a0 14 ld [ %g2 + 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++)
2006b50: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
2006b54: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
2006b58: 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;
2006b5c: da 26 a0 14 st %o5, [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
2006b60: da 00 a0 18 ld [ %g2 + 0x18 ], %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++)
2006b64: b8 07 20 30 add %i4, 0x30, %i4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
2006b68: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006b6c: 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;
2006b70: da 26 a0 2c st %o5, [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006b74: da 00 a0 1c ld [ %g2 + 0x1c ], %o5 <== NOT EXECUTED
2006b78: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006b7c: 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;
2006b80: da 26 a0 30 st %o5, [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006b84: da 00 a0 20 ld [ %g2 + 0x20 ], %o5 <== NOT EXECUTED
2006b88: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
2006b8c: 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;
2006b90: da 26 a0 34 st %o5, [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
2006b94: da 00 a0 24 ld [ %g2 + 0x24 ], %o5 <== NOT EXECUTED
data->seg_erases += sc->erased;
2006b98: c4 00 a0 2c ld [ %g2 + 0x2c ], %g2 <== 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;
2006b9c: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
2006ba0: da 26 a0 38 st %o5, [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases += sc->erased;
2006ba4: da 06 a0 28 ld [ %i2 + 0x28 ], %o5 <== NOT EXECUTED
2006ba8: 84 03 40 02 add %o5, %g2, %g2 <== NOT EXECUTED
2006bac: c4 26 a0 28 st %g2, [ %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++)
2006bb0: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2006bb4: 32 bf ff e4 bne,a 2006b44 <rtems_fdisk_ioctl+0xcf0> <== NOT EXECUTED
2006bb8: c4 03 c0 00 ld [ %o7 ], %g2 <== 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++)
2006bbc: 86 00 e0 01 inc %g3 <== NOT EXECUTED
2006bc0: 88 01 20 0c add %g4, 0xc, %g4 <== NOT EXECUTED
2006bc4: 80 a0 c0 19 cmp %g3, %i1 <== NOT EXECUTED
2006bc8: 32 bf ff d7 bne,a 2006b24 <rtems_fdisk_ioctl+0xcd0> <== NOT EXECUTED
2006bcc: de 00 60 28 ld [ %g1 + 0x28 ], %o7 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
2006bd0: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 <== NOT EXECUTED
2006bd4: 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;
2006bd8: 10 80 01 0e b 2007010 <rtems_fdisk_ioctl+0x11bc> <== NOT EXECUTED
2006bdc: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
2006be0: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
break;
2006be4: 10 80 01 0b b 2007010 <rtems_fdisk_ioctl+0x11bc> <== NOT EXECUTED
2006be8: f4 20 60 68 st %i2, [ %g1 + 0x68 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
2006bec: 40 00 66 5f call 2020568 <__errno>
2006bf0: b8 10 20 00 clr %i4
2006bf4: c2 07 61 ac ld [ %i5 + 0x1ac ], %g1
2006bf8: d0 27 bf f4 st %o0, [ %fp + -12 ]
2006bfc: 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;
2006c00: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
2006c04: d4 00 40 1b ld [ %g1 + %i3 ], %o2
2006c08: 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;
2006c0c: c4 27 bf f0 st %g2, [ %fp + -16 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
2006c10: 84 10 20 03 mov 3, %g2
rtems_fdisk_printf (fd,
2006c14: 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;
2006c18: c4 27 60 68 st %g2, [ %i5 + 0x68 ]
rtems_fdisk_printf (fd,
2006c1c: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006c20: 7f ff f8 c0 call 2004f20 <rtems_fdisk_printf>
2006c24: 92 12 61 98 or %o1, 0x198, %o1 ! 2031198 <__FUNCTION__.6925+0xe88>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
2006c28: d4 07 60 1c ld [ %i5 + 0x1c ], %o2
2006c2c: 90 10 00 1d mov %i5, %o0
2006c30: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006c34: 7f ff f8 bb call 2004f20 <rtems_fdisk_printf>
2006c38: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 20311c0 <__FUNCTION__.6925+0xeb0>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
2006c3c: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
2006c40: 90 10 00 1d mov %i5, %o0
2006c44: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006c48: 7f ff f8 b6 call 2004f20 <rtems_fdisk_printf>
2006c4c: 92 12 61 d0 or %o1, 0x1d0, %o1 ! 20311d0 <__FUNCTION__.6925+0xec0>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
2006c50: d4 07 60 6c ld [ %i5 + 0x6c ], %o2
2006c54: 90 10 00 1d mov %i5, %o0
2006c58: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006c5c: 7f ff f8 b1 call 2004f20 <rtems_fdisk_printf>
2006c60: 92 12 61 e8 or %o1, 0x1e8, %o1 ! 20311e8 <__FUNCTION__.6925+0xed8>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006c64: 10 80 00 03 b 2006c70 <rtems_fdisk_ioctl+0xe1c>
2006c68: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
uint32_t count = 0;
while (sc)
{
count++;
2006c6c: b8 07 20 01 inc %i4
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006c70: 80 a0 60 00 cmp %g1, 0
2006c74: 32 bf ff fe bne,a 2006c6c <rtems_fdisk_ioctl+0xe18>
2006c78: c2 00 40 00 ld [ %g1 ], %g1
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, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
2006c7c: d6 07 60 38 ld [ %i5 + 0x38 ], %o3
2006c80: 94 10 00 1c mov %i4, %o2
2006c84: 90 10 00 1d mov %i5, %o0
2006c88: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006c8c: 7f ff f8 a5 call 2004f20 <rtems_fdisk_printf>
2006c90: 92 12 61 f8 or %o1, 0x1f8, %o1 ! 20311f8 <__FUNCTION__.6925+0xee8>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006c94: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
uint32_t count = 0;
2006c98: 10 80 00 03 b 2006ca4 <rtems_fdisk_ioctl+0xe50>
2006c9c: 94 10 20 00 clr %o2
while (sc)
{
count++;
2006ca0: 94 02 a0 01 inc %o2
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006ca4: 80 a0 60 00 cmp %g1, 0
2006ca8: 32 bf ff fe bne,a 2006ca0 <rtems_fdisk_ioctl+0xe4c>
2006cac: c2 00 40 00 ld [ %g1 ], %g1
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);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
2006cb0: d6 07 60 44 ld [ %i5 + 0x44 ], %o3
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);
total += count;
2006cb4: b8 02 80 1c add %o2, %i4, %i4
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
2006cb8: 90 10 00 1d mov %i5, %o0
2006cbc: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006cc0: 7f ff f8 98 call 2004f20 <rtems_fdisk_printf>
2006cc4: 92 12 62 18 or %o1, 0x218, %o1 ! 2031218 <__FUNCTION__.6925+0xf08>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006cc8: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
uint32_t count = 0;
2006ccc: 10 80 00 03 b 2006cd8 <rtems_fdisk_ioctl+0xe84>
2006cd0: 94 10 20 00 clr %o2
while (sc)
{
count++;
2006cd4: 94 02 a0 01 inc %o2 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006cd8: 80 a0 60 00 cmp %g1, 0
2006cdc: 32 bf ff fe bne,a 2006cd4 <rtems_fdisk_ioctl+0xe80> <== NEVER TAKEN
2006ce0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
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);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
2006ce4: d6 07 60 50 ld [ %i5 + 0x50 ], %o3
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);
total += count;
2006ce8: b8 07 00 0a add %i4, %o2, %i4
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
2006cec: 90 10 00 1d mov %i5, %o0
2006cf0: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006cf4: 7f ff f8 8b call 2004f20 <rtems_fdisk_printf>
2006cf8: 92 12 62 30 or %o1, 0x230, %o1 ! 2031230 <__FUNCTION__.6925+0xf20>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
2006cfc: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
uint32_t count = 0;
2006d00: 10 80 00 03 b 2006d0c <rtems_fdisk_ioctl+0xeb8>
2006d04: 94 10 20 00 clr %o2
while (sc)
{
count++;
2006d08: 94 02 a0 01 inc %o2 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
2006d0c: 80 a0 60 00 cmp %g1, 0
2006d10: 32 bf ff fe bne,a 2006d08 <rtems_fdisk_ioctl+0xeb4> <== NEVER TAKEN
2006d14: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
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);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
2006d18: d6 07 60 5c ld [ %i5 + 0x5c ], %o3
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);
total += count;
2006d1c: b8 07 00 0a add %i4, %o2, %i4
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
2006d20: 90 10 00 1d mov %i5, %o0
2006d24: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006d28: 7f ff f8 7e call 2004f20 <rtems_fdisk_printf>
2006d2c: 92 12 62 48 or %o1, 0x248, %o1 ! 2031248 <__FUNCTION__.6925+0xf38>
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
2006d30: c6 07 60 2c ld [ %i5 + 0x2c ], %g3
2006d34: 84 10 20 00 clr %g2
2006d38: 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;
2006d3c: 10 80 00 07 b 2006d58 <rtems_fdisk_ioctl+0xf04>
2006d40: 96 10 20 00 clr %o3
for (device = 0; device < fd->device_count; device++)
2006d44: 82 00 60 01 inc %g1
count += fd->devices[device].segment_count;
2006d48: 88 01 00 02 add %g4, %g2, %g4
2006d4c: c8 01 20 04 ld [ %g4 + 4 ], %g4
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++)
2006d50: 84 00 a0 0c add %g2, 0xc, %g2
count += fd->devices[device].segment_count;
2006d54: 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++)
2006d58: 80 a0 40 03 cmp %g1, %g3
2006d5c: 32 bf ff fa bne,a 2006d44 <rtems_fdisk_ioctl+0xef0>
2006d60: c8 07 60 28 ld [ %i5 + 0x28 ], %g4
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
2006d64: 19 00 80 c3 sethi %hi(0x2030c00), %o4
2006d68: 80 a7 00 0b cmp %i4, %o3
2006d6c: 12 80 00 04 bne 2006d7c <rtems_fdisk_ioctl+0xf28> <== NEVER TAKEN
2006d70: 98 13 21 40 or %o4, 0x140, %o4
2006d74: 19 00 80 c3 sethi %hi(0x2030c00), %o4
2006d78: 98 13 21 38 or %o4, 0x138, %o4 ! 2030d38 <__FUNCTION__.6925+0xa28>
2006d7c: 94 10 00 1c mov %i4, %o2
2006d80: 90 10 00 1d mov %i5, %o0
2006d84: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006d88: 7f ff f8 66 call 2004f20 <rtems_fdisk_printf>
2006d8c: 92 12 62 60 or %o1, 0x260, %o1 ! 2031260 <__FUNCTION__.6925+0xf50>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
2006d90: d4 07 60 2c ld [ %i5 + 0x2c ], %o2
2006d94: 90 10 00 1d mov %i5, %o0
2006d98: 13 00 80 c4 sethi %hi(0x2031000), %o1
for (device = 0; device < fd->device_count; device++)
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
2006d9c: 21 00 80 c4 sethi %hi(0x2031000), %l0
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);
2006da0: 92 12 62 80 or %o1, 0x280, %o1
2006da4: 7f ff f8 5f call 2004f20 <rtems_fdisk_printf>
2006da8: b8 10 20 00 clr %i4
for (device = 0; device < fd->device_count; device++)
2006dac: b4 10 20 00 clr %i2
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
2006db0: 10 80 00 78 b 2006f90 <rtems_fdisk_ioctl+0x113c>
2006db4: a0 14 22 90 or %l0, 0x290, %l0
2006db8: 94 10 00 1a mov %i2, %o2
2006dbc: 7f ff f8 59 call 2004f20 <rtems_fdisk_printf>
2006dc0: 90 10 00 1d mov %i5, %o0
rtems_fdisk_printf (fd, " Segment count\t%ld",
2006dc4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006dc8: 90 10 00 1d mov %i5, %o0
2006dcc: 82 00 40 1c add %g1, %i4, %g1
2006dd0: d4 00 60 04 ld [ %g1 + 4 ], %o2
2006dd4: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006dd8: b0 10 20 00 clr %i0
2006ddc: 92 12 62 a0 or %o1, 0x2a0, %o1
2006de0: 7f ff f8 50 call 2004f20 <rtems_fdisk_printf>
2006de4: b2 10 20 00 clr %i1
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
2006de8: 10 80 00 63 b 2006f74 <rtems_fdisk_ioctl+0x1120>
2006dec: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006df0: 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];
2006df4: a2 04 40 18 add %l1, %i0, %l1
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006df8: 94 07 bf f8 add %fp, -8, %o2
2006dfc: 92 10 00 11 mov %l1, %o1
2006e00: 7f ff f7 da call 2004d68 <rtems_fdisk_queue_status>
2006e04: ae 10 20 00 clr %l7
{
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;
2006e08: aa 10 20 00 clr %l5
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;
2006e0c: ac 10 20 00 clr %l6
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;
2006e10: a8 10 20 00 clr %l4
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006e14: 10 80 00 32 b 2006edc <rtems_fdisk_ioctl+0x1088>
2006e18: a4 10 20 00 clr %l2
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
2006e1c: 83 2c a0 03 sll %l2, 3, %g1
2006e20: a6 04 c0 01 add %l3, %g1, %l3
2006e24: 7f ff f7 fb call 2004e10 <rtems_fdisk_page_desc_erased>
2006e28: 90 10 00 13 mov %l3, %o0
2006e2c: 80 8a 20 ff btst 0xff, %o0
2006e30: 22 80 00 04 be,a 2006e40 <rtems_fdisk_ioctl+0xfec>
2006e34: c2 14 e0 02 lduh [ %l3 + 2 ], %g1
erased++;
2006e38: 10 80 00 0b b 2006e64 <rtems_fdisk_ioctl+0x1010>
2006e3c: a8 05 20 01 inc %l4
else if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006e40: 80 88 60 01 btst 1, %g1
2006e44: 12 80 00 09 bne 2006e68 <rtems_fdisk_ioctl+0x1014> <== NEVER TAKEN
2006e48: a6 10 20 00 clr %l3
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006e4c: 80 88 60 02 btst 2, %g1
2006e50: 32 80 00 04 bne,a 2006e60 <rtems_fdisk_ioctl+0x100c> <== ALWAYS TAKEN
2006e54: ac 05 a0 01 inc %l6
RTEMS_FDISK_PAGE_USED))
used++;
2006e58: 10 80 00 04 b 2006e68 <rtems_fdisk_ioctl+0x1014> <== NOT EXECUTED
2006e5c: aa 05 60 01 inc %l5 <== NOT EXECUTED
else
{
active++;
is_active = true;
2006e60: ae 10 20 01 mov 1, %l7
}
}
for (block = 0; block < fd->block_count; block++)
2006e64: a6 10 20 00 clr %l3
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
2006e68: 10 80 00 18 b 2006ec8 <rtems_fdisk_ioctl+0x1074>
2006e6c: 82 0d e0 ff and %l7, 0xff, %g1
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
2006e70: 85 2c e0 03 sll %l3, 3, %g2
2006e74: 88 00 c0 02 add %g3, %g2, %g4
2006e78: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2006e7c: 80 a0 80 11 cmp %g2, %l1
2006e80: 32 80 00 12 bne,a 2006ec8 <rtems_fdisk_ioctl+0x1074>
2006e84: a6 04 e0 01 inc %l3
2006e88: c4 01 20 04 ld [ %g4 + 4 ], %g2
2006e8c: 80 a0 80 12 cmp %g2, %l2
2006e90: 32 80 00 0e bne,a 2006ec8 <rtems_fdisk_ioctl+0x1074>
2006e94: a6 04 e0 01 inc %l3
(fd->blocks[block].page == page) && !is_active)
2006e98: 80 a0 60 00 cmp %g1, 0
2006e9c: 32 80 00 0b bne,a 2006ec8 <rtems_fdisk_ioctl+0x1074> <== ALWAYS TAKEN
2006ea0: a6 04 e0 01 inc %l3
rtems_fdisk_printf (fd,
2006ea4: c2 27 bf dc st %g1, [ %fp + -36 ] <== NOT EXECUTED
2006ea8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006eac: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
2006eb0: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2006eb4: 92 12 62 b8 or %o1, 0x2b8, %o1 <== NOT EXECUTED
2006eb8: 7f ff f8 1a call 2004f20 <rtems_fdisk_printf> <== NOT EXECUTED
2006ebc: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED
2006ec0: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
2006ec4: a6 04 e0 01 inc %l3 <== NOT EXECUTED
2006ec8: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
2006ecc: 80 a4 c0 02 cmp %l3, %g2
2006ed0: 2a bf ff e8 bcs,a 2006e70 <rtems_fdisk_ioctl+0x101c>
2006ed4: c6 07 60 18 ld [ %i5 + 0x18 ], %g3
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006ed8: a4 04 a0 01 inc %l2
2006edc: d8 04 60 14 ld [ %l1 + 0x14 ], %o4
2006ee0: 80 a4 80 0c cmp %l2, %o4
2006ee4: 2a bf ff ce bcs,a 2006e1c <rtems_fdisk_ioctl+0xfc8>
2006ee8: e6 04 60 10 ld [ %l1 + 0x10 ], %l3
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006eec: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
2006ef0: 82 10 20 00 clr %g1
2006ef4: 10 80 00 08 b 2006f14 <rtems_fdisk_ioctl+0x10c0>
2006ef8: 84 10 20 00 clr %g2
{
if (fd->blocks[block].segment == sc)
2006efc: 89 28 60 03 sll %g1, 3, %g4
2006f00: c8 03 c0 04 ld [ %o7 + %g4 ], %g4
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006f04: 82 00 60 01 inc %g1
{
if (fd->blocks[block].segment == sc)
count++;
2006f08: 88 19 00 11 xor %g4, %l1, %g4
2006f0c: 80 a0 00 04 cmp %g0, %g4
2006f10: 84 60 bf ff subx %g2, -1, %g2
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006f14: 80 a0 40 03 cmp %g1, %g3
2006f18: 32 bf ff f9 bne,a 2006efc <rtems_fdisk_ioctl+0x10a8>
2006f1c: de 07 60 18 ld [ %i5 + 0x18 ], %o7
" 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),
2006f20: c2 04 60 20 ld [ %l1 + 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 +
2006f24: da 04 60 1c ld [ %l1 + 0x1c ], %o5
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006f28: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
2006f2c: ec 23 a0 5c st %l6, [ %sp + 0x5c ]
2006f30: ea 23 a0 64 st %l5, [ %sp + 0x64 ]
2006f34: e8 23 a0 68 st %l4, [ %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)
2006f38: c6 04 60 24 ld [ %l1 + 0x24 ], %g3
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006f3c: 94 10 00 19 mov %i1, %o2
* @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)
2006f40: 82 00 40 03 add %g1, %g3, %g1
2006f44: 82 00 40 0d add %g1, %o5, %g1
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006f48: 82 23 00 01 sub %o4, %g1, %g1
2006f4c: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
2006f50: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2006f54: 90 10 00 1d mov %i5, %o0
2006f58: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006f5c: 96 07 bf f8 add %fp, -8, %o3
2006f60: 92 12 62 e8 or %o1, 0x2e8, %o1
2006f64: 7f ff f7 ef call 2004f20 <rtems_fdisk_printf>
2006f68: b2 06 60 01 inc %i1
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++)
2006f6c: b0 06 20 30 add %i0, 0x30, %i0
2006f70: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006f74: 84 00 40 1c add %g1, %i4, %g2
2006f78: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2006f7c: 80 a6 40 02 cmp %i1, %g2
2006f80: 2a bf ff 9c bcs,a 2006df0 <rtems_fdisk_ioctl+0xf9c>
2006f84: e2 00 40 1c ld [ %g1 + %i4 ], %l1
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++)
2006f88: b4 06 a0 01 inc %i2
2006f8c: b8 07 20 0c add %i4, 0xc, %i4
2006f90: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2006f94: 80 a6 80 01 cmp %i2, %g1
2006f98: 0a bf ff 88 bcs 2006db8 <rtems_fdisk_ioctl+0xf64>
2006f9c: 92 10 00 10 mov %l0, %o1
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
2006fa0: f8 07 60 3c ld [ %i5 + 0x3c ], %i4
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
2006fa4: 90 10 00 1d mov %i5, %o0
2006fa8: 13 00 80 c4 sethi %hi(0x2031000), %o1
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
2006fac: 33 00 80 c4 sethi %hi(0x2031000), %i1
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
2006fb0: 92 12 63 28 or %o1, 0x328, %o1
2006fb4: 7f ff f7 db call 2004f20 <rtems_fdisk_printf>
2006fb8: b4 10 20 00 clr %i2
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
2006fbc: 10 80 00 0a b 2006fe4 <rtems_fdisk_ioctl+0x1190>
2006fc0: b2 16 63 38 or %i1, 0x338, %i1
2006fc4: d8 07 20 0c ld [ %i4 + 0xc ], %o4
2006fc8: da 07 20 20 ld [ %i4 + 0x20 ], %o5
2006fcc: 94 10 00 1a mov %i2, %o2
2006fd0: 90 10 00 1d mov %i5, %o0
2006fd4: 7f ff f7 d3 call 2004f20 <rtems_fdisk_printf>
2006fd8: 92 10 00 19 mov %i1, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
2006fdc: f8 07 00 00 ld [ %i4 ], %i4
count++;
2006fe0: 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)
2006fe4: 80 a7 20 00 cmp %i4, 0
2006fe8: 32 bf ff f7 bne,a 2006fc4 <rtems_fdisk_ioctl+0x1170>
2006fec: 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;
2006ff0: c2 07 bf f0 ld [ %fp + -16 ], %g1
2006ff4: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
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]);
2006ff8: c4 07 bf f4 ld [ %fp + -12 ], %g2
break;
2006ffc: 10 80 00 05 b 2007010 <rtems_fdisk_ioctl+0x11bc>
2007000: c0 20 80 00 clr [ %g2 ]
default:
rtems_blkdev_ioctl (dd, req, argp);
2007004: 92 10 00 19 mov %i1, %o1
2007008: 40 00 3b 5c call 2015d78 <rtems_blkdev_ioctl>
200700c: 94 10 00 1a mov %i2, %o2
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
2007010: 03 00 81 18 sethi %hi(0x2046000), %g1
2007014: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 20461ac <rtems_flashdisks>
2007018: b6 00 40 1b add %g1, %i3, %i3
200701c: 40 00 17 7c call 200ce0c <rtems_semaphore_release>
2007020: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2007024: 80 a2 20 00 cmp %o0, 0
2007028: 02 80 00 06 be 2007040 <rtems_fdisk_ioctl+0x11ec> <== ALWAYS TAKEN
200702c: 01 00 00 00 nop
errno = EIO;
2007030: 40 00 65 4e call 2020568 <__errno> <== NOT EXECUTED
2007034: 01 00 00 00 nop <== NOT EXECUTED
2007038: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
200703c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
2007040: 40 00 65 4a call 2020568 <__errno>
2007044: 01 00 00 00 nop
2007048: c2 02 00 00 ld [ %o0 ], %g1
}
200704c: 80 a0 00 01 cmp %g0, %g1
2007050: b0 60 20 00 subx %g0, 0, %i0
2007054: 81 c7 e0 08 ret
2007058: 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)
200705c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2007060: a0 04 20 01 inc %l0
2007064: 10 bf fc 65 b 20061f8 <rtems_fdisk_ioctl+0x3a4>
2007068: b2 06 40 01 add %i1, %g1, %i1
02005408 <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)
{
2005408: 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",
200540c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
2005410: 05 00 80 c2 sethi %hi(0x2030800), %g2
* @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)
{
2005414: ba 10 00 18 mov %i0, %i5
2005418: 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",
200541c: d4 06 60 08 ld [ %i1 + 8 ], %o2
2005420: d6 06 60 0c ld [ %i1 + 0xc ], %o3
2005424: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
2005428: da 06 60 1c ld [ %i1 + 0x1c ], %o5
200542c: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
2005430: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
2005434: 80 a0 60 00 cmp %g1, 0
2005438: 02 80 00 04 be 2005448 <rtems_fdisk_queue_segment+0x40> <== ALWAYS TAKEN
200543c: 84 10 a1 50 or %g2, 0x150, %g2
2005440: 05 00 80 c2 sethi %hi(0x2030800), %g2 <== NOT EXECUTED
2005444: 84 10 a1 48 or %g2, 0x148, %g2 ! 2030948 <__FUNCTION__.6925+0x638><== NOT EXECUTED
2005448: f8 06 80 00 ld [ %i2 ], %i4
200544c: 03 00 80 c2 sethi %hi(0x2030800), %g1
2005450: 80 a7 20 00 cmp %i4, 0
2005454: 02 80 00 04 be 2005464 <rtems_fdisk_queue_segment+0x5c>
2005458: 82 10 61 60 or %g1, 0x160, %g1
200545c: 03 00 80 c2 sethi %hi(0x2030800), %g1
2005460: 82 10 61 58 or %g1, 0x158, %g1 ! 2030958 <__FUNCTION__.6925+0x648>
2005464: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
2005468: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
200546c: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
2005470: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
2005474: 90 10 00 1d mov %i5, %o0
2005478: 13 00 80 c2 sethi %hi(0x2030800), %o1
200547c: 7f ff fe 89 call 2004ea0 <rtems_fdisk_info>
2005480: 92 12 61 68 or %o1, 0x168, %o1 ! 2030968 <__FUNCTION__.6925+0x658>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
2005484: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
2005488: 80 a0 60 00 cmp %g1, 0
200548c: 22 80 00 0c be,a 20054bc <rtems_fdisk_queue_segment+0xb4><== ALWAYS TAKEN
2005490: 92 10 00 1a mov %i2, %o1
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
2005494: 10 80 00 05 b 20054a8 <rtems_fdisk_queue_segment+0xa0> <== NOT EXECUTED
2005498: c2 07 60 54 ld [ %i5 + 0x54 ], %g1 <== NOT EXECUTED
while (it)
{
if (it == sc)
200549c: 02 80 00 37 be 2005578 <rtems_fdisk_queue_segment+0x170> <== NOT EXECUTED
20054a0: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
20054a4: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
20054a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20054ac: 32 bf ff fc bne,a 200549c <rtems_fdisk_queue_segment+0x94><== NOT EXECUTED
20054b0: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
* if not failed.
*/
if (sc->failed)
{
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
20054b4: 10 80 00 2f b 2005570 <rtems_fdisk_queue_segment+0x168> <== NOT EXECUTED
20054b8: b0 07 60 54 add %i5, 0x54, %i0 <== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
20054bc: b8 07 60 30 add %i5, 0x30, %i4
20054c0: 7f ff fd f8 call 2004ca0 <rtems_fdisk_segment_queue_remove>
20054c4: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
20054c8: 92 10 00 1a mov %i2, %o1
20054cc: b0 07 60 3c add %i5, 0x3c, %i0
20054d0: 7f ff fd f4 call 2004ca0 <rtems_fdisk_segment_queue_remove>
20054d4: 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)
20054d8: 7f ff fe 58 call 2004e38 <rtems_fdisk_seg_pages_available>
20054dc: 90 10 00 1a mov %i2, %o0
20054e0: b6 92 20 00 orcc %o0, 0, %i3
20054e4: 32 80 00 1d bne,a 2005558 <rtems_fdisk_queue_segment+0x150>
20054e8: f2 07 60 30 ld [ %i5 + 0x30 ], %i1
{
if (sc->pages_active)
20054ec: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
20054f0: 80 a0 60 00 cmp %g1, 0
20054f4: 22 80 00 0d be,a 2005528 <rtems_fdisk_queue_segment+0x120><== NEVER TAKEN
20054f8: 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)
20054fc: 10 80 00 07 b 2005518 <rtems_fdisk_queue_segment+0x110>
2005500: f2 07 60 3c ld [ %i5 + 0x3c ], %i1
{
if (sc->pages_used > seg->pages_used)
2005504: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2005508: 80 a0 80 01 cmp %g2, %g1
200550c: 18 80 00 17 bgu 2005568 <rtems_fdisk_queue_segment+0x160>
2005510: 01 00 00 00 nop
break;
seg = seg->next;
2005514: 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)
2005518: 80 a6 60 00 cmp %i1, 0
200551c: 32 bf ff fa bne,a 2005504 <rtems_fdisk_queue_segment+0xfc>
2005520: c4 06 a0 20 ld [ %i2 + 0x20 ], %g2
2005524: 30 80 00 13 b,a 2005570 <rtems_fdisk_queue_segment+0x168>
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
2005528: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
200552c: 12 80 00 11 bne 2005570 <rtems_fdisk_queue_segment+0x168> <== NOT EXECUTED
2005530: b0 07 60 48 add %i5, 0x48, %i0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
2005534: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2005538: 7f ff ff 6d call 20052ec <rtems_fdisk_erase_segment> <== NOT EXECUTED
200553c: 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))
2005540: 7f ff fe 3e call 2004e38 <rtems_fdisk_seg_pages_available>
2005544: 90 10 00 19 mov %i1, %o0
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
2005548: 80 a6 c0 08 cmp %i3, %o0
200554c: 0a 80 00 07 bcs 2005568 <rtems_fdisk_queue_segment+0x160>
2005550: b0 10 00 1c mov %i4, %i0
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
2005554: 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)
2005558: 80 a6 60 00 cmp %i1, 0
200555c: 12 bf ff f9 bne 2005540 <rtems_fdisk_queue_segment+0x138>
2005560: b0 10 00 1c mov %i4, %i0
2005564: 30 80 00 03 b,a 2005570 <rtems_fdisk_queue_segment+0x168>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
2005568: 7f ff fd eb call 2004d14 <rtems_fdisk_segment_queue_insert_before>
200556c: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
2005570: 7f ff fd ba call 2004c58 <rtems_fdisk_segment_queue_push_tail>
2005574: 93 e8 00 1a restore %g0, %i2, %o1
2005578: 81 c7 e0 08 ret <== NOT EXECUTED
200557c: 81 e8 00 00 restore <== NOT EXECUTED
02004d68 <rtems_fdisk_queue_status>:
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
2004d68: 10 80 00 05 b 2004d7c <rtems_fdisk_queue_status+0x14>
2004d6c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
while (it)
{
if (it == sc)
2004d70: 22 80 00 07 be,a 2004d8c <rtems_fdisk_queue_status+0x24>
2004d74: 82 10 20 41 mov 0x41, %g1
return true;
it = it->next;
2004d78: c2 00 40 00 ld [ %g1 ], %g1
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004d7c: 80 a0 60 00 cmp %g1, 0
2004d80: 12 bf ff fc bne 2004d70 <rtems_fdisk_queue_status+0x8>
2004d84: 80 a0 40 09 cmp %g1, %o1
2004d88: 82 10 20 2d mov 0x2d, %g1
static void
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
2004d8c: c2 2a 80 00 stb %g1, [ %o2 ]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
2004d90: 10 80 00 05 b 2004da4 <rtems_fdisk_queue_status+0x3c>
2004d94: c2 02 20 3c ld [ %o0 + 0x3c ], %g1
while (it)
{
if (it == sc)
2004d98: 22 80 00 07 be,a 2004db4 <rtems_fdisk_queue_status+0x4c>
2004d9c: 82 10 20 55 mov 0x55, %g1
return true;
it = it->next;
2004da0: c2 00 40 00 ld [ %g1 ], %g1
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004da4: 80 a0 60 00 cmp %g1, 0
2004da8: 12 bf ff fc bne 2004d98 <rtems_fdisk_queue_status+0x30>
2004dac: 80 a0 40 09 cmp %g1, %o1
2004db0: 82 10 20 2d mov 0x2d, %g1
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
2004db4: c2 2a a0 01 stb %g1, [ %o2 + 1 ]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
2004db8: 10 80 00 05 b 2004dcc <rtems_fdisk_queue_status+0x64>
2004dbc: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
while (it)
{
if (it == sc)
2004dc0: 22 80 00 07 be,a 2004ddc <rtems_fdisk_queue_status+0x74> <== NOT EXECUTED
2004dc4: 82 10 20 45 mov 0x45, %g1 <== NOT EXECUTED
return true;
it = it->next;
2004dc8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004dcc: 80 a0 60 00 cmp %g1, 0
2004dd0: 12 bf ff fc bne 2004dc0 <rtems_fdisk_queue_status+0x58> <== NEVER TAKEN
2004dd4: 80 a0 40 09 cmp %g1, %o1
2004dd8: 82 10 20 2d mov 0x2d, %g1
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
2004ddc: c2 2a a0 02 stb %g1, [ %o2 + 2 ]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
2004de0: 10 80 00 05 b 2004df4 <rtems_fdisk_queue_status+0x8c>
2004de4: c2 02 20 54 ld [ %o0 + 0x54 ], %g1
while (it)
{
if (it == sc)
2004de8: 22 80 00 07 be,a 2004e04 <rtems_fdisk_queue_status+0x9c> <== NOT EXECUTED
2004dec: 82 10 20 46 mov 0x46, %g1 <== NOT EXECUTED
return true;
it = it->next;
2004df0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004df4: 80 a0 60 00 cmp %g1, 0
2004df8: 12 bf ff fc bne 2004de8 <rtems_fdisk_queue_status+0x80> <== NEVER TAKEN
2004dfc: 80 a0 40 09 cmp %g1, %o1
2004e00: 82 10 20 2d mov 0x2d, %g1
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc) ? 'F' : '-';
2004e04: c2 2a a0 03 stb %g1, [ %o2 + 3 ]
queues[4] = '\0';
}
2004e08: 81 c3 e0 08 retl
2004e0c: c0 2a a0 04 clrb [ %o2 + 4 ]
02005b08 <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
2005b08: 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));
2005b0c: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
2005b10: 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;
2005b14: c0 26 20 34 clr [ %i0 + 0x34 ]
2005b18: c0 26 20 30 clr [ %i0 + 0x30 ]
queue->count = 0;
2005b1c: c0 26 20 38 clr [ %i0 + 0x38 ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005b20: c0 26 20 40 clr [ %i0 + 0x40 ]
2005b24: c0 26 20 3c clr [ %i0 + 0x3c ]
queue->count = 0;
2005b28: c0 26 20 44 clr [ %i0 + 0x44 ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005b2c: c0 26 20 4c clr [ %i0 + 0x4c ]
2005b30: c0 26 20 48 clr [ %i0 + 0x48 ]
queue->count = 0;
2005b34: c0 26 20 50 clr [ %i0 + 0x50 ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005b38: c0 26 20 58 clr [ %i0 + 0x58 ]
2005b3c: c0 26 20 54 clr [ %i0 + 0x54 ]
queue->count = 0;
2005b40: c0 26 20 5c clr [ %i0 + 0x5c ]
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
2005b44: 92 10 20 00 clr %o1
2005b48: 95 2a a0 03 sll %o2, 3, %o2
2005b4c: 40 00 6f 73 call 2021918 <memset>
2005b50: 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,
2005b54: 27 00 80 c3 sethi %hi(0x2030c00), %l3
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005b58: 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",
2005b5c: 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)
{
2005b60: 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;
2005b64: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
2005b68: a2 10 20 00 clr %l1
2005b6c: a0 10 20 00 clr %l0
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);
2005b70: 2b 00 80 c3 sethi %hi(0x2030c00), %l5
* 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: " \
2005b74: a8 15 21 08 or %l4, 0x108, %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,
2005b78: a6 14 e0 d8 or %l3, 0xd8, %l3
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005b7c: ac 15 a0 90 or %l6, 0x90, %l6
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
for (device = 0; device < fd->device_count; device++)
2005b80: 10 80 00 af b 2005e3c <rtems_fdisk_recover_block_mappings+0x334>
2005b84: ae 15 e0 b0 or %l7, 0xb0, %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);
2005b88: 94 10 00 10 mov %l0, %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];
2005b8c: b8 07 00 12 add %i4, %l2, %i4
const rtems_fdisk_segment_desc* sd = sc->descriptor;
2005b90: 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);
2005b94: 96 10 00 19 mov %i1, %o3
2005b98: 92 15 60 00 mov %l5, %o1
2005b9c: 7f ff fc c1 call 2004ea0 <rtems_fdisk_info>
2005ba0: 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;
2005ba4: 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);
2005ba8: 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;
2005bac: 7f ff f2 80 call 20025ac <.udiv>
2005bb0: 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;
2005bb4: 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;
2005bb8: 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);
2005bbc: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
2005bc0: 7f ff f2 7b call 20025ac <.udiv>
2005bc4: 90 02 3f ff add %o0, -1, %o0
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
2005bc8: c2 07 20 10 ld [ %i4 + 0x10 ], %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;
2005bcc: b0 02 20 01 add %o0, 1, %i0
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;
sc->pages_active = 0;
2005bd0: c0 27 20 1c clr [ %i4 + 0x1c ]
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;
2005bd4: b6 26 c0 18 sub %i3, %i0, %i3
#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);
2005bd8: f0 27 20 18 st %i0, [ %i4 + 0x18 ]
sc->pages =
2005bdc: f6 27 20 14 st %i3, [ %i4 + 0x14 ]
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
sc->pages_active = 0;
sc->pages_used = 0;
2005be0: c0 27 20 20 clr [ %i4 + 0x20 ]
sc->pages_bad = 0;
2005be4: c0 27 20 24 clr [ %i4 + 0x24 ]
sc->failed = false;
if (!sc->page_descriptors)
2005be8: 80 a0 60 00 cmp %g1, 0
2005bec: 12 80 00 08 bne 2005c0c <rtems_fdisk_recover_block_mappings+0x104><== NEVER TAKEN
2005bf0: c0 27 20 28 clr [ %i4 + 0x28 ]
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
2005bf4: 92 10 00 1a mov %i2, %o1
2005bf8: 7f ff f2 33 call 20024c4 <.umul>
2005bfc: 90 10 00 18 mov %i0, %o0
2005c00: 40 00 0b 69 call 20089a4 <malloc>
2005c04: 01 00 00 00 nop
2005c08: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
if (!sc->page_descriptors)
2005c0c: f6 07 20 10 ld [ %i4 + 0x10 ], %i3
2005c10: 80 a6 e0 00 cmp %i3, 0
2005c14: 32 80 00 05 bne,a 2005c28 <rtems_fdisk_recover_block_mappings+0x120><== ALWAYS TAKEN
2005c18: 90 10 00 18 mov %i0, %o0
rtems_fdisk_abort ("no memory for page descriptors");
2005c1c: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005c20: 40 00 06 54 call 2007570 <rtems_fdisk_abort> <== NOT EXECUTED
2005c24: 90 12 20 28 or %o0, 0x28, %o0 ! 2030c28 <__FUNCTION__.6925+0x918><== 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,
2005c28: 7f ff f2 27 call 20024c4 <.umul>
2005c2c: 92 10 00 1a mov %i2, %o1
2005c30: 92 10 00 1c mov %i4, %o1
2005c34: 98 10 00 08 mov %o0, %o4
2005c38: 94 10 20 00 clr %o2
2005c3c: 90 10 00 1d mov %i5, %o0
2005c40: 7f ff fc d8 call 2004fa0 <rtems_fdisk_seg_read>
2005c44: 96 10 00 1b mov %i3, %o3
sc->pages_desc * fd->block_size);
if (ret)
2005c48: b0 92 20 00 orcc %o0, 0, %i0
2005c4c: 22 80 00 6a be,a 2005df4 <rtems_fdisk_recover_block_mappings+0x2ec><== ALWAYS TAKEN
2005c50: b4 10 20 00 clr %i2
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
2005c54: 40 00 74 41 call 2022d58 <strerror> <== NOT EXECUTED
2005c58: 01 00 00 00 nop <== NOT EXECUTED
2005c5c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2005c60: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2005c64: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2005c68: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005c6c: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
2005c70: 7f ff fd 82 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2005c74: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
2005c78: 81 c7 e0 08 ret <== NOT EXECUTED
2005c7c: 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))
2005c80: 7f ff fc 64 call 2004e10 <rtems_fdisk_page_desc_erased>
2005c84: 90 10 00 1b mov %i3, %o0
2005c88: 80 8a 20 ff btst 0xff, %o0
2005c8c: 22 80 00 2b be,a 2005d38 <rtems_fdisk_recover_block_mappings+0x230><== NEVER TAKEN
2005c90: 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);
2005c94: 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,
2005c98: 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,
2005c9c: 92 10 00 18 mov %i0, %o1
2005ca0: 7f ff f2 09 call 20024c4 <.umul>
2005ca4: 90 06 80 08 add %i2, %o0, %o0
2005ca8: 92 10 00 1c mov %i4, %o1
2005cac: 94 10 00 08 mov %o0, %o2
2005cb0: 96 10 00 18 mov %i0, %o3
2005cb4: 7f ff fc dd call 2005028 <rtems_fdisk_seg_blank_check>
2005cb8: 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)
2005cbc: 80 a2 20 00 cmp %o0, 0
2005cc0: 32 80 00 06 bne,a 2005cd8 <rtems_fdisk_recover_block_mappings+0x1d0><== NEVER TAKEN
2005cc4: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
2005cc8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
2005ccc: 82 00 60 01 inc %g1
2005cd0: 10 80 00 47 b 2005dec <rtems_fdisk_recover_block_mappings+0x2e4>
2005cd4: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005cd8: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
2005cdc: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2005ce0: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2005ce4: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
2005ce8: 7f ff fd 44 call 20051f8 <rtems_fdisk_warning> <== NOT EXECUTED
2005cec: 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;
2005cf0: 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,
2005cf4: 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;
2005cf8: 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,
2005cfc: 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;
2005d00: 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,
2005d04: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2005d08: 7f ff fd 0f call 2005144 <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
2005d0c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
page, pd);
if (ret)
2005d10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2005d14: 22 80 00 0d be,a 2005d48 <rtems_fdisk_recover_block_mappings+0x240><== NOT EXECUTED
2005d18: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2005d1c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
2005d20: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2005d24: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2005d28: 7f ff fd 54 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2005d2c: 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++;
2005d30: 10 80 00 06 b 2005d48 <rtems_fdisk_recover_block_mappings+0x240><== NOT EXECUTED
2005d34: 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))
2005d38: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2005d3c: 12 80 00 06 bne 2005d54 <rtems_fdisk_recover_block_mappings+0x24c><== NOT EXECUTED
2005d40: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
{
sc->pages_used++;
2005d44: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
2005d48: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005d4c: 10 80 00 28 b 2005dec <rtems_fdisk_recover_block_mappings+0x2e4><== NOT EXECUTED
2005d50: c2 27 20 20 st %g1, [ %i4 + 0x20 ] <== NOT EXECUTED
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
2005d54: 32 80 00 24 bne,a 2005de4 <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
2005d58: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
2005d5c: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
2005d60: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2005d64: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
2005d68: 2a 80 00 0a bcs,a 2005d90 <rtems_fdisk_recover_block_mappings+0x288><== NOT EXECUTED
2005d6c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
2005d70: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2005d74: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2005d78: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2005d7c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2005d80: 7f ff fd 1e call 20051f8 <rtems_fdisk_warning> <== NOT EXECUTED
2005d84: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
2005d88: 10 80 00 17 b 2005de4 <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
2005d8c: 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)
2005d90: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
2005d94: c4 00 40 0d ld [ %g1 + %o5 ], %g2 <== NOT EXECUTED
2005d98: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2005d9c: 02 80 00 0c be 2005dcc <rtems_fdisk_recover_block_mappings+0x2c4><== NOT EXECUTED
2005da0: 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: " \
2005da4: d2 00 a0 08 ld [ %g2 + 8 ], %o1 <== NOT EXECUTED
2005da8: d4 00 a0 0c ld [ %g2 + 0xc ], %o2 <== NOT EXECUTED
2005dac: d6 00 e0 04 ld [ %g3 + 4 ], %o3 <== NOT EXECUTED
2005db0: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2005db4: f4 23 a0 5c st %i2, [ %sp + 0x5c ] <== NOT EXECUTED
2005db8: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
2005dbc: 7f ff fd 2f call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2005dc0: 9a 10 00 19 mov %i1, %o5 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
2005dc4: 10 80 00 08 b 2005de4 <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
2005dc8: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
2005dcc: f8 20 40 0d st %i4, [ %g1 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
2005dd0: 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;
2005dd4: f4 20 e0 04 st %i2, [ %g3 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
2005dd8: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005ddc: 10 80 00 04 b 2005dec <rtems_fdisk_recover_block_mappings+0x2e4><== NOT EXECUTED
2005de0: c2 27 20 1c st %g1, [ %i4 + 0x1c ] <== NOT EXECUTED
}
}
else
sc->pages_bad++;
2005de4: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005de8: 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++)
2005dec: b4 06 a0 01 inc %i2
2005df0: b6 06 e0 08 add %i3, 8, %i3
2005df4: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2005df8: 80 a6 80 01 cmp %i2, %g1
2005dfc: 0a bf ff a1 bcs 2005c80 <rtems_fdisk_recover_block_mappings+0x178>
2005e00: 90 10 00 1d mov %i5, %o0
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
2005e04: 92 10 00 1c mov %i4, %o1
2005e08: 7f ff fd 80 call 2005408 <rtems_fdisk_queue_segment>
2005e0c: b2 06 60 01 inc %i1
*/
fd->erased_blocks = 0;
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
2005e10: 10 80 00 03 b 2005e1c <rtems_fdisk_recover_block_mappings+0x314>
2005e14: a4 04 a0 30 add %l2, 0x30, %l2
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
for (device = 0; device < fd->device_count; device++)
2005e18: b2 10 20 00 clr %i1
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
2005e1c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2005e20: 84 00 40 11 add %g1, %l1, %g2
2005e24: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2005e28: 80 a6 40 02 cmp %i1, %g2
2005e2c: 2a bf ff 57 bcs,a 2005b88 <rtems_fdisk_recover_block_mappings+0x80>
2005e30: f8 00 40 11 ld [ %g1 + %l1 ], %i4
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
for (device = 0; device < fd->device_count; device++)
2005e34: a0 04 20 01 inc %l0
2005e38: a2 04 60 0c add %l1, 0xc, %l1
2005e3c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2005e40: 80 a4 00 01 cmp %l0, %g1
2005e44: 0a bf ff f5 bcs 2005e18 <rtems_fdisk_recover_block_mappings+0x310>
2005e48: a4 10 20 00 clr %l2
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
}
2005e4c: 81 c7 e0 08 ret
2005e50: 91 e8 20 00 restore %g0, 0, %o0
02005580 <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)
{
2005580: 9d e3 bf 88 save %sp, -120, %sp
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
2005584: ac 10 20 00 clr %l6
* 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);
2005588: 82 06 20 30 add %i0, 0x30, %g1
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
int ret;
uint32_t spage;
uint32_t used = 0;
200558c: aa 10 20 00 clr %l5
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
2005590: a0 10 20 00 clr %l0
2005594: 10 80 00 c3 b 20058a0 <rtems_fdisk_recycle_segment+0x320>
2005598: c2 27 bf fc st %g1, [ %fp + -4 ]
{
uint32_t dst_pages;
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
200559c: a7 2c 20 03 sll %l0, 3, %l3
20055a0: a2 05 00 13 add %l4, %l3, %l1
* 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;
20055a4: c2 14 60 02 lduh [ %l1 + 2 ], %g1
for (spage = 0; spage < ssc->pages; spage++)
{
uint32_t dst_pages;
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
20055a8: 80 88 60 01 btst 1, %g1
20055ac: 12 80 00 b4 bne 200587c <rtems_fdisk_recycle_segment+0x2fc><== NEVER TAKEN
20055b0: 80 88 60 02 btst 2, %g1
20055b4: 02 80 00 b2 be 200587c <rtems_fdisk_recycle_segment+0x2fc>
20055b8: b8 10 20 00 clr %i4
* 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];
20055bc: e4 06 a0 10 ld [ %i2 + 0x10 ], %l2
20055c0: 10 80 00 32 b 2005688 <rtems_fdisk_recycle_segment+0x108>
20055c4: ba 10 00 12 mov %l2, %i5
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
if (rtems_fdisk_page_desc_erased (pd))
20055c8: 7f ff fe 12 call 2004e10 <rtems_fdisk_page_desc_erased>
20055cc: 90 10 00 1d mov %i5, %o0
20055d0: 80 8a 20 ff btst 0xff, %o0
20055d4: 22 80 00 2c be,a 2005684 <rtems_fdisk_recycle_segment+0x104>
20055d8: b8 07 20 01 inc %i4
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return EIO;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
20055dc: da 06 a0 08 ld [ %i2 + 8 ], %o5
20055e0: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
20055e4: d4 06 60 08 ld [ %i1 + 8 ], %o2
20055e8: d6 06 60 0c ld [ %i1 + 0xc ], %o3
20055ec: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
20055f0: 98 10 00 10 mov %l0, %o4
20055f4: f8 23 a0 60 st %i4, [ %sp + 0x60 ]
20055f8: 90 10 00 18 mov %i0, %o0
20055fc: 13 00 80 c2 sethi %hi(0x2030800), %o1
2005600: 7f ff fe 28 call 2004ea0 <rtems_fdisk_info>
2005604: 92 12 61 d0 or %o1, 0x1d0, %o1 ! 20309d0 <__FUNCTION__.6925+0x6c0>
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",
2005608: da 06 a0 08 ld [ %i2 + 8 ], %o5
200560c: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
#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,
2005610: ee 06 a0 18 ld [ %i2 + 0x18 ], %l7
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",
2005614: d4 06 60 08 ld [ %i1 + 8 ], %o2
2005618: d6 06 60 0c ld [ %i1 + 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,
200561c: fa 06 60 18 ld [ %i1 + 0x18 ], %i5
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",
2005620: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
#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,
2005624: ba 04 00 1d add %l0, %i5, %i5
2005628: ae 07 00 17 add %i4, %l7, %l7
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",
200562c: 98 10 00 1d mov %i5, %o4
2005630: ee 23 a0 60 st %l7, [ %sp + 0x60 ]
2005634: 90 10 00 18 mov %i0, %o0
2005638: 13 00 80 c2 sethi %hi(0x2030800), %o1
200563c: 7f ff fe 39 call 2004f20 <rtems_fdisk_printf>
2005640: 92 12 61 f8 or %o1, 0x1f8, %o1 ! 20309f8 <__FUNCTION__.6925+0x6e8>
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);
2005644: d8 06 20 14 ld [ %i0 + 0x14 ], %o4
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,
2005648: 90 10 00 1d mov %i5, %o0
200564c: 92 10 00 0c mov %o4, %o1
2005650: 7f ff f3 9d call 20024c4 <.umul>
2005654: d8 27 bf f8 st %o4, [ %fp + -8 ]
2005658: d6 06 20 64 ld [ %i0 + 0x64 ], %o3
200565c: d8 07 bf f8 ld [ %fp + -8 ], %o4
2005660: 94 10 00 08 mov %o0, %o2
2005664: 92 10 00 19 mov %i1, %o1
2005668: 7f ff fe 4e call 2004fa0 <rtems_fdisk_seg_read>
200566c: 90 10 00 18 mov %i0, %o0
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)
2005670: ba 92 20 00 orcc %o0, 0, %i5
2005674: 32 80 00 29 bne,a 2005718 <rtems_fdisk_recycle_segment+0x198><== NEVER TAKEN
2005678: e6 06 60 08 ld [ %i1 + 8 ], %l3 <== NOT EXECUTED
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
200567c: 10 80 00 1f b 20056f8 <rtems_fdisk_recycle_segment+0x178>
2005680: d6 06 20 64 ld [ %i0 + 0x64 ], %o3
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++)
2005684: ba 07 60 08 add %i5, 8, %i5
2005688: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
200568c: 80 a7 00 01 cmp %i4, %g1
2005690: 0a bf ff ce bcs 20055c8 <rtems_fdisk_recycle_segment+0x48><== ALWAYS TAKEN
2005694: 01 00 00 00 nop
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
2005698: 7f ff fd e8 call 2004e38 <rtems_fdisk_seg_pages_available><== NOT EXECUTED
200569c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20056a0: d2 06 a0 08 ld [ %i2 + 8 ], %o1 <== NOT EXECUTED
20056a4: d4 06 a0 0c ld [ %i2 + 0xc ], %o2 <== NOT EXECUTED
20056a8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20056ac: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
20056b0: 7f ff fe f2 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20056b4: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 20309a0 <__FUNCTION__.6925+0x690><== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
20056b8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
20056bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
20056c0: c2 26 a0 28 st %g1, [ %i2 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
20056c4: 7f ff ff 51 call 2005408 <rtems_fdisk_queue_segment> <== NOT EXECUTED
20056c8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
20056cc: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
20056d0: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
20056d4: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED
20056d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20056dc: 12 80 00 03 bne 20056e8 <rtems_fdisk_recycle_segment+0x168><== NOT EXECUTED
20056e0: f2 26 20 3c st %i1, [ %i0 + 0x3c ] <== NOT EXECUTED
queue->tail = sc;
20056e4: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
queue->count++;
20056e8: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
20056ec: 82 00 60 01 inc %g1 <== NOT EXECUTED
20056f0: 10 80 00 5d b 2005864 <rtems_fdisk_recycle_segment+0x2e4> <== NOT EXECUTED
20056f4: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
20056f8: 90 10 00 18 mov %i0, %o0
20056fc: 92 10 00 1a mov %i2, %o1
2005700: 7f ff fe a2 call 2005188 <rtems_fdisk_seg_write_page>
2005704: 94 10 00 17 mov %l7, %o2
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
2005708: ba 92 20 00 orcc %o0, 0, %i5
200570c: 22 80 00 0e be,a 2005744 <rtems_fdisk_recycle_segment+0x1c4><== ALWAYS TAKEN
2005710: c4 05 00 13 ld [ %l4 + %l3 ], %g2
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005714: e6 06 60 08 ld [ %i1 + 8 ], %l3 <== NOT EXECUTED
2005718: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
200571c: e2 06 a0 08 ld [ %i2 + 8 ], %l1 <== NOT EXECUTED
2005720: f6 06 a0 0c ld [ %i2 + 0xc ], %i3 <== NOT EXECUTED
2005724: 40 00 75 8d call 2022d58 <strerror> <== NOT EXECUTED
2005728: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200572c: f8 23 a0 5c st %i4, [ %sp + 0x5c ] <== NOT EXECUTED
2005730: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2005734: fa 23 a0 64 st %i5, [ %sp + 0x64 ] <== NOT EXECUTED
2005738: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
200573c: 10 80 00 18 b 200579c <rtems_fdisk_recycle_segment+0x21c> <== NOT EXECUTED
2005740: 90 12 22 28 or %o0, 0x228, %o0 ! 2030a28 <__FUNCTION__.6925+0x718><== NOT EXECUTED
{
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
2005744: 83 2f 20 03 sll %i4, 3, %g1
2005748: 96 04 80 01 add %l2, %g1, %o3
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
200574c: c4 24 80 01 st %g2, [ %l2 + %g1 ]
2005750: c2 04 60 04 ld [ %l1 + 4 ], %g1
ret = rtems_fdisk_seg_write_page_desc (fd,
2005754: 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;
2005758: c2 22 e0 04 st %g1, [ %o3 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
200575c: 92 10 00 1a mov %i2, %o1
2005760: 7f ff fe 79 call 2005144 <rtems_fdisk_seg_write_page_desc>
2005764: 94 10 00 1c mov %i4, %o2
dsc,
dpage, dpd);
if (ret)
2005768: ba 92 20 00 orcc %o0, 0, %i5
200576c: 22 80 00 20 be,a 20057ec <rtems_fdisk_recycle_segment+0x26c><== ALWAYS TAKEN
2005770: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005774: e6 06 60 08 ld [ %i1 + 8 ], %l3 <== NOT EXECUTED
2005778: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
200577c: e2 06 a0 08 ld [ %i2 + 8 ], %l1 <== NOT EXECUTED
2005780: 40 00 75 76 call 2022d58 <strerror> <== NOT EXECUTED
2005784: f6 06 a0 0c ld [ %i2 + 0xc ], %i3 <== NOT EXECUTED
2005788: f8 23 a0 5c st %i4, [ %sp + 0x5c ] <== NOT EXECUTED
200578c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2005790: fa 23 a0 64 st %i5, [ %sp + 0x64 ] <== NOT EXECUTED
2005794: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2005798: 90 12 22 70 or %o0, 0x270, %o0 ! 2030a70 <__FUNCTION__.6925+0x760><== NOT EXECUTED
200579c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
20057a0: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
20057a4: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
20057a8: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
20057ac: 7f ff fe b3 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20057b0: 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);
20057b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20057b8: 7f ff ff 14 call 2005408 <rtems_fdisk_queue_segment> <== NOT EXECUTED
20057bc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
20057c0: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
20057c4: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
20057c8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED
20057cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20057d0: 12 80 00 03 bne 20057dc <rtems_fdisk_recycle_segment+0x25c><== NOT EXECUTED
20057d4: f2 26 20 3c st %i1, [ %i0 + 0x3c ] <== NOT EXECUTED
queue->tail = sc;
20057d8: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
queue->count++;
20057dc: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
20057e0: 82 00 60 01 inc %g1 <== NOT EXECUTED
20057e4: 10 80 00 44 b 20058f4 <rtems_fdisk_recycle_segment+0x374> <== NOT EXECUTED
20057e8: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
20057ec: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
20057f0: 82 00 60 01 inc %g1
20057f4: c2 26 a0 1c st %g1, [ %i2 + 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--;
20057f8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
fd->blocks[spd->block].page = dpage;
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
20057fc: 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--;
2005800: 82 00 7f ff add %g1, -1, %g1
2005804: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
ssc->pages_used++;
2005808: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
fd->blocks[spd->block].page = dpage;
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
200580c: 92 10 00 1a mov %i2, %o1
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
ssc->pages_used++;
2005810: 82 00 60 01 inc %g1
2005814: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
fd->blocks[spd->block].segment = dsc;
2005818: c2 04 60 04 ld [ %l1 + 4 ], %g1
200581c: 83 28 60 03 sll %g1, 3, %g1
2005820: 86 00 80 01 add %g2, %g1, %g3
2005824: f4 20 80 01 st %i2, [ %g2 + %g1 ]
fd->blocks[spd->block].page = dpage;
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
2005828: 7f ff fe f8 call 2005408 <rtems_fdisk_queue_segment>
200582c: f8 20 e0 04 st %i4, [ %g3 + 4 ]
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005830: 7f ff fd 82 call 2004e38 <rtems_fdisk_seg_pages_available>
2005834: 90 10 00 1a mov %i2, %o0
if (dst_pages == 0)
2005838: 80 a2 20 00 cmp %o0, 0
200583c: 32 80 00 0c bne,a 200586c <rtems_fdisk_recycle_segment+0x2ec><== ALWAYS TAKEN
2005840: c2 06 c0 00 ld [ %i3 ], %g1
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005844: 7f ff fd 85 call 2004e58 <rtems_fdisk_seg_most_available> <== NOT EXECUTED
2005848: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
if (!dsc)
200584c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2005850: 32 80 00 07 bne,a 200586c <rtems_fdisk_recycle_segment+0x2ec><== NOT EXECUTED
2005854: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("recycle: no available dst segment");
2005858: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
200585c: 7f ff fe 87 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
2005860: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 2030ab8 <__FUNCTION__.6925+0x7a8><== NOT EXECUTED
return EIO;
2005864: 10 80 00 24 b 20058f4 <rtems_fdisk_recycle_segment+0x374> <== NOT EXECUTED
2005868: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
200586c: ac 05 a0 01 inc %l6
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
}
(*pages)--;
2005870: 82 00 7f ff add %g1, -1, %g1
uint32_t dst_pages;
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
!rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
{
2005874: 10 80 00 0a b 200589c <rtems_fdisk_recycle_segment+0x31c>
2005878: c2 26 c0 00 st %g1, [ %i3 ]
}
}
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
200587c: 7f ff fd 65 call 2004e10 <rtems_fdisk_page_desc_erased>
2005880: 90 10 00 11 mov %l1, %o0
2005884: 80 8a 20 ff btst 0xff, %o0
2005888: 22 80 00 05 be,a 200589c <rtems_fdisk_recycle_segment+0x31c><== ALWAYS TAKEN
200588c: aa 05 60 01 inc %l5
{
--fd->erased_blocks;
2005890: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
2005894: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2005898: c2 26 20 24 st %g1, [ %i0 + 0x24 ] <== NOT EXECUTED
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
200589c: a0 04 20 01 inc %l0
20058a0: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
20058a4: 80 a4 00 01 cmp %l0, %g1
20058a8: 2a bf ff 3d bcs,a 200559c <rtems_fdisk_recycle_segment+0x1c>
20058ac: e8 06 60 10 ld [ %i1 + 0x10 ], %l4
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
20058b0: d4 06 60 08 ld [ %i1 + 8 ], %o2
20058b4: d6 06 60 0c ld [ %i1 + 0xc ], %o3
20058b8: ea 23 a0 5c st %l5, [ %sp + 0x5c ]
20058bc: 90 10 00 18 mov %i0, %o0
20058c0: 13 00 80 c2 sethi %hi(0x2030800), %o1
20058c4: 98 10 00 1b mov %i3, %o4
20058c8: 92 12 62 e0 or %o1, 0x2e0, %o1
20058cc: 7f ff fd 95 call 2004f20 <rtems_fdisk_printf>
20058d0: 9a 10 00 16 mov %l6, %o5
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
20058d4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
20058d8: 80 a2 60 00 cmp %o1, 0
20058dc: 02 80 00 04 be 20058ec <rtems_fdisk_recycle_segment+0x36c><== ALWAYS TAKEN
20058e0: 11 00 80 c2 sethi %hi(0x2030800), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
20058e4: 7f ff fe 65 call 2005278 <rtems_fdisk_error> <== NOT EXECUTED
20058e8: 90 12 23 08 or %o0, 0x308, %o0 ! 2030b08 <__FUNCTION__.6925+0x7f8><== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
20058ec: 7f ff fe 80 call 20052ec <rtems_fdisk_erase_segment>
20058f0: 81 e8 00 00 restore
return ret;
}
20058f4: 81 c7 e0 08 ret <== NOT EXECUTED
20058f8: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
020050ac <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)
{
20050ac: 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;
20050b0: e0 06 60 08 ld [ %i1 + 8 ], %l0
segment = sc->segment;
20050b4: 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;
20050b8: 85 2c 20 04 sll %l0, 4, %g2
20050bc: 83 2c 20 02 sll %l0, 2, %g1
20050c0: 82 20 80 01 sub %g2, %g1, %g1
20050c4: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
20050c8: 89 2f 60 06 sll %i5, 6, %g4
20050cc: 86 00 80 01 add %g2, %g1, %g3
20050d0: c4 00 80 01 ld [ %g2 + %g1 ], %g2
20050d4: 83 2f 60 04 sll %i5, 4, %g1
20050d8: 82 21 00 01 sub %g4, %g1, %g1
20050dc: 82 00 80 01 add %g2, %g1, %g1
20050e0: 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;
20050e4: c2 00 e0 08 ld [ %g3 + 8 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
20050e8: 94 10 00 10 mov %l0, %o2
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;
20050ec: e4 00 60 08 ld [ %g1 + 8 ], %l2
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
20050f0: 96 10 00 1d mov %i5, %o3
20050f4: 98 10 00 1a mov %i2, %o4
20050f8: 9a 10 00 1c mov %i4, %o5
rtems_fdisk_seg_write (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t offset,
const void* buffer,
uint32_t size)
{
20050fc: 90 10 00 18 mov %i0, %o0
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
2005100: 13 00 80 c2 sethi %hi(0x2030800), %o1
2005104: 7f ff ff 87 call 2004f20 <rtems_fdisk_printf>
2005108: 92 12 60 c8 or %o1, 0xc8, %o1 ! 20308c8 <__FUNCTION__.6925+0x5b8>
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
200510c: c2 04 a0 04 ld [ %l2 + 4 ], %g1
2005110: 90 10 00 11 mov %l1, %o0
2005114: 92 10 00 10 mov %l0, %o1
2005118: 94 10 00 1d mov %i5, %o2
200511c: 96 10 00 1a mov %i2, %o3
2005120: 98 10 00 1b mov %i3, %o4
2005124: 9f c0 40 00 call %g1
2005128: 9a 10 00 1c mov %i4, %o5
if (ret)
200512c: 80 a2 20 00 cmp %o0, 0
2005130: 02 80 00 03 be 200513c <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
2005134: 82 10 20 01 mov 1, %g1
sc->failed = true;
2005138: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
200513c: 81 c7 e0 08 ret
2005140: 91 e8 00 08 restore %g0, %o0, %o0
02005188 <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)
{
2005188: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
200518c: c2 06 20 08 ld [ %i0 + 8 ], %g1
2005190: 80 88 60 08 btst 8, %g1
2005194: 22 80 00 0f be,a 20051d0 <rtems_fdisk_seg_write_page+0x48><== NEVER TAKEN
2005198: c2 06 20 24 ld [ %i0 + 0x24 ], %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);
200519c: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
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,
20051a0: 90 10 00 1a mov %i2, %o0
20051a4: 7f ff f4 c8 call 20024c4 <.umul>
20051a8: 92 10 00 1c mov %i4, %o1
20051ac: 92 10 00 19 mov %i1, %o1
20051b0: 94 10 00 08 mov %o0, %o2
20051b4: 96 10 00 1c mov %i4, %o3
20051b8: 7f ff ff 9c call 2005028 <rtems_fdisk_seg_blank_check>
20051bc: 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)
20051c0: 80 a2 20 00 cmp %o0, 0
20051c4: 12 80 00 0b bne 20051f0 <rtems_fdisk_seg_write_page+0x68> <== NEVER TAKEN
20051c8: 01 00 00 00 nop
return ret;
}
--fd->erased_blocks;
20051cc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
20051d0: 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;
20051d4: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
20051d8: 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;
20051dc: c2 26 20 24 st %g1, [ %i0 + 0x24 ]
return rtems_fdisk_seg_write (fd, sc,
20051e0: 7f ff f4 b9 call 20024c4 <.umul>
20051e4: 92 10 00 1c mov %i4, %o1
20051e8: 7f ff ff b1 call 20050ac <rtems_fdisk_seg_write>
20051ec: 95 e8 00 08 restore %g0, %o0, %o2
page * fd->block_size, buffer, fd->block_size);
}
20051f0: 81 c7 e0 08 ret <== NOT EXECUTED
20051f4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02005144 <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)
{
2005144: 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))
2005148: c2 06 20 08 ld [ %i0 + 8 ], %g1
200514c: 80 88 60 08 btst 8, %g1
2005150: 02 80 00 0a be 2005178 <rtems_fdisk_seg_write_page_desc+0x34><== NEVER TAKEN
2005154: b5 2e a0 03 sll %i2, 3, %i2
{
int ret = rtems_fdisk_seg_blank_check (fd, sc,
2005158: 90 10 00 18 mov %i0, %o0
200515c: 92 10 00 19 mov %i1, %o1
2005160: 94 10 00 1a mov %i2, %o2
2005164: 7f ff ff b1 call 2005028 <rtems_fdisk_seg_blank_check>
2005168: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
200516c: 80 a2 20 00 cmp %o0, 0
2005170: 12 80 00 04 bne 2005180 <rtems_fdisk_seg_write_page_desc+0x3c><== NEVER TAKEN
2005174: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
2005178: 7f ff ff cd call 20050ac <rtems_fdisk_seg_write>
200517c: 99 e8 20 08 restore %g0, 8, %o4
page_desc, sizeof (rtems_fdisk_page_desc));
}
2005180: 81 c7 e0 08 ret <== NOT EXECUTED
2005184: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02004d14 <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)
2004d14: 80 a2 60 00 cmp %o1, 0
2004d18: 02 80 00 10 be 2004d58 <rtems_fdisk_segment_queue_insert_before+0x44><== NEVER TAKEN
2004d1c: 84 10 00 08 mov %o0, %g2
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004d20: 10 80 00 0b b 2004d4c <rtems_fdisk_segment_queue_insert_before+0x38>
2004d24: c2 02 00 00 ld [ %o0 ], %g1
{
if (item == it)
2004d28: 32 80 00 08 bne,a 2004d48 <rtems_fdisk_segment_queue_insert_before+0x34><== NEVER TAKEN
2004d2c: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED
{
sc->next = item;
2004d30: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
queue->count++;
2004d34: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
*prev = sc;
2004d38: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
2004d3c: 82 00 60 01 inc %g1
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
}
2004d40: 81 c3 e0 08 retl
2004d44: c2 22 20 08 st %g1, [ %o0 + 8 ]
queue->count++;
return;
}
prev = &it->next;
it = it->next;
2004d48: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004d4c: 80 a0 60 00 cmp %g1, 0
2004d50: 12 bf ff f6 bne 2004d28 <rtems_fdisk_segment_queue_insert_before+0x14><== ALWAYS TAKEN
2004d54: 80 a2 40 01 cmp %o1, %g1
prev = &it->next;
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
2004d58: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2004d5c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004d60: 7f ff ff be call 2004c58 <rtems_fdisk_segment_queue_push_tail><== NOT EXECUTED
2004d64: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004c18 <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)
{
2004c18: 82 10 00 08 mov %o0, %g1
if (queue->head)
2004c1c: d0 02 00 00 ld [ %o0 ], %o0
2004c20: 80 a2 20 00 cmp %o0, 0
2004c24: 02 80 00 0b be 2004c50 <rtems_fdisk_segment_queue_pop_head+0x38><== NEVER TAKEN
2004c28: 01 00 00 00 nop
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
2004c2c: c4 02 00 00 ld [ %o0 ], %g2
if (!queue->head)
2004c30: 80 a0 a0 00 cmp %g2, 0
2004c34: 12 80 00 03 bne 2004c40 <rtems_fdisk_segment_queue_pop_head+0x28><== ALWAYS TAKEN
2004c38: c4 20 40 00 st %g2, [ %g1 ]
queue->tail = 0;
2004c3c: c0 20 60 04 clr [ %g1 + 4 ] <== NOT EXECUTED
queue->count--;
2004c40: c4 00 60 08 ld [ %g1 + 8 ], %g2
2004c44: 84 00 bf ff add %g2, -1, %g2
2004c48: c4 20 60 08 st %g2, [ %g1 + 8 ]
sc->next = 0;
2004c4c: c0 22 00 00 clr [ %o0 ]
return sc;
}
return 0;
}
2004c50: 81 c3 e0 08 retl
02004c58 <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)
2004c58: 80 a2 60 00 cmp %o1, 0
2004c5c: 02 80 00 0f be 2004c98 <rtems_fdisk_segment_queue_push_tail+0x40><== NEVER TAKEN
2004c60: 01 00 00 00 nop
{
sc->next = 0;
if (queue->head)
2004c64: c2 02 00 00 ld [ %o0 ], %g1
2004c68: 80 a0 60 00 cmp %g1, 0
2004c6c: 02 80 00 06 be 2004c84 <rtems_fdisk_segment_queue_push_tail+0x2c>
2004c70: c0 22 40 00 clr [ %o1 ]
{
queue->tail->next = sc;
2004c74: c2 02 20 04 ld [ %o0 + 4 ], %g1
2004c78: d2 20 40 00 st %o1, [ %g1 ]
queue->tail = sc;
2004c7c: 10 80 00 04 b 2004c8c <rtems_fdisk_segment_queue_push_tail+0x34>
2004c80: d2 22 20 04 st %o1, [ %o0 + 4 ]
}
else
{
queue->head = queue->tail = sc;
2004c84: d2 22 20 04 st %o1, [ %o0 + 4 ]
2004c88: d2 22 00 00 st %o1, [ %o0 ]
}
queue->count++;
2004c8c: c2 02 20 08 ld [ %o0 + 8 ], %g1
2004c90: 82 00 60 01 inc %g1
2004c94: c2 22 20 08 st %g1, [ %o0 + 8 ]
2004c98: 81 c3 e0 08 retl
02004ca0 <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;
2004ca0: c2 02 00 00 ld [ %o0 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004ca4: 10 80 00 17 b 2004d00 <rtems_fdisk_segment_queue_remove+0x60>
2004ca8: 84 10 20 00 clr %g2
{
if (sc == it)
2004cac: 32 80 00 14 bne,a 2004cfc <rtems_fdisk_segment_queue_remove+0x5c>
2004cb0: 84 10 00 01 mov %g1, %g2
{
if (prev == 0)
2004cb4: 80 a0 a0 00 cmp %g2, 0
2004cb8: 12 80 00 07 bne 2004cd4 <rtems_fdisk_segment_queue_remove+0x34>
2004cbc: c2 02 40 00 ld [ %o1 ], %g1
{
queue->head = sc->next;
if (queue->head == 0)
2004cc0: 80 a0 60 00 cmp %g1, 0
2004cc4: 12 80 00 09 bne 2004ce8 <rtems_fdisk_segment_queue_remove+0x48>
2004cc8: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
2004ccc: 10 80 00 07 b 2004ce8 <rtems_fdisk_segment_queue_remove+0x48>
2004cd0: c0 22 20 04 clr [ %o0 + 4 ]
}
else
{
prev->next = sc->next;
2004cd4: c2 20 80 00 st %g1, [ %g2 ]
if (queue->tail == sc)
2004cd8: c2 02 20 04 ld [ %o0 + 4 ], %g1
2004cdc: 80 a0 40 09 cmp %g1, %o1
2004ce0: 22 80 00 02 be,a 2004ce8 <rtems_fdisk_segment_queue_remove+0x48><== ALWAYS TAKEN
2004ce4: c4 22 20 04 st %g2, [ %o0 + 4 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
2004ce8: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
2004cec: c0 22 40 00 clr [ %o1 ]
queue->count--;
2004cf0: 82 00 7f ff add %g1, -1, %g1
break;
2004cf4: 81 c3 e0 08 retl
2004cf8: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = it;
it = it->next;
2004cfc: c2 00 40 00 ld [ %g1 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004d00: 80 a0 60 00 cmp %g1, 0
2004d04: 12 bf ff ea bne 2004cac <rtems_fdisk_segment_queue_remove+0xc>
2004d08: 80 a2 40 01 cmp %o1, %g1
2004d0c: 81 c3 e0 08 retl
020051f8 <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, ...)
{
20051f8: 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);
20051fc: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2005200: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2005204: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
2005208: 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)
200520c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
2005210: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005214: 02 80 00 17 be 2005270 <rtems_fdisk_warning+0x78> <== NOT EXECUTED
2005218: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
200521c: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
2005220: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
2005224: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
2005228: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
200522c: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2005230: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2005234: 40 00 6f 27 call 2020ed0 <fputs> <== NOT EXECUTED
2005238: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
200523c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
2005240: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2005244: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2005248: 40 00 91 7e call 2029840 <vfprintf> <== NOT EXECUTED
200524c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2005250: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
2005254: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
2005258: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
200525c: 40 00 6e e8 call 2020dfc <fputc> <== NOT EXECUTED
2005260: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
2005264: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
2005268: 40 00 6d d0 call 20209a8 <fflush> <== NOT EXECUTED
200526c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2005270: 81 c7 e0 08 ret <== NOT EXECUTED
2005274: 81 e8 00 00 restore <== NOT EXECUTED
0200c480 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
200c480: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
200c484: 7f ff fe e8 call 200c024 <geteuid>
200c488: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
200c48c: 91 2a 20 10 sll %o0, 0x10, %o0
200c490: 91 32 20 10 srl %o0, 0x10, %o0
200c494: 80 a2 00 1a cmp %o0, %i2
200c498: 22 80 00 12 be,a 200c4e0 <rtems_filesystem_check_access+0x60>
200c49c: b1 2e 20 06 sll %i0, 6, %i0
200c4a0: 80 a2 20 00 cmp %o0, 0
200c4a4: 12 80 00 04 bne 200c4b4 <rtems_filesystem_check_access+0x34>
200c4a8: 01 00 00 00 nop
perm_flags <<= RTEMS_FS_USR_SHIFT;
200c4ac: 10 80 00 0d b 200c4e0 <rtems_filesystem_check_access+0x60>
200c4b0: b1 2e 20 06 sll %i0, 6, %i0
} else {
gid_t task_gid = getegid();
200c4b4: 7f ff fe d8 call 200c014 <getegid>
200c4b8: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
200c4bc: 91 2a 20 10 sll %o0, 0x10, %o0
200c4c0: 91 32 20 10 srl %o0, 0x10, %o0
200c4c4: 80 a2 00 1b cmp %o0, %i3
200c4c8: 22 80 00 06 be,a 200c4e0 <rtems_filesystem_check_access+0x60>
200c4cc: b1 2e 20 03 sll %i0, 3, %i0
200c4d0: 80 a2 20 00 cmp %o0, 0
200c4d4: 32 80 00 04 bne,a 200c4e4 <rtems_filesystem_check_access+0x64><== ALWAYS TAKEN
200c4d8: b2 2e 00 19 andn %i0, %i1, %i1
perm_flags <<= RTEMS_FS_GRP_SHIFT;
200c4dc: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
200c4e0: b2 2e 00 19 andn %i0, %i1, %i1
}
200c4e4: 80 a0 00 19 cmp %g0, %i1
200c4e8: b0 60 3f ff subx %g0, -1, %i0
200c4ec: 81 c7 e0 08 ret
200c4f0: 81 e8 00 00 restore
0200c52c <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
)
{
200c52c: 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);
200c530: 37 00 80 6f sethi %hi(0x201bc00), %i3
¤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);
200c534: 3b 00 80 6e sethi %hi(0x201b800), %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 =
200c538: b8 06 20 18 add %i0, 0x18, %i4
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c53c: b6 16 e1 30 or %i3, 0x130, %i3
¤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);
200c540: ba 17 60 98 or %i5, 0x98, %i5
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
200c544: 40 00 00 94 call 200c794 <rtems_filesystem_eval_path_next_token>
200c548: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
200c54c: e0 06 20 0c ld [ %i0 + 0xc ], %l0
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
200c550: 80 a4 20 00 cmp %l0, 0
200c554: 02 80 00 3e be 200c64c <rtems_filesystem_eval_path_generic+0x120>
200c558: e2 06 20 08 ld [ %i0 + 8 ], %l1
if ((*config->is_directory)(ctx, arg)) {
200c55c: c2 06 80 00 ld [ %i2 ], %g1
200c560: 90 10 00 18 mov %i0, %o0
200c564: 9f c0 40 00 call %g1
200c568: 92 10 00 19 mov %i1, %o1
200c56c: 80 8a 20 ff btst 0xff, %o0
200c570: 02 80 00 57 be 200c6cc <rtems_filesystem_eval_path_generic+0x1a0>
200c574: 80 a4 20 01 cmp %l0, 1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200c578: 12 80 00 5f bne 200c6f4 <rtems_filesystem_eval_path_generic+0x1c8>
200c57c: 80 a4 20 02 cmp %l0, 2
200c580: c2 4c 40 00 ldsb [ %l1 ], %g1
200c584: 80 a0 60 2e cmp %g1, 0x2e
200c588: 32 80 00 5e bne,a 200c700 <rtems_filesystem_eval_path_generic+0x1d4>
200c58c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c590: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c594: 80 a0 60 00 cmp %g1, 0
200c598: 32 80 00 2f bne,a 200c654 <rtems_filesystem_eval_path_generic+0x128>
200c59c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
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: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200c5a4: 80 88 61 00 btst 0x100, %g1
200c5a8: 22 80 00 2b be,a 200c654 <rtems_filesystem_eval_path_generic+0x128>
200c5ac: c2 06 a0 04 ld [ %i2 + 4 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
200c5b0: 90 10 00 18 mov %i0, %o0
200c5b4: 10 80 00 48 b 200c6d4 <rtems_filesystem_eval_path_generic+0x1a8>
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: 80 a0 60 2e cmp %g1, 0x2e
200c5c0: 32 80 00 50 bne,a 200c700 <rtems_filesystem_eval_path_generic+0x1d4>
200c5c4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200c5c8: c2 4c 60 01 ldsb [ %l1 + 1 ], %g1
200c5cc: 80 a0 60 2e cmp %g1, 0x2e
200c5d0: 32 80 00 4c bne,a 200c700 <rtems_filesystem_eval_path_generic+0x1d4><== NEVER TAKEN
200c5d4: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
static bool is_eval_path_root(
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
200c5d8: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
return loc->mt_entry == rootloc->mt_entry
&& (*loc->ops->are_nodes_equal_h)( loc, rootloc );
200c5dc: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
200c5e0: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
200c5e4: 80 a0 80 01 cmp %g2, %g1
200c5e8: 12 80 00 4c bne 200c718 <rtems_filesystem_eval_path_generic+0x1ec>
200c5ec: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
200c5f0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200c5f4: 9f c0 40 00 call %g1
200c5f8: 90 10 00 1c mov %i4, %o0
200c5fc: 80 8a 20 ff btst 0xff, %o0
200c600: 22 80 00 45 be,a 200c714 <rtems_filesystem_eval_path_generic+0x1e8>
200c604: 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);
200c608: 10 80 00 13 b 200c654 <rtems_filesystem_eval_path_generic+0x128>
200c60c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
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)) {
if (currentloc->mt_entry->mt_point_node != NULL) {
200c610: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
200c614: 80 a0 60 00 cmp %g1, 0
200c618: 22 80 00 0f be,a 200c654 <rtems_filesystem_eval_path_generic+0x128><== NEVER TAKEN
200c61c: 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;
200c620: c2 06 20 0c ld [ %i0 + 0xc ], %g1
ctx->path -= tokenlen;
200c624: c4 06 00 00 ld [ %i0 ], %g2
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
200c628: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
200c62c: 84 20 80 01 sub %g2, %g1, %g2
200c630: c4 26 00 00 st %g2, [ %i0 ]
ctx->pathlen += tokenlen;
200c634: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
200c638: 90 10 00 18 mov %i0, %o0
200c63c: 82 00 80 01 add %g2, %g1, %g1
200c640: 92 02 60 14 add %o1, 0x14, %o1
200c644: 7f ff e1 4e call 2004b7c <rtems_filesystem_eval_path_restart>
200c648: c2 26 20 04 st %g1, [ %i0 + 4 ]
200c64c: 81 c7 e0 08 ret
200c650: 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);
200c654: 90 10 00 18 mov %i0, %o0
200c658: 92 10 00 19 mov %i1, %o1
200c65c: 94 10 00 1d mov %i5, %o2
200c660: 10 80 00 06 b 200c678 <rtems_filesystem_eval_path_generic+0x14c>
200c664: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c668: 90 10 00 18 mov %i0, %o0
200c66c: 92 10 00 19 mov %i1, %o1
200c670: 94 10 00 1b mov %i3, %o2
200c674: 96 10 20 02 mov 2, %o3
200c678: 9f c0 40 00 call %g1
200c67c: 01 00 00 00 nop
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
200c680: 80 a2 20 02 cmp %o0, 2
200c684: 12 80 00 18 bne 200c6e4 <rtems_filesystem_eval_path_generic+0x1b8>
200c688: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c68c: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c690: 80 a0 60 00 cmp %g1, 0
200c694: 02 80 00 2a be 200c73c <rtems_filesystem_eval_path_generic+0x210>
200c698: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
200c69c: 40 00 00 2a call 200c744 <rtems_filesystem_eval_path_eat_delimiter>
200c6a0: 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
200c6a4: 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 (
200c6a8: 80 88 60 80 btst 0x80, %g1
200c6ac: 02 80 00 06 be 200c6c4 <rtems_filesystem_eval_path_generic+0x198>
200c6b0: 90 10 00 18 mov %i0, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
200c6b4: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c6b8: 80 a0 60 00 cmp %g1, 0
200c6bc: 02 80 00 20 be 200c73c <rtems_filesystem_eval_path_generic+0x210>
200c6c0: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200c6c4: 10 80 00 04 b 200c6d4 <rtems_filesystem_eval_path_generic+0x1a8>
200c6c8: 92 10 20 02 mov 2, %o1 ! 2 <PROM_START+0x2>
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
200c6cc: 90 10 00 18 mov %i0, %o0
200c6d0: 92 10 20 14 mov 0x14, %o1
200c6d4: 7f ff e0 5f call 2004850 <rtems_filesystem_eval_path_error>
200c6d8: 01 00 00 00 nop
200c6dc: 81 c7 e0 08 ret
200c6e0: 81 e8 00 00 restore
)
{
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
200c6e4: 02 bf ff 98 be 200c544 <rtems_filesystem_eval_path_generic+0x18>
200c6e8: 01 00 00 00 nop
200c6ec: 81 c7 e0 08 ret
200c6f0: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200c6f4: 22 bf ff b2 be,a 200c5bc <rtems_filesystem_eval_path_generic+0x90>
200c6f8: c2 4c 40 00 ldsb [ %l1 ], %g1
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
200c6fc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200c700: 90 10 00 18 mov %i0, %o0
200c704: 92 10 00 19 mov %i1, %o1
200c708: 94 10 00 11 mov %l1, %o2
200c70c: 10 bf ff db b 200c678 <rtems_filesystem_eval_path_generic+0x14c>
200c710: 96 10 00 10 mov %l0, %o3
#include <rtems/libio_.h>
static bool is_fs_root( const rtems_filesystem_location_info_t *loc )
{
const rtems_filesystem_location_info_t *mt_fs_root =
&loc->mt_entry->mt_fs_root->location;
200c714: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
return (*loc->ops->are_nodes_equal_h)( loc, mt_fs_root );
200c718: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200c71c: d2 00 a0 18 ld [ %g2 + 0x18 ], %o1
200c720: 9f c0 40 00 call %g1
200c724: 90 10 00 1c mov %i4, %o0
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)) {
200c728: 80 8a 20 ff btst 0xff, %o0
200c72c: 32 bf ff b9 bne,a 200c610 <rtems_filesystem_eval_path_generic+0xe4>
200c730: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c734: 10 bf ff cd b 200c668 <rtems_filesystem_eval_path_generic+0x13c>
200c738: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200c73c: 81 c7 e0 08 ret
200c740: 81 e8 00 00 restore
02004bd8 <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
2004bd8: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
2004bdc: 80 a6 a0 00 cmp %i2, 0
2004be0: 02 80 00 28 be 2004c80 <rtems_filesystem_eval_path_recursive+0xa8><== NEVER TAKEN
2004be4: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
2004be8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2004bec: 80 a0 60 1f cmp %g1, 0x1f
2004bf0: 34 80 00 25 bg,a 2004c84 <rtems_filesystem_eval_path_recursive+0xac>
2004bf4: b2 10 20 5c mov 0x5c, %i1
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
2004bf8: c2 4e 40 00 ldsb [ %i1 ], %g1
const char *saved_path = ctx->path;
2004bfc: f6 06 00 00 ld [ %i0 ], %i3
2004c00: 84 18 60 5c xor %g1, 0x5c, %g2
2004c04: 80 a0 00 02 cmp %g0, %g2
2004c08: 82 18 60 2f xor %g1, 0x2f, %g1
2004c0c: 84 60 3f ff subx %g0, -1, %g2
2004c10: 80 a0 00 01 cmp %g0, %g1
2004c14: 82 60 3f ff subx %g0, -1, %g1
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
2004c18: 80 90 80 01 orcc %g2, %g1, %g0
2004c1c: 02 80 00 05 be 2004c30 <rtems_filesystem_eval_path_recursive+0x58>
2004c20: f8 06 20 04 ld [ %i0 + 4 ], %i4
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
2004c24: 90 10 00 18 mov %i0, %o0
2004c28: 7f ff ff d5 call 2004b7c <rtems_filesystem_eval_path_restart>
2004c2c: 92 06 20 34 add %i0, 0x34, %o1
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
2004c30: 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;
2004c34: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
++ctx->recursionlevel;
2004c38: 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;
2004c3c: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
2004c40: 10 80 00 05 b 2004c54 <rtems_filesystem_eval_path_recursive+0x7c>
2004c44: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.ops->eval_path_h)(ctx);
2004c48: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004c4c: 9f c0 40 00 call %g1
2004c50: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
2004c54: c2 07 60 04 ld [ %i5 + 4 ], %g1
2004c58: 80 a0 60 00 cmp %g1, 0
2004c5c: 32 bf ff fb bne,a 2004c48 <rtems_filesystem_eval_path_recursive+0x70>
2004c60: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004c64: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
2004c68: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004c6c: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
2004c70: f8 27 60 04 st %i4, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004c74: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
2004c78: 81 c7 e0 08 ret
2004c7c: 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);
2004c80: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
2004c84: 7f ff fe f3 call 2004850 <rtems_filesystem_eval_path_error>
2004c88: 81 e8 00 00 restore
0200c2f8 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
200c2f8: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
200c2fc: f0 27 bf f8 st %i0, [ %fp + -8 ]
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
200c300: 80 a6 20 00 cmp %i0, 0
200c304: 02 80 00 06 be 200c31c <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
200c308: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_iterate( find_handler, &fa );
200c30c: 11 00 80 30 sethi %hi(0x200c000), %o0
200c310: 92 07 bf f8 add %fp, -8, %o1
200c314: 7f ff ff d0 call 200c254 <rtems_filesystem_iterate>
200c318: 90 12 21 f0 or %o0, 0x1f0, %o0
}
return fa.mount_h;
}
200c31c: f0 07 bf fc ld [ %fp + -4 ], %i0
200c320: 81 c7 e0 08 ret
200c324: 81 e8 00 00 restore
020033f0 <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 )
{
20033f0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
20033f4: 05 00 80 6b sethi %hi(0x201ac00), %g2
20033f8: 82 10 a0 48 or %g2, 0x48, %g1 ! 201ac48 <rtems_filesystem_root_configuration>
20033fc: d0 00 a0 48 ld [ %g2 + 0x48 ], %o0
2003400: d2 00 60 04 ld [ %g1 + 4 ], %o1
2003404: d4 00 60 08 ld [ %g1 + 8 ], %o2
2003408: d6 00 60 0c ld [ %g1 + 0xc ], %o3
200340c: 40 00 02 36 call 2003ce4 <mount>
2003410: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
2003414: 80 a2 20 00 cmp %o0, 0
2003418: 22 80 00 05 be,a 200342c <rtems_filesystem_initialize+0x3c><== ALWAYS TAKEN
200341c: 11 00 80 6c sethi %hi(0x201b000), %o0
rtems_fatal_error_occurred( 0xABCD0002 );
2003420: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
2003424: 10 80 00 09 b 2003448 <rtems_filesystem_initialize+0x58> <== NOT EXECUTED
2003428: 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);
200342c: 92 10 21 ff mov 0x1ff, %o1
2003430: 40 00 01 de call 2003ba8 <mkdir>
2003434: 90 12 23 20 or %o0, 0x320, %o0
if ( rv != 0 )
2003438: 80 a2 20 00 cmp %o0, 0
200343c: 02 80 00 05 be 2003450 <rtems_filesystem_initialize+0x60> <== ALWAYS TAKEN
2003440: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
rtems_fatal_error_occurred( 0xABCD0003 );
2003444: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <RAM_END+0xa98d0003><== NOT EXECUTED
2003448: 40 00 12 d0 call 2007f88 <rtems_fatal_error_occurred> <== NOT EXECUTED
200344c: 01 00 00 00 nop <== NOT EXECUTED
2003450: 81 c7 e0 08 ret
2003454: 81 e8 00 00 restore
0200c254 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
200c254: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
200c258: 3b 00 80 6b sethi %hi(0x201ac00), %i5
rtems_chain_node *node = NULL;
bool stop = false;
200c25c: b6 10 20 00 clr %i3
while ( table_entry->type && !stop ) {
200c260: 10 80 00 06 b 200c278 <rtems_filesystem_iterate+0x24>
200c264: ba 17 60 5c or %i5, 0x5c, %i5
stop = (*routine)( table_entry, routine_arg );
200c268: 92 10 00 19 mov %i1, %o1
200c26c: 9f c6 00 00 call %i0
200c270: ba 07 60 08 add %i5, 8, %i5
200c274: b6 10 00 08 mov %o0, %i3
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
200c278: c2 07 40 00 ld [ %i5 ], %g1
200c27c: 80 a0 60 00 cmp %g1, 0
200c280: 02 80 00 08 be 200c2a0 <rtems_filesystem_iterate+0x4c>
200c284: 82 0e e0 ff and %i3, 0xff, %g1
200c288: 80 a0 60 00 cmp %g1, 0
200c28c: 02 bf ff f7 be 200c268 <rtems_filesystem_iterate+0x14>
200c290: 90 10 00 1d mov %i5, %o0
200c294: b0 0e e0 ff and %i3, 0xff, %i0
200c298: 81 c7 e0 08 ret
200c29c: 81 e8 00 00 restore
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
200c2a0: 80 a0 60 00 cmp %g1, 0
200c2a4: 32 80 00 13 bne,a 200c2f0 <rtems_filesystem_iterate+0x9c>
200c2a8: b0 0e e0 ff and %i3, 0xff, %i0
rtems_libio_lock();
200c2ac: 7f ff ff de call 200c224 <rtems_libio_lock>
200c2b0: 39 00 80 74 sethi %hi(0x201d000), %i4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200c2b4: 03 00 80 74 sethi %hi(0x201d000), %g1
200c2b8: fa 00 61 04 ld [ %g1 + 0x104 ], %i5 ! 201d104 <filesystem_chain>
for (
200c2bc: 10 80 00 06 b 200c2d4 <rtems_filesystem_iterate+0x80>
200c2c0: b8 17 21 08 or %i4, 0x108, %i4
!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 );
200c2c4: 9f c6 00 00 call %i0
200c2c8: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200c2cc: fa 07 40 00 ld [ %i5 ], %i5
200c2d0: b6 10 00 08 mov %o0, %i3
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
200c2d4: 80 a7 40 1c cmp %i5, %i4
200c2d8: 02 80 00 04 be 200c2e8 <rtems_filesystem_iterate+0x94>
200c2dc: 80 8e e0 ff btst 0xff, %i3
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
200c2e0: 02 bf ff f9 be 200c2c4 <rtems_filesystem_iterate+0x70> <== ALWAYS TAKEN
200c2e4: 90 07 60 08 add %i5, 8, %o0
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
200c2e8: 7f ff ff d6 call 200c240 <rtems_libio_unlock>
200c2ec: b0 0e e0 ff and %i3, 0xff, %i0
}
return stop;
}
200c2f0: 81 c7 e0 08 ret
200c2f4: 81 e8 00 00 restore
02004fe4 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
2004fe4: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
2004fe8: 7f ff fa b2 call 2003ab0 <malloc>
2004fec: 90 10 20 28 mov 0x28, %o0
if (global_loc != NULL) {
2004ff0: ba 92 20 00 orcc %o0, 0, %i5
2004ff4: 02 80 00 0b be 2005020 <rtems_filesystem_location_transform_to_global+0x3c><== NEVER TAKEN
2004ff8: 82 10 20 01 mov 1, %g1
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
2004ffc: c0 27 60 20 clr [ %i5 + 0x20 ]
)
{
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
if (global_loc != NULL) {
global_loc->reference_count = 1;
2005000: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
2005004: c0 27 60 24 clr [ %i5 + 0x24 ]
rtems_filesystem_location_copy(&global_loc->location, loc);
2005008: 7f ff ff 38 call 2004ce8 <rtems_filesystem_location_copy>
200500c: 92 10 00 18 mov %i0, %o1
rtems_filesystem_location_remove_from_mt_entry(loc);
2005010: 7f ff ff 68 call 2004db0 <rtems_filesystem_location_remove_from_mt_entry>
2005014: 90 10 00 18 mov %i0, %o0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
2005018: 81 c7 e0 08 ret
200501c: 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);
2005020: 40 00 1b c3 call 200bf2c <rtems_filesystem_location_free> <== NOT EXECUTED
2005024: 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 );
2005028: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
200502c: 7f ff ff bb call 2004f18 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
2005030: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
2005034: 40 00 2a 10 call 200f874 <__errno> <== NOT EXECUTED
2005038: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
200503c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
2005040: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
2005044: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2005048: 81 c7 e0 08 ret <== NOT EXECUTED
200504c: 81 e8 00 00 restore <== NOT EXECUTED
02007b70 <rtems_fsmount>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
2007b70: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007b74: 25 00 81 7b sethi %hi(0x205ec00), %l2 <== NOT EXECUTED
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007b78: 23 00 81 7b sethi %hi(0x205ec00), %l1 <== NOT EXECUTED
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
2007b7c: 21 00 81 7b sethi %hi(0x205ec00), %l0 <== NOT EXECUTED
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int rc = 0;
int tmp_rc;
size_t fstab_idx = 0;
2007b80: ba 10 20 00 clr %i5 <== NOT EXECUTED
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007b84: 39 00 81 ae sethi %hi(0x206b800), %i4 <== NOT EXECUTED
2007b88: a4 14 a3 10 or %l2, 0x310, %l2 <== NOT EXECUTED
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007b8c: a2 14 62 e0 or %l1, 0x2e0, %l1 <== NOT EXECUTED
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
2007b90: 10 80 00 3d b 2007c84 <rtems_fsmount+0x114> <== NOT EXECUTED
2007b94: a0 14 22 a8 or %l0, 0x2a8, %l0 <== NOT EXECUTED
tmp_rc = 0;
/*
* create mount point
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
2007b98: 40 00 08 24 call 2009c28 <rtems_mkdir> <== NOT EXECUTED
2007b9c: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (tmp_rc != 0) {
2007ba0: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
2007ba4: 22 80 00 41 be,a 2007ca8 <rtems_fsmount+0x138> <== NOT EXECUTED
2007ba8: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
2007bac: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
2007bb0: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2007bb4: 22 80 00 0e be,a 2007bec <rtems_fsmount+0x7c> <== NOT EXECUTED
2007bb8: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1 <== NOT EXECUTED
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
2007bbc: c2 07 21 68 ld [ %i4 + 0x168 ], %g1 <== NOT EXECUTED
2007bc0: e6 06 20 04 ld [ %i0 + 4 ], %l3 <== NOT EXECUTED
fstab_ptr->target,
strerror(errno));
2007bc4: 40 00 e8 37 call 2041ca0 <__errno> <== NOT EXECUTED
2007bc8: e8 00 60 08 ld [ %g1 + 8 ], %l4 <== NOT EXECUTED
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
2007bcc: 40 01 04 2b call 2048c78 <strerror> <== NOT EXECUTED
2007bd0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2007bd4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2007bd8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2007bdc: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
2007be0: 40 00 ea fa call 20427c8 <fprintf> <== NOT EXECUTED
2007be4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNTPNT_CRTERR)) {
2007be8: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1 <== NOT EXECUTED
2007bec: 10 80 00 14 b 2007c3c <rtems_fsmount+0xcc> <== NOT EXECUTED
2007bf0: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
fstab_ptr->target,
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
2007bf4: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
2007bf8: 22 80 00 10 be,a 2007c38 <rtems_fsmount+0xc8> <== NOT EXECUTED
2007bfc: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1 <== NOT EXECUTED
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007c00: c2 07 21 68 ld [ %i4 + 0x168 ], %g1 <== NOT EXECUTED
2007c04: e8 06 00 00 ld [ %i0 ], %l4 <== NOT EXECUTED
2007c08: ea 00 60 08 ld [ %g1 + 8 ], %l5 <== NOT EXECUTED
" \"%s\" failed: %s\n",
fstab_ptr->source,
fstab_ptr->target,
strerror(errno));
2007c0c: 40 00 e8 25 call 2041ca0 <__errno> <== NOT EXECUTED
2007c10: e6 06 20 04 ld [ %i0 + 4 ], %l3 <== NOT EXECUTED
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007c14: 40 01 04 19 call 2048c78 <strerror> <== NOT EXECUTED
2007c18: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2007c1c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2007c20: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
2007c24: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
2007c28: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
2007c2c: 40 00 ea e7 call 20427c8 <fprintf> <== NOT EXECUTED
2007c30: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED
" \"%s\" failed: %s\n",
fstab_ptr->source,
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_FAILED)) {
2007c34: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1 <== NOT EXECUTED
2007c38: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
2007c3c: 12 80 00 17 bne 2007c98 <rtems_fsmount+0x128> <== NOT EXECUTED
2007c40: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
}
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
2007c44: 10 80 00 0f b 2007c80 <rtems_fsmount+0x110> <== NOT EXECUTED
2007c48: b0 06 20 14 add %i0, 0x14, %i0 <== NOT EXECUTED
terminate = true;
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
2007c4c: 22 80 00 09 be,a 2007c70 <rtems_fsmount+0x100> <== NOT EXECUTED
2007c50: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1 <== NOT EXECUTED
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007c54: c2 07 21 68 ld [ %i4 + 0x168 ], %g1 <== NOT EXECUTED
2007c58: d4 06 00 00 ld [ %i0 ], %o2 <== NOT EXECUTED
2007c5c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2007c60: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
2007c64: 40 00 ea d9 call 20427c8 <fprintf> <== NOT EXECUTED
2007c68: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
" \"%s\" succeeded\n",
fstab_ptr->source,
fstab_ptr->target);
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_OK)) {
2007c6c: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1 <== NOT EXECUTED
2007c70: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2007c74: 12 80 00 08 bne 2007c94 <rtems_fsmount+0x124> <== NOT EXECUTED
2007c78: b6 10 20 00 clr %i3 <== NOT EXECUTED
}
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
2007c7c: b0 06 20 14 add %i0, 0x14, %i0 <== NOT EXECUTED
fstab_idx++;
2007c80: ba 07 60 01 inc %i5 <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
2007c84: 80 a7 40 19 cmp %i5, %i1 <== NOT EXECUTED
2007c88: 32 bf ff c4 bne,a 2007b98 <rtems_fsmount+0x28> <== NOT EXECUTED
2007c8c: d0 06 20 04 ld [ %i0 + 4 ], %o0 <== NOT EXECUTED
2007c90: b6 10 20 00 clr %i3 <== NOT EXECUTED
if (!terminate) {
fstab_ptr++;
fstab_idx++;
}
}
if (fail_idx != NULL) {
2007c94: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2007c98: 32 80 00 02 bne,a 2007ca0 <rtems_fsmount+0x130> <== NOT EXECUTED
2007c9c: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
*fail_idx = fstab_idx;
}
return rc;
}
2007ca0: 81 c7 e0 08 ret <== NOT EXECUTED
2007ca4: 91 e8 00 1b restore %g0, %i3, %o0 <== NOT EXECUTED
}
/*
* mount device to given mount point
*/
if (tmp_rc == 0) {
tmp_rc = mount(fstab_ptr->source,
2007ca8: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== NOT EXECUTED
2007cac: d4 06 20 08 ld [ %i0 + 8 ], %o2 <== NOT EXECUTED
2007cb0: d6 06 20 0c ld [ %i0 + 0xc ], %o3 <== NOT EXECUTED
2007cb4: 40 00 04 ee call 200906c <mount> <== NOT EXECUTED
2007cb8: 98 10 20 00 clr %o4 <== NOT EXECUTED
fstab_ptr->target,
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
2007cbc: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
2007cc0: 12 bf ff cd bne 2007bf4 <rtems_fsmount+0x84> <== NOT EXECUTED
2007cc4: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
terminate = true;
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
2007cc8: 10 bf ff e1 b 2007c4c <rtems_fsmount+0xdc> <== NOT EXECUTED
2007ccc: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
02003f14 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2003f14: 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 ) );
2003f18: 40 00 01 16 call 2004370 <malloc>
2003f1c: 90 10 20 08 mov 8, %o0
*key = new_key;
2003f20: 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 ) );
2003f24: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
2003f28: c0 22 00 00 clr [ %o0 ]
new_key->dtor = dtor;
2003f2c: 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 );
2003f30: 92 10 00 1d mov %i5, %o1
2003f34: 90 10 20 00 clr %o0
2003f38: 94 10 00 19 mov %i1, %o2
2003f3c: 40 00 11 fc call 200872c <rtems_task_variable_add>
2003f40: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
2003f44: 80 a2 20 00 cmp %o0, 0
2003f48: 02 80 00 04 be 2003f58 <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
2003f4c: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
2003f50: 7f ff ff 81 call 2003d54 <free> <== NOT EXECUTED
2003f54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
2003f58: 81 c7 e0 08 ret
2003f5c: 81 e8 00 00 restore
02003f6c <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
2003f6c: 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 );
2003f70: 90 10 20 00 clr %o0
2003f74: 40 00 12 17 call 20087d0 <rtems_task_variable_delete>
2003f78: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
2003f7c: 80 a2 20 00 cmp %o0, 0
2003f80: 12 80 00 06 bne 2003f98 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2003f84: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
2003f88: 02 80 00 04 be 2003f98 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2003f8c: 01 00 00 00 nop
2003f90: 7f ff ff 71 call 2003d54 <free>
2003f94: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
2003f98: 81 c7 e0 08 ret
2003f9c: 91 e8 20 00 restore %g0, 0, %o0
02003eb0 <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))
{
2003eb0: 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 ) {
2003eb4: c2 06 00 00 ld [ %i0 ], %g1
2003eb8: 80 a0 60 00 cmp %g1, 0
2003ebc: 12 80 00 14 bne 2003f0c <rtems_gxx_once+0x5c>
2003ec0: 90 10 21 00 mov 0x100, %o0
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2003ec4: 92 10 21 00 mov 0x100, %o1
2003ec8: 40 00 11 a0 call 2008548 <rtems_task_mode>
2003ecc: 94 07 bf fc add %fp, -4, %o2
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2003ed0: fa 06 00 00 ld [ %i0 ], %i5
2003ed4: 80 a7 60 00 cmp %i5, 0
2003ed8: 12 80 00 05 bne 2003eec <rtems_gxx_once+0x3c> <== NEVER TAKEN
2003edc: d0 07 bf fc ld [ %fp + -4 ], %o0
*(volatile __gthread_once_t *)once = 1;
2003ee0: 82 10 20 01 mov 1, %g1
2003ee4: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2003ee8: d0 07 bf fc ld [ %fp + -4 ], %o0
2003eec: 92 10 21 00 mov 0x100, %o1
2003ef0: 40 00 11 96 call 2008548 <rtems_task_mode>
2003ef4: 94 07 bf fc add %fp, -4, %o2
if ( o == 0 )
2003ef8: 80 a7 60 00 cmp %i5, 0
2003efc: 12 80 00 04 bne 2003f0c <rtems_gxx_once+0x5c> <== NEVER TAKEN
2003f00: 01 00 00 00 nop
(*func)();
2003f04: 9f c6 40 00 call %i1
2003f08: 01 00 00 00 nop
}
return 0;
}
2003f0c: 81 c7 e0 08 ret
2003f10: 91 e8 20 00 restore %g0, 0, %o0
02004004 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
2004004: 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 );
2004008: d4 06 20 04 ld [ %i0 + 4 ], %o2
200400c: 92 10 00 18 mov %i0, %o1
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
2004010: ba 10 00 18 mov %i0, %i5
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 );
2004014: 90 10 20 00 clr %o0
2004018: 40 00 11 c5 call 200872c <rtems_task_variable_add>
200401c: b0 10 3f ff mov -1, %i0
if ( status == RTEMS_SUCCESSFUL ) {
2004020: 80 a2 20 00 cmp %o0, 0
2004024: 12 80 00 04 bne 2004034 <rtems_gxx_setspecific+0x30> <== NEVER TAKEN
2004028: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
200402c: f2 27 40 00 st %i1, [ %i5 ]
return 0;
2004030: b0 10 20 00 clr %i0
}
return -1;
}
2004034: 81 c7 e0 08 ret
2004038: 81 e8 00 00 restore
02007d04 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007d04: 9d e3 bf a0 save %sp, -96, %sp
if (
2007d08: 03 00 80 91 sethi %hi(0x2024400), %g1
2007d0c: c2 00 63 e8 ld [ %g1 + 0x3e8 ], %g1 ! 20247e8 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007d10: b8 10 00 18 mov %i0, %i4
2007d14: ba 10 00 19 mov %i1, %i5
if (
2007d18: 80 a0 60 03 cmp %g1, 3
2007d1c: 12 80 00 07 bne 2007d38 <rtems_heap_allocate_aligned_with_boundary+0x34><== NEVER TAKEN
2007d20: b6 10 00 1a mov %i2, %i3
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
2007d24: 7f ff fb d6 call 2006c7c <malloc_is_system_state_OK>
2007d28: 01 00 00 00 nop
2007d2c: 80 8a 20 ff btst 0xff, %o0
2007d30: 02 80 00 08 be 2007d50 <rtems_heap_allocate_aligned_with_boundary+0x4c>
2007d34: 01 00 00 00 nop
) {
return NULL;
}
malloc_deferred_frees_process();
2007d38: 7f ff fb e3 call 2006cc4 <malloc_deferred_frees_process>
2007d3c: b2 10 00 1c mov %i4, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
2007d40: 03 00 80 8c sethi %hi(0x2023000), %g1
2007d44: f0 00 60 ac ld [ %g1 + 0xac ], %i0 ! 20230ac <RTEMS_Malloc_Heap>
2007d48: 40 00 17 4c call 200da78 <_Protected_heap_Allocate_aligned_with_boundary>
2007d4c: 95 e8 00 1d restore %g0, %i5, %o2
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
2007d50: 81 c7 e0 08 ret
2007d54: 91 e8 20 00 restore %g0, 0, %o0
02004eb4 <rtems_ide_part_table_free>:
* RETURNS:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
2004eb4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
2004eb8: ba 10 20 00 clr %i5 <== NOT EXECUTED
*
* RETURNS:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
2004ebc: 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(disk_desc->partitions[part_num]);
2004ec0: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 <== NOT EXECUTED
2004ec4: 7f ff fe b4 call 2004994 <partition_free> <== NOT EXECUTED
2004ec8: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
static void
partition_table_free(rtems_disk_desc_t *disk_desc)
{
int part_num;
for (part_num = 0;
2004ecc: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
2004ed0: 12 bf ff fc bne 2004ec0 <rtems_ide_part_table_free+0xc> <== NOT EXECUTED
2004ed4: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
}
free(disk_desc);
2004ed8: 40 00 02 e2 call 2005a60 <free> <== NOT EXECUTED
2004edc: 81 e8 00 00 restore <== NOT EXECUTED
02004ee0 <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 );
2004ee0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004ee4: 7f ff ff 82 call 2004cec <partition_table_get> <== NOT EXECUTED
2004ee8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004eec <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)
{
2004eec: 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));
2004ef0: 90 10 20 01 mov 1, %o0
2004ef4: 92 10 21 28 mov 0x128, %o1
2004ef8: 40 00 02 0a call 2005720 <calloc>
2004efc: b6 10 20 1a mov 0x1a, %i3
if (disk_desc == NULL)
2004f00: 80 a2 20 00 cmp %o0, 0
2004f04: 02 80 00 39 be 2004fe8 <rtems_ide_part_table_initialize+0xfc><== NEVER TAKEN
2004f08: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
2004f0c: 90 10 00 18 mov %i0, %o0
2004f10: 7f ff ff 77 call 2004cec <partition_table_get>
2004f14: 92 10 00 1d mov %i5, %o1
if (rc != RTEMS_SUCCESSFUL)
2004f18: b6 92 20 00 orcc %o0, 0, %i3
2004f1c: 12 80 00 31 bne 2004fe0 <rtems_ide_part_table_initialize+0xf4><== NEVER TAKEN
2004f20: 01 00 00 00 nop
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++)
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2004f24: 27 00 80 90 sethi %hi(0x2024000), %l3
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);
2004f28: 29 00 80 90 sethi %hi(0x2024000), %l4
/* 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);
2004f2c: e4 07 40 00 ld [ %i5 ], %l2
2004f30: e2 07 60 04 ld [ %i5 + 4 ], %l1
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.minor;
2004f34: b2 10 00 1d mov %i5, %i1
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2004f38: b8 10 20 00 clr %i4
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2004f3c: b4 07 bf f0 add %fp, -16, %i2
2004f40: a6 14 e1 58 or %l3, 0x158, %l3
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);
2004f44: 21 00 80 98 sethi %hi(0x2026000), %l0
*/
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++)
2004f48: 10 80 00 1a b 2004fb0 <rtems_ide_part_table_initialize+0xc4>
2004f4c: a8 15 21 60 or %l4, 0x160, %l4
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2004f50: 92 10 00 13 mov %l3, %o1
2004f54: 90 10 00 1a mov %i2, %o0
2004f58: 94 10 00 18 mov %i0, %o2
2004f5c: 40 00 42 e5 call 2015af0 <sprintf>
2004f60: 96 10 00 1c mov %i4, %o3
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
2004f64: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
if (part_desc == NULL)
2004f68: 80 a0 60 00 cmp %g1, 0
2004f6c: 02 80 00 10 be 2004fac <rtems_ide_part_table_initialize+0xc0>
2004f70: 92 07 00 11 add %i4, %l1, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
2004f74: d4 1f 40 00 ldd [ %i5 ], %o2
2004f78: d8 00 60 04 ld [ %g1 + 4 ], %o4
2004f7c: da 00 60 08 ld [ %g1 + 8 ], %o5
2004f80: 90 10 00 12 mov %l2, %o0
2004f84: 7f ff fd 11 call 20043c8 <rtems_disk_create_log>
2004f88: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
2004f8c: 96 92 20 00 orcc %o0, 0, %o3
2004f90: 22 80 00 08 be,a 2004fb0 <rtems_ide_part_table_initialize+0xc4><== ALWAYS TAKEN
2004f94: b2 06 60 04 add %i1, 4, %i1
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
2004f98: c2 04 21 80 ld [ %l0 + 0x180 ], %g1 <== NOT EXECUTED
2004f9c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2004fa0: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2004fa4: 40 00 40 3d call 2015098 <fprintf> <== NOT EXECUTED
2004fa8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
continue;
2004fac: b2 06 60 04 add %i1, 4, %i1
*/
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++)
2004fb0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
2004fb4: 80 a7 00 01 cmp %i4, %g1
2004fb8: 26 bf ff e6 bl,a 2004f50 <rtems_ide_part_table_initialize+0x64>
2004fbc: b8 07 20 01 inc %i4
2004fc0: b8 10 20 00 clr %i4
* 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)
2004fc4: 82 07 40 1c add %i5, %i4, %g1
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
2004fc8: d0 00 60 28 ld [ %g1 + 0x28 ], %o0
2004fcc: 7f ff fe 72 call 2004994 <partition_free>
2004fd0: b8 07 20 04 add %i4, 4, %i4
static void
partition_table_free(rtems_disk_desc_t *disk_desc)
{
int part_num;
for (part_num = 0;
2004fd4: 80 a7 20 10 cmp %i4, 0x10
2004fd8: 12 bf ff fc bne 2004fc8 <rtems_ide_part_table_initialize+0xdc>
2004fdc: 82 07 40 1c add %i5, %i4, %g1
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
}
free(disk_desc);
2004fe0: 40 00 02 a0 call 2005a60 <free>
2004fe4: 90 10 00 1d mov %i5, %o0
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
2004fe8: 81 c7 e0 08 ret
2004fec: 91 e8 00 1b restore %g0, %i3, %o0
0200a5a0 <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)
{
200a5a0: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
200a5a4: 80 a6 20 00 cmp %i0, 0
200a5a8: 02 80 00 1b be 200a614 <rtems_iterate_over_all_threads+0x74><== NEVER TAKEN
200a5ac: ba 10 20 01 mov 1, %i5
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
200a5b0: 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)
200a5b4: 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 ];
200a5b8: 84 16 a2 88 or %i2, 0x288, %g2
200a5bc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200a5c0: f6 00 60 04 ld [ %g1 + 4 ], %i3
if ( !information )
200a5c4: 80 a6 e0 00 cmp %i3, 0
200a5c8: 12 80 00 0b bne 200a5f4 <rtems_iterate_over_all_threads+0x54>
200a5cc: b8 10 20 01 mov 1, %i4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
200a5d0: 10 80 00 0e b 200a608 <rtems_iterate_over_all_threads+0x68>
200a5d4: ba 07 60 01 inc %i5
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 ];
200a5d8: 83 2f 20 02 sll %i4, 2, %g1
200a5dc: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !the_thread )
200a5e0: 80 a2 20 00 cmp %o0, 0
200a5e4: 02 80 00 04 be 200a5f4 <rtems_iterate_over_all_threads+0x54>
200a5e8: b8 07 20 01 inc %i4
continue;
(*routine)(the_thread);
200a5ec: 9f c6 00 00 call %i0
200a5f0: 01 00 00 00 nop
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
200a5f4: c2 16 e0 10 lduh [ %i3 + 0x10 ], %g1
200a5f8: 80 a7 00 01 cmp %i4, %g1
200a5fc: 28 bf ff f7 bleu,a 200a5d8 <rtems_iterate_over_all_threads+0x38>
200a600: 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++ ) {
200a604: ba 07 60 01 inc %i5
200a608: 80 a7 60 04 cmp %i5, 4
200a60c: 12 bf ff eb bne 200a5b8 <rtems_iterate_over_all_threads+0x18>
200a610: 83 2f 60 02 sll %i5, 2, %g1
200a614: 81 c7 e0 08 ret
200a618: 81 e8 00 00 restore
0200c198 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
200c198: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_free( &iop->pathinfo );
200c19c: 7f ff ff 64 call 200bf2c <rtems_filesystem_location_free>
200c1a0: 90 06 20 1c add %i0, 0x1c, %o0
rtems_libio_lock();
200c1a4: 7f ff ff a4 call 200c034 <rtems_libio_lock>
200c1a8: 01 00 00 00 nop
if (iop->sem)
200c1ac: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
200c1b0: 80 a2 20 00 cmp %o0, 0
200c1b4: 22 80 00 05 be,a 200c1c8 <rtems_libio_free+0x30> <== NEVER TAKEN
200c1b8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
rtems_semaphore_delete(iop->sem);
200c1bc: 7f ff ed 80 call 20077bc <rtems_semaphore_delete>
200c1c0: 01 00 00 00 nop
iop->flags &= ~LIBIO_FLAGS_OPEN;
200c1c4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200c1c8: 82 08 7e ff and %g1, -257, %g1
200c1cc: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
iop->data1 = rtems_libio_iop_freelist;
200c1d0: 03 00 80 76 sethi %hi(0x201d800), %g1
200c1d4: c4 00 62 9c ld [ %g1 + 0x29c ], %g2 ! 201da9c <rtems_libio_iop_freelist>
rtems_libio_iop_freelist = iop;
200c1d8: f0 20 62 9c st %i0, [ %g1 + 0x29c ]
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
200c1dc: c4 26 20 40 st %g2, [ %i0 + 0x40 ]
200c1e0: 03 00 80 76 sethi %hi(0x201d800), %g1
200c1e4: f0 00 62 a0 ld [ %g1 + 0x2a0 ], %i0 ! 201daa0 <rtems_libio_semaphore>
200c1e8: 7f ff ed ee call 20079a0 <rtems_semaphore_release>
200c1ec: 81 e8 00 00 restore
0200386c <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
200386c: 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)
2003870: 03 00 80 73 sethi %hi(0x201cc00), %g1
2003874: fa 00 63 5c ld [ %g1 + 0x35c ], %i5 ! 201cf5c <rtems_libio_number_iops>
2003878: 80 a7 60 00 cmp %i5, 0
200387c: 02 80 00 1b be 20038e8 <rtems_libio_init+0x7c> <== NEVER TAKEN
2003880: 11 13 10 92 sethi %hi(0x4c424800), %o0
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
2003884: 90 10 00 1d mov %i5, %o0
2003888: 7f ff fe f4 call 2003458 <calloc>
200388c: 92 10 20 48 mov 0x48, %o1
2003890: 03 00 80 76 sethi %hi(0x201d800), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
2003894: 80 a2 20 00 cmp %o0, 0
2003898: 12 80 00 04 bne 20038a8 <rtems_libio_init+0x3c>
200389c: d0 20 62 98 st %o0, [ %g1 + 0x298 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
20038a0: 10 80 00 1c b 2003910 <rtems_libio_init+0xa4>
20038a4: 90 10 20 1a mov 0x1a, %o0
iop = rtems_libio_iop_freelist = rtems_libio_iops;
20038a8: 03 00 80 76 sethi %hi(0x201d800), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
20038ac: 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;
20038b0: d0 20 62 9c st %o0, [ %g1 + 0x29c ]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
20038b4: 10 80 00 03 b 20038c0 <rtems_libio_init+0x54>
20038b8: 82 10 20 00 clr %g1
iop->data1 = iop + 1;
20038bc: 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++)
20038c0: 82 00 60 01 inc %g1
20038c4: 80 a0 40 1d cmp %g1, %i5
20038c8: 12 bf ff fd bne 20038bc <rtems_libio_init+0x50>
20038cc: 84 00 a0 48 add %g2, 0x48, %g2
iop->data1 = iop + 1;
iop->data1 = NULL;
20038d0: 85 28 60 03 sll %g1, 3, %g2
20038d4: 83 28 60 06 sll %g1, 6, %g1
20038d8: 82 00 80 01 add %g2, %g1, %g1
20038dc: 90 02 00 01 add %o0, %g1, %o0
20038e0: c0 22 3f f8 clr [ %o0 + -8 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
20038e4: 11 13 10 92 sethi %hi(0x4c424800), %o0
20038e8: 92 10 20 01 mov 1, %o1
20038ec: 90 12 21 4f or %o0, 0x14f, %o0
20038f0: 94 10 20 54 mov 0x54, %o2
20038f4: 96 10 20 00 clr %o3
20038f8: 19 00 80 76 sethi %hi(0x201d800), %o4
20038fc: 40 00 0f 45 call 2007610 <rtems_semaphore_create>
2003900: 98 13 22 a0 or %o4, 0x2a0, %o4 ! 201daa0 <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
2003904: 80 a2 20 00 cmp %o0, 0
2003908: 02 80 00 04 be 2003918 <rtems_libio_init+0xac> <== ALWAYS TAKEN
200390c: 03 00 80 73 sethi %hi(0x201cc00), %g1
rtems_fatal_error_occurred( rc );
2003910: 40 00 11 9e call 2007f88 <rtems_fatal_error_occurred>
2003914: 01 00 00 00 nop
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
2003918: c2 00 63 60 ld [ %g1 + 0x360 ], %g1
200391c: 80 a0 60 00 cmp %g1, 0
2003920: 02 80 00 04 be 2003930 <rtems_libio_init+0xc4>
2003924: 01 00 00 00 nop
(* rtems_fs_init_helper)();
2003928: 9f c0 40 00 call %g1
200392c: 01 00 00 00 nop
2003930: 81 c7 e0 08 ret
2003934: 81 e8 00 00 restore
02028b44 <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
2028b44: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
2028b48: 7f ff 92 df call 200d6c4 <rtems_task_self>
2028b4c: 01 00 00 00 nop
rtems_user_env_t *old_env = rtems_current_user_env;
2028b50: 03 00 81 ac sethi %hi(0x206b000), %g1
2028b54: f8 00 60 d4 ld [ %g1 + 0xd4 ], %i4 ! 206b0d4 <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;
if (uses_global_env || uses_shared_env) {
2028b58: 05 00 81 ac sethi %hi(0x206b000), %g2
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
2028b5c: b6 10 00 08 mov %o0, %i3
rtems_user_env_t *old_env = 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;
if (uses_global_env || uses_shared_env) {
2028b60: 84 10 a0 d8 or %g2, 0xd8, %g2
2028b64: 80 a7 00 02 cmp %i4, %g2
2028b68: 02 80 00 05 be 2028b7c <rtems_libio_set_private_env+0x38>
2028b6c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
2028b70: 80 a0 40 08 cmp %g1, %o0
2028b74: 02 80 00 2b be 2028c20 <rtems_libio_set_private_env+0xdc>
2028b78: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
2028b7c: 90 10 20 01 mov 1, %o0
2028b80: 92 10 20 2c mov 0x2c, %o1
2028b84: 7f ff 7e 1f call 2008400 <calloc>
2028b88: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
2028b8c: 80 a2 20 00 cmp %o0, 0
2028b90: 02 80 00 24 be 2028c20 <rtems_libio_set_private_env+0xdc>
2028b94: ba 10 00 08 mov %o0, %i5
*new_env = *old_env;
2028b98: 92 10 00 1c mov %i4, %o1
2028b9c: 40 00 71 82 call 20451a4 <memcpy>
2028ba0: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
2028ba4: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
2028ba8: 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;
2028bac: 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);
2028bb0: 7f ff 86 9a call 200a618 <rtems_filesystem_global_location_obtain>
2028bb4: 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 =
2028bb8: 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);
2028bbc: 7f ff 86 97 call 200a618 <rtems_filesystem_global_location_obtain>
2028bc0: 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;
2028bc4: 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 =
2028bc8: d0 27 40 00 st %o0, [ %i5 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
2028bcc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2028bd0: 03 00 81 7d sethi %hi(0x205f400), %g1
2028bd4: 82 10 61 f4 or %g1, 0x1f4, %g1 ! 205f5f4 <rtems_filesystem_null_handlers>
2028bd8: 80 a0 80 01 cmp %g2, %g1
2028bdc: 02 80 00 14 be 2028c2c <rtems_libio_set_private_env+0xe8>
2028be0: 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)
2028be4: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
2028be8: 80 a0 80 01 cmp %g2, %g1
2028bec: 02 80 00 0f be 2028c28 <rtems_libio_set_private_env+0xe4> <== NEVER TAKEN
2028bf0: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
2028bf4: 37 00 81 ac sethi %hi(0x206b000), %i3
2028bf8: 15 00 80 a2 sethi %hi(0x2028800), %o2
2028bfc: 92 16 e0 d4 or %i3, 0xd4, %o1
2028c00: 40 00 07 73 call 202a9cc <rtems_task_variable_add>
2028c04: 94 12 a2 cc or %o2, 0x2cc, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
2028c08: b0 92 20 00 orcc %o0, 0, %i0
2028c0c: 32 80 00 08 bne,a 2028c2c <rtems_libio_set_private_env+0xe8>
2028c10: b0 10 20 05 mov 5, %i0
free_user_env_protected(old_env);
2028c14: 7f ff ff c1 call 2028b18 <free_user_env_protected>
2028c18: 90 10 00 1c mov %i4, %o0
rtems_current_user_env = new_env;
2028c1c: fa 26 e0 d4 st %i5, [ %i3 + 0xd4 ]
2028c20: 81 c7 e0 08 ret
2028c24: 81 e8 00 00 restore
2028c28: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
2028c2c: 7f ff ff a8 call 2028acc <free_user_env>
2028c30: 90 10 00 1d mov %i5, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
2028c34: 81 c7 e0 08 ret
2028c38: 81 e8 00 00 restore
02028c3c <rtems_libio_share_private_env>:
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
2028c3c: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
2028c40: 7f ff 92 a1 call 200d6c4 <rtems_task_self>
2028c44: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
2028c48: 80 a2 00 18 cmp %o0, %i0
2028c4c: 22 80 00 27 be,a 2028ce8 <rtems_libio_share_private_env+0xac>
2028c50: b0 10 20 00 clr %i0
2028c54: 80 a6 20 00 cmp %i0, 0
2028c58: 22 80 00 24 be,a 2028ce8 <rtems_libio_share_private_env+0xac>
2028c5c: 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++;
2028c60: 03 00 81 bc sethi %hi(0x206f000), %g1
2028c64: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 206f2c0 <_Thread_Dispatch_disable_level>
2028c68: 84 00 a0 01 inc %g2
2028c6c: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ]
return _Thread_Dispatch_disable_level;
2028c70: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %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(
2028c74: 13 00 81 ac sethi %hi(0x206b000), %o1
2028c78: 90 10 00 18 mov %i0, %o0
2028c7c: 92 12 60 d4 or %o1, 0xd4, %o1
2028c80: 40 00 07 a0 call 202ab00 <rtems_task_variable_get>
2028c84: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
2028c88: b0 92 20 00 orcc %o0, 0, %i0
2028c8c: 32 80 00 06 bne,a 2028ca4 <rtems_libio_share_private_env+0x68>
2028c90: b0 10 20 0d mov 0xd, %i0
++env->reference_count;
2028c94: c2 07 bf fc ld [ %fp + -4 ], %g1
2028c98: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
2028c9c: 84 00 a0 01 inc %g2
2028ca0: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
2028ca4: 7f ff 9c 6b call 200fe50 <_Thread_Enable_dispatch>
2028ca8: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
2028cac: 80 a6 20 00 cmp %i0, 0
2028cb0: 12 80 00 0e bne 2028ce8 <rtems_libio_share_private_env+0xac>
2028cb4: 90 10 20 00 clr %o0
sc = rtems_task_variable_add(
2028cb8: 3b 00 81 ac sethi %hi(0x206b000), %i5
2028cbc: 15 00 80 a2 sethi %hi(0x2028800), %o2
2028cc0: 92 17 60 d4 or %i5, 0xd4, %o1
2028cc4: 40 00 07 42 call 202a9cc <rtems_task_variable_add>
2028cc8: 94 12 a2 cc or %o2, 0x2cc, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
2028ccc: b0 92 20 00 orcc %o0, 0, %i0
2028cd0: 12 80 00 08 bne 2028cf0 <rtems_libio_share_private_env+0xb4><== NEVER TAKEN
2028cd4: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
2028cd8: 7f ff ff 90 call 2028b18 <free_user_env_protected>
2028cdc: d0 07 60 d4 ld [ %i5 + 0xd4 ], %o0
rtems_current_user_env = env;
2028ce0: c2 07 bf fc ld [ %fp + -4 ], %g1
2028ce4: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
2028ce8: 81 c7 e0 08 ret
2028cec: 81 e8 00 00 restore
} else {
free_user_env_protected(env);
2028cf0: 7f ff ff 8a call 2028b18 <free_user_env_protected> <== NOT EXECUTED
2028cf4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2028cf8: 81 c7 e0 08 ret <== NOT EXECUTED
2028cfc: 81 e8 00 00 restore <== NOT EXECUTED
0200c084 <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 ) {
200c084: 84 0a 20 06 and %o0, 6, %g2
200c088: 80 a0 a0 06 cmp %g2, 6
200c08c: 02 80 00 08 be 200c0ac <rtems_libio_to_fcntl_flags+0x28>
200c090: 82 10 20 02 mov 2, %g1
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
200c094: 80 8a 20 02 btst 2, %o0
200c098: 12 80 00 05 bne 200c0ac <rtems_libio_to_fcntl_flags+0x28> <== ALWAYS TAKEN
200c09c: 82 10 20 00 clr %g1
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
200c0a0: 82 0a 20 04 and %o0, 4, %g1 <== NOT EXECUTED
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
200c0a4: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
200c0a8: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
200c0ac: 80 8a 20 01 btst 1, %o0
200c0b0: 02 80 00 04 be 200c0c0 <rtems_libio_to_fcntl_flags+0x3c>
200c0b4: 80 8a 22 00 btst 0x200, %o0
fcntl_flags |= O_NONBLOCK;
200c0b8: 05 00 00 10 sethi %hi(0x4000), %g2
200c0bc: 82 10 40 02 or %g1, %g2, %g1
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
200c0c0: 32 80 00 02 bne,a 200c0c8 <rtems_libio_to_fcntl_flags+0x44>
200c0c4: 82 10 60 08 or %g1, 8, %g1
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
200c0c8: 80 8a 24 00 btst 0x400, %o0
200c0cc: 32 80 00 02 bne,a 200c0d4 <rtems_libio_to_fcntl_flags+0x50>
200c0d0: 82 10 62 00 or %g1, 0x200, %g1
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
200c0d4: 81 c3 e0 08 retl
200c0d8: 90 10 00 01 mov %g1, %o0
02028d00 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
2028d00: 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) {
2028d04: 3b 00 81 ac sethi %hi(0x206b000), %i5
2028d08: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1 ! 206b0d4 <rtems_current_user_env>
2028d0c: 39 00 81 ac sethi %hi(0x206b000), %i4
2028d10: b8 17 20 d8 or %i4, 0xd8, %i4 ! 206b0d8 <rtems_global_user_env>
2028d14: 80 a0 40 1c cmp %g1, %i4
2028d18: 02 80 00 0a be 2028d40 <rtems_libio_use_global_env+0x40>
2028d1c: 92 17 60 d4 or %i5, 0xd4, %o1
sc = rtems_task_variable_delete(
2028d20: 40 00 07 54 call 202aa70 <rtems_task_variable_delete>
2028d24: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
2028d28: 80 a2 20 00 cmp %o0, 0
2028d2c: 22 80 00 05 be,a 2028d40 <rtems_libio_use_global_env+0x40><== ALWAYS TAKEN
2028d30: f8 27 60 d4 st %i4, [ %i5 + 0xd4 ]
rtems_fatal_error_occurred(0xdeadbeef);
2028d34: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
2028d38: 7f ff 93 0f call 200d974 <rtems_fatal_error_occurred> <== NOT EXECUTED
2028d3c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2028d40: 81 c7 e0 08 ret
2028d44: 81 e8 00 00 restore
02008e70 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
2008e70: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
2008e74: 03 00 81 ab sethi %hi(0x206ac00), %g1
2008e78: d0 00 63 7c ld [ %g1 + 0x37c ], %o0 ! 206af7c <RTEMS_Malloc_Heap>
2008e7c: 92 10 00 18 mov %i0, %o1
2008e80: 40 00 18 e3 call 200f20c <_Protected_heap_Get_block_size>
2008e84: 94 07 bf fc add %fp, -4, %o2
2008e88: 80 8a 20 ff btst 0xff, %o0
2008e8c: 02 80 00 08 be 2008eac <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
2008e90: c4 07 bf fc ld [ %fp + -4 ], %g2
MSBUMP(lifetime_freed, size);
2008e94: 03 00 81 bc sethi %hi(0x206f000), %g1
2008e98: 82 10 61 60 or %g1, 0x160, %g1 ! 206f160 <rtems_malloc_statistics>
2008e9c: d8 18 60 28 ldd [ %g1 + 0x28 ], %o4
2008ea0: 86 83 40 02 addcc %o5, %g2, %g3
2008ea4: 84 43 20 00 addx %o4, 0, %g2
2008ea8: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
2008eac: 81 c7 e0 08 ret
2008eb0: 81 e8 00 00 restore
02008eb4 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
2008eb4: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t actual_size = 0;
2008eb8: c0 27 bf fc clr [ %fp + -4 ]
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
2008ebc: 80 a6 20 00 cmp %i0, 0
2008ec0: 02 80 00 13 be 2008f0c <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
2008ec4: 92 10 00 18 mov %i0, %o1
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
2008ec8: 03 00 81 ab sethi %hi(0x206ac00), %g1
2008ecc: d0 00 63 7c ld [ %g1 + 0x37c ], %o0 ! 206af7c <RTEMS_Malloc_Heap>
2008ed0: 40 00 18 cf call 200f20c <_Protected_heap_Get_block_size>
2008ed4: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
2008ed8: c4 07 bf fc ld [ %fp + -4 ], %g2
2008edc: 03 00 81 bc sethi %hi(0x206f000), %g1
2008ee0: 82 10 61 60 or %g1, 0x160, %g1 ! 206f160 <rtems_malloc_statistics>
2008ee4: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
2008ee8: 86 83 40 02 addcc %o5, %g2, %g3
2008eec: 84 43 20 00 addx %o4, 0, %g2
2008ef0: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
2008ef4: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
2008ef8: 84 20 c0 02 sub %g3, %g2, %g2
if (current_depth > s->max_depth)
2008efc: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2008f00: 80 a0 80 03 cmp %g2, %g3
2008f04: 38 80 00 02 bgu,a 2008f0c <rtems_malloc_statistics_at_malloc+0x58>
2008f08: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
2008f0c: 81 c7 e0 08 ret
2008f10: 81 e8 00 00 restore
0200ff48 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
200ff48: 9d e3 bf a0 save %sp, -96, %sp
200ff4c: ba 10 00 18 mov %i0, %i5
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
200ff50: 80 a7 60 00 cmp %i5, 0
200ff54: 02 80 00 21 be 200ffd8 <rtems_memalign+0x90>
200ff58: b0 10 20 16 mov 0x16, %i0
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
200ff5c: 03 00 80 86 sethi %hi(0x2021800), %g1
200ff60: c2 00 62 88 ld [ %g1 + 0x288 ], %g1 ! 2021a88 <_System_state_Current>
200ff64: 80 a0 60 03 cmp %g1, 3
200ff68: 12 80 00 07 bne 200ff84 <rtems_memalign+0x3c>
200ff6c: c0 27 40 00 clr [ %i5 ]
!malloc_is_system_state_OK() )
200ff70: 7f ff d3 b2 call 2004e38 <malloc_is_system_state_OK>
200ff74: 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()) &&
200ff78: 80 8a 20 ff btst 0xff, %o0
200ff7c: 02 80 00 17 be 200ffd8 <rtems_memalign+0x90> <== NEVER TAKEN
200ff80: 01 00 00 00 nop
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
200ff84: 7f ff d3 bf call 2004e80 <malloc_deferred_frees_process>
200ff88: b0 10 20 0c mov 0xc, %i0 ! c <PROM_START+0xc>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
200ff8c: 03 00 80 82 sethi %hi(0x2020800), %g1
200ff90: d0 00 63 90 ld [ %g1 + 0x390 ], %o0 ! 2020b90 <RTEMS_Malloc_Heap>
200ff94: 94 10 00 19 mov %i1, %o2
200ff98: 92 10 00 1a mov %i2, %o1
200ff9c: 7f ff ea 9e call 200aa14 <_Protected_heap_Allocate_aligned_with_boundary>
200ffa0: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
200ffa4: 80 a2 20 00 cmp %o0, 0
200ffa8: 02 80 00 0c be 200ffd8 <rtems_memalign+0x90>
200ffac: b2 10 00 08 mov %o0, %i1
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
200ffb0: 03 00 80 84 sethi %hi(0x2021000), %g1
200ffb4: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 2021374 <rtems_malloc_statistics_helpers>
200ffb8: 80 a0 60 00 cmp %g1, 0
200ffbc: 22 80 00 06 be,a 200ffd4 <rtems_memalign+0x8c>
200ffc0: f2 27 40 00 st %i1, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
200ffc4: c2 00 60 04 ld [ %g1 + 4 ], %g1
200ffc8: 9f c0 40 00 call %g1
200ffcc: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
200ffd0: f2 27 40 00 st %i1, [ %i5 ]
return 0;
200ffd4: b0 10 20 00 clr %i0
}
200ffd8: 81 c7 e0 08 ret
200ffdc: 81 e8 00 00 restore
02009c28 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
2009c28: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
2009c2c: 90 10 00 18 mov %i0, %o0
2009c30: 40 00 fa 7a call 2048618 <strdup>
2009c34: b0 10 3f ff mov -1, %i0
if (dup_path != NULL) {
2009c38: 80 a2 20 00 cmp %o0, 0
2009c3c: 02 80 00 6b be 2009de8 <rtems_mkdir+0x1c0> <== NEVER TAKEN
2009c40: b6 10 00 08 mov %o0, %i3
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009c44: c2 4a 00 00 ldsb [ %o0 ], %g1
2009c48: b8 10 20 01 mov 1, %i4
++p;
2009c4c: 82 18 60 2f xor %g1, 0x2f, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009c50: b0 10 20 00 clr %i0
++p;
2009c54: 80 a0 00 01 cmp %g0, %g1
retval = 0;
break;
}
}
if (!last)
*p = '/';
2009c58: a4 10 20 2f mov 0x2f, %l2
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
2009c5c: b4 62 3f ff subx %o0, -1, %i2
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009c60: 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)) {
2009c64: 23 00 00 3c sethi %hi(0xf000), %l1
2009c68: 21 00 00 10 sethi %hi(0x4000), %l0
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
2009c6c: c6 4e 80 00 ldsb [ %i2 ], %g3
2009c70: 80 a0 e0 00 cmp %g3, 0
2009c74: 02 80 00 05 be 2009c88 <rtems_mkdir+0x60>
2009c78: 84 10 20 01 mov 1, %g2
last = 1;
else if (p[0] != '/')
2009c7c: 80 a0 e0 2f cmp %g3, 0x2f
2009c80: 12 80 00 4a bne 2009da8 <rtems_mkdir+0x180>
2009c84: 84 10 20 00 clr %g2
continue;
*p = '\0';
2009c88: c0 2e 80 00 clrb [ %i2 ]
if (!last && p[1] == '\0')
2009c8c: 80 a0 a0 00 cmp %g2, 0
2009c90: 12 80 00 05 bne 2009ca4 <rtems_mkdir+0x7c>
2009c94: ba 10 20 01 mov 1, %i5
2009c98: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2
2009c9c: 80 a0 00 02 cmp %g0, %g2
2009ca0: ba 60 3f ff subx %g0, -1, %i5
last = 1;
if (first) {
2009ca4: 80 a0 60 00 cmp %g1, 0
2009ca8: 02 80 00 08 be 2009cc8 <rtems_mkdir+0xa0>
2009cac: 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);
2009cb0: 40 00 09 f8 call 200c490 <umask>
2009cb4: 90 10 20 00 clr %o0
2009cb8: b0 10 00 08 mov %o0, %i0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
2009cbc: 40 00 09 f5 call 200c490 <umask>
2009cc0: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
2009cc4: 80 a7 60 00 cmp %i5, 0
2009cc8: 02 80 00 05 be 2009cdc <rtems_mkdir+0xb4>
2009ccc: 92 10 21 ff mov 0x1ff, %o1
(void)umask(oumask);
2009cd0: 40 00 09 f0 call 200c490 <umask>
2009cd4: 90 10 00 18 mov %i0, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
2009cd8: 92 10 00 19 mov %i1, %o1
2009cdc: 7f ff fc 95 call 2008f30 <mkdir>
2009ce0: 90 10 00 1b mov %i3, %o0
2009ce4: 80 a2 20 00 cmp %o0, 0
2009ce8: 16 80 00 28 bge 2009d88 <rtems_mkdir+0x160>
2009cec: 84 10 20 01 mov 1, %g2
if (errno == EEXIST || errno == EISDIR) {
2009cf0: 40 00 df ec call 2041ca0 <__errno>
2009cf4: 01 00 00 00 nop
2009cf8: c2 02 00 00 ld [ %o0 ], %g1
2009cfc: 80 a0 60 11 cmp %g1, 0x11
2009d00: 02 80 00 08 be 2009d20 <rtems_mkdir+0xf8>
2009d04: 90 10 00 1b mov %i3, %o0
2009d08: 40 00 df e6 call 2041ca0 <__errno>
2009d0c: 01 00 00 00 nop
2009d10: c2 02 00 00 ld [ %o0 ], %g1
2009d14: 80 a0 60 15 cmp %g1, 0x15
2009d18: 12 80 00 29 bne 2009dbc <rtems_mkdir+0x194> <== ALWAYS TAKEN
2009d1c: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
2009d20: 40 00 00 39 call 2009e04 <stat>
2009d24: 92 07 bf b8 add %fp, -72, %o1
2009d28: 80 a2 20 00 cmp %o0, 0
2009d2c: 06 80 00 24 bl 2009dbc <rtems_mkdir+0x194> <== NEVER TAKEN
2009d30: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
2009d34: 82 08 40 11 and %g1, %l1, %g1
2009d38: 80 a0 40 10 cmp %g1, %l0
2009d3c: 02 80 00 0f be 2009d78 <rtems_mkdir+0x150>
2009d40: 80 a7 60 00 cmp %i5, 0
if (last)
2009d44: 02 80 00 08 be 2009d64 <rtems_mkdir+0x13c>
2009d48: 01 00 00 00 nop
errno = EEXIST;
2009d4c: 40 00 df d5 call 2041ca0 <__errno>
2009d50: b8 10 20 00 clr %i4 ! 0 <PROM_START>
2009d54: 82 10 20 11 mov 0x11, %g1
2009d58: c2 22 00 00 st %g1, [ %o0 ]
2009d5c: 10 80 00 19 b 2009dc0 <rtems_mkdir+0x198>
2009d60: ba 10 20 01 mov 1, %i5
else
errno = ENOTDIR;
2009d64: 40 00 df cf call 2041ca0 <__errno>
2009d68: b8 10 20 00 clr %i4
2009d6c: 82 10 20 14 mov 0x14, %g1
2009d70: 10 80 00 14 b 2009dc0 <rtems_mkdir+0x198>
2009d74: c2 22 00 00 st %g1, [ %o0 ]
retval = 0;
break;
}
if (last)
2009d78: 32 80 00 0a bne,a 2009da0 <rtems_mkdir+0x178>
2009d7c: b8 10 20 02 mov 2, %i4
retval = 0;
break;
}
}
if (!last)
*p = '/';
2009d80: 10 80 00 06 b 2009d98 <rtems_mkdir+0x170>
2009d84: e4 2e 80 00 stb %l2, [ %i2 ]
} else {
retval = 0;
break;
}
}
if (!last)
2009d88: 80 a7 60 00 cmp %i5, 0
2009d8c: 12 80 00 07 bne 2009da8 <rtems_mkdir+0x180>
2009d90: 82 10 20 00 clr %g1
*p = '/';
2009d94: e4 2e 80 00 stb %l2, [ %i2 ]
2009d98: 10 80 00 03 b 2009da4 <rtems_mkdir+0x17c>
2009d9c: 84 10 20 00 clr %g2
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
2009da0: 84 10 20 01 mov 1, %g2
2009da4: 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) {
2009da8: 80 a0 a0 00 cmp %g2, 0
2009dac: 02 bf ff b0 be 2009c6c <rtems_mkdir+0x44>
2009db0: b4 06 a0 01 inc %i2
2009db4: 10 80 00 04 b 2009dc4 <rtems_mkdir+0x19c>
2009db8: 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) {
retval = 0;
2009dbc: b8 10 20 00 clr %i4
}
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) {
2009dc0: 82 10 20 00 clr %g1
}
}
if (!last)
*p = '/';
}
if (!first && !last)
2009dc4: 80 97 40 01 orcc %i5, %g1, %g0
2009dc8: 12 80 00 04 bne 2009dd8 <rtems_mkdir+0x1b0>
2009dcc: 01 00 00 00 nop
(void)umask(oumask);
2009dd0: 40 00 09 b0 call 200c490 <umask>
2009dd4: 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);
2009dd8: 7f ff fa 68 call 2008778 <free>
2009ddc: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
2009de0: 80 a0 00 1c cmp %g0, %i4
2009de4: b0 40 3f ff addx %g0, -1, %i0
}
2009de8: 81 c7 e0 08 ret
2009dec: 81 e8 00 00 restore
020206c4 <rtems_nvdisk_device_read>:
rtems_nvdisk_device_read (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t offset,
void* buffer,
uint32_t size)
{
20206c4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
20206c8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
20206cc: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED
20206d0: 83 2e 60 04 sll %i1, 4, %g1 <== NOT EXECUTED
20206d4: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
20206d8: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
20206dc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED
rtems_nvdisk_device_read (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t offset,
void* buffer,
uint32_t size)
{
20206e0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-read: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->read (device, dd->flags, dd->base, offset, buffer, size);
20206e4: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 <== NOT EXECUTED
20206e8: d2 00 80 00 ld [ %g2 ], %o1 <== NOT EXECUTED
20206ec: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
20206f0: d4 00 a0 04 ld [ %g2 + 4 ], %o2 <== NOT EXECUTED
20206f4: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
20206f8: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
20206fc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2020700: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
2020704: 81 c7 e0 08 ret <== NOT EXECUTED
2020708: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0202070c <rtems_nvdisk_device_write>:
rtems_nvdisk_device_write (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t offset,
const void* buffer,
uint32_t size)
{
202070c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
2020710: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
2020714: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED
2020718: 83 2e 60 04 sll %i1, 4, %g1 <== NOT EXECUTED
202071c: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
2020720: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
2020724: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED
rtems_nvdisk_device_write (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t offset,
const void* buffer,
uint32_t size)
{
2020728: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
202072c: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 <== NOT EXECUTED
2020730: d2 00 80 00 ld [ %g2 ], %o1 <== NOT EXECUTED
2020734: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
2020738: d4 00 a0 04 ld [ %g2 + 4 ], %o2 <== NOT EXECUTED
202073c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
2020740: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
2020744: 9f c0 40 00 call %g1 <== NOT EXECUTED
2020748: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
202074c: 81 c7 e0 08 ret <== NOT EXECUTED
2020750: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02020754 <rtems_nvdisk_error>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_nvdisk_error (const char *format, ...)
{
2020754: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
2020758: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
202075c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
2020760: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "nvdisk:error:");
2020764: 3b 00 81 ae sethi %hi(0x206b800), %i5 <== NOT EXECUTED
2020768: c2 07 61 68 ld [ %i5 + 0x168 ], %g1 ! 206b968 <_impure_ptr><== NOT EXECUTED
static int
rtems_nvdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
202076c: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2020770: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2020774: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2020778: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "nvdisk:error:");
202077c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2020780: 11 00 81 89 sethi %hi(0x2062400), %o0 <== NOT EXECUTED
2020784: 40 00 88 62 call 204290c <fputs> <== NOT EXECUTED
2020788: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 20627a0 <msdos_ops+0x58> <== NOT EXECUTED
ret = vfprintf (stderr, format, args);
202078c: c2 07 61 68 ld [ %i5 + 0x168 ], %g1 <== NOT EXECUTED
2020790: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2020794: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2020798: 40 00 c9 f2 call 2052f60 <vfprintf> <== NOT EXECUTED
202079c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
20207a0: c2 07 61 68 ld [ %i5 + 0x168 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "nvdisk:error:");
ret = vfprintf (stderr, format, args);
20207a4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
20207a8: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
20207ac: 40 00 88 23 call 2042838 <fputc> <== NOT EXECUTED
20207b0: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
20207b4: c2 07 61 68 ld [ %i5 + 0x168 ], %g1 <== NOT EXECUTED
20207b8: 40 00 86 4a call 20420e0 <fflush> <== NOT EXECUTED
20207bc: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
20207c0: 81 c7 e0 08 ret <== NOT EXECUTED
20207c4: 81 e8 00 00 restore <== NOT EXECUTED
020207c8 <rtems_nvdisk_get_device>:
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
20207c8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
20207cc: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
20207d0: 82 10 00 18 mov %i0, %g1 <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
20207d4: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED
20207d8: 1a 80 00 06 bcc 20207f0 <rtems_nvdisk_get_device+0x28> <== NOT EXECUTED
20207dc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
20207e0: de 06 20 18 ld [ %i0 + 0x18 ], %o7 <== NOT EXECUTED
20207e4: 86 10 20 00 clr %g3 <== NOT EXECUTED
20207e8: 10 80 00 15 b 202083c <rtems_nvdisk_get_device+0x74> <== NOT EXECUTED
20207ec: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
uint32_t device;
if (block >= nvd->block_count)
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
20207f0: 11 00 81 89 sethi %hi(0x2062400), %o0 <== NOT EXECUTED
20207f4: b0 10 20 00 clr %i0 <== NOT EXECUTED
20207f8: 7f ff ff d7 call 2020754 <rtems_nvdisk_error> <== NOT EXECUTED
20207fc: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED
2020800: 81 c7 e0 08 ret <== NOT EXECUTED
2020804: 81 e8 00 00 restore <== NOT EXECUTED
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
2020808: b0 06 00 03 add %i0, %g3, %i0 <== NOT EXECUTED
if ((block >= dc->block_base) &&
202080c: c8 06 20 0c ld [ %i0 + 0xc ], %g4 <== NOT EXECUTED
2020810: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
2020814: 0a 80 00 09 bcs 2020838 <rtems_nvdisk_get_device+0x70> <== NOT EXECUTED
2020818: 84 00 a0 01 inc %g2 <== NOT EXECUTED
(block < (dc->block_base + dc->pages - dc->pages_desc)))
202081c: da 06 20 04 ld [ %i0 + 4 ], %o5 <== NOT EXECUTED
2020820: 88 01 00 0d add %g4, %o5, %g4 <== NOT EXECUTED
2020824: da 06 20 08 ld [ %i0 + 8 ], %o5 <== NOT EXECUTED
2020828: 88 21 00 0d sub %g4, %o5, %g4 <== NOT EXECUTED
}
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
if ((block >= dc->block_base) &&
202082c: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
2020830: 0a 80 00 0a bcs 2020858 <rtems_nvdisk_get_device+0x90> <== NOT EXECUTED
2020834: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
2020838: 86 00 e0 14 add %g3, 0x14, %g3 <== NOT EXECUTED
202083c: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
2020840: 32 bf ff f2 bne,a 2020808 <rtems_nvdisk_get_device+0x40> <== NOT EXECUTED
2020844: f0 00 60 14 ld [ %g1 + 0x14 ], %i0 <== NOT EXECUTED
if ((block >= dc->block_base) &&
(block < (dc->block_base + dc->pages - dc->pages_desc)))
return dc;
}
rtems_nvdisk_error ("map-block:%d: no device/page map found", block);
2020848: 11 00 81 89 sethi %hi(0x2062400), %o0 <== NOT EXECUTED
return NULL;
202084c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ((block >= dc->block_base) &&
(block < (dc->block_base + dc->pages - dc->pages_desc)))
return dc;
}
rtems_nvdisk_error ("map-block:%d: no device/page map found", block);
2020850: 7f ff ff c1 call 2020754 <rtems_nvdisk_error> <== NOT EXECUTED
2020854: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
return NULL;
}
2020858: 81 c7 e0 08 ret <== NOT EXECUTED
202085c: 81 e8 00 00 restore <== NOT EXECUTED
02020d74 <rtems_nvdisk_initialize>:
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
2020d74: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
const rtems_nvdisk_config* c = rtems_nvdisk_configuration;
rtems_nvdisk* nvd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
2020d78: 7f ff 9b 28 call 2007a18 <rtems_disk_io_initialize> <== NOT EXECUTED
2020d7c: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2020d80: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2020d84: 12 80 00 80 bne 2020f84 <rtems_nvdisk_initialize+0x210> <== NOT EXECUTED
2020d88: 01 00 00 00 nop <== NOT EXECUTED
static rtems_status_code
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
2020d8c: 7f ff 9f fb call 2008d78 <malloc> <== NOT EXECUTED
2020d90: 90 10 22 00 mov 0x200, %o0 ! 200 <PROM_START+0x200> <== NOT EXECUTED
2020d94: 03 00 81 ba sethi %hi(0x206e800), %g1 <== NOT EXECUTED
2020d98: d0 20 63 44 st %o0, [ %g1 + 0x344 ] ! 206eb44 <rtems_nvdisk_crc16_factor><== NOT EXECUTED
if (!rtems_nvdisk_crc16_factor)
2020d9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020da0: 02 80 00 6c be 2020f50 <rtems_nvdisk_initialize+0x1dc> <== NOT EXECUTED
2020da4: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2020da8: 09 3f ff e1 sethi %hi(0xffff8400), %g4 <== NOT EXECUTED
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
2020dac: 82 10 20 00 clr %g1 <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2020db0: 88 11 20 08 or %g4, 8, %g4 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
2020db4: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED
2020db8: 10 80 00 06 b 2020dd0 <rtems_nvdisk_initialize+0x5c> <== NOT EXECUTED
2020dbc: 86 10 20 09 mov 9, %g3 <== NOT EXECUTED
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2020dc0: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
2020dc4: 02 80 00 03 be 2020dd0 <rtems_nvdisk_initialize+0x5c> <== NOT EXECUTED
2020dc8: 85 37 60 11 srl %i5, 0x11, %g2 <== NOT EXECUTED
2020dcc: 84 18 80 04 xor %g2, %g4, %g2 <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
2020dd0: 86 80 ff ff addcc %g3, -1, %g3 <== NOT EXECUTED
2020dd4: 32 bf ff fb bne,a 2020dc0 <rtems_nvdisk_initialize+0x4c> <== NOT EXECUTED
2020dd8: bb 28 a0 10 sll %g2, 0x10, %i5 <== NOT EXECUTED
* @param major NV disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
2020ddc: 87 28 60 01 sll %g1, 1, %g3 <== NOT EXECUTED
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
2020de0: 82 00 60 01 inc %g1 <== NOT EXECUTED
2020de4: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
2020de8: 12 bf ff f3 bne 2020db4 <rtems_nvdisk_initialize+0x40> <== NOT EXECUTED
2020dec: c4 32 00 03 sth %g2, [ %o0 + %g3 ] <== NOT EXECUTED
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
2020df0: 10 80 00 67 b 2020f8c <rtems_nvdisk_initialize+0x218> <== NOT EXECUTED
2020df4: 27 00 81 ab sethi %hi(0x206ac00), %l3 <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
2020df8: 03 00 81 ba sethi %hi(0x206e800), %g1 <== NOT EXECUTED
2020dfc: c2 00 63 48 ld [ %g1 + 0x348 ], %g1 ! 206eb48 <rtems_nvdisks><== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
2020e00: f6 2f bf f9 stb %i3, [ %fp + -7 ] <== NOT EXECUTED
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
2020e04: 05 0b d9 19 sethi %hi(0x2f646400), %g2 <== NOT EXECUTED
2020e08: 07 0b db 9d sethi %hi(0x2f6e7400), %g3 <== NOT EXECUTED
2020e0c: 84 10 a1 76 or %g2, 0x176, %g2 <== NOT EXECUTED
2020e10: 86 10 e2 64 or %g3, 0x264, %g3 <== NOT EXECUTED
2020e14: c4 3f bf f0 std %g2, [ %fp + -16 ] <== NOT EXECUTED
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
2020e18: ba 00 40 1a add %g1, %i2, %i5 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
nvd->major = major;
2020e1c: f2 20 40 1a st %i1, [ %g1 + %i2 ] <== NOT EXECUTED
nvd->minor = minor;
nvd->flags = c->flags;
2020e20: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED
nvd->block_size = c->block_size;
2020e24: ee 07 00 00 ld [ %i4 ], %l7 <== NOT EXECUTED
nvd->info_level = c->info_level;
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
2020e28: c6 07 20 04 ld [ %i4 + 4 ], %g3 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
nvd->major = major;
nvd->minor = minor;
nvd->flags = c->flags;
2020e2c: c2 27 60 08 st %g1, [ %i5 + 8 ] <== NOT EXECUTED
nvd->block_size = c->block_size;
nvd->info_level = c->info_level;
2020e30: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 <== NOT EXECUTED
nvd = &rtems_nvdisks[minor];
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
nvd->major = major;
nvd->minor = minor;
2020e34: f6 27 60 04 st %i3, [ %i5 + 4 ] <== NOT EXECUTED
nvd->flags = c->flags;
nvd->block_size = c->block_size;
2020e38: ee 27 60 0c st %l7, [ %i5 + 0xc ] <== NOT EXECUTED
nvd->info_level = c->info_level;
2020e3c: c2 27 60 24 st %g1, [ %i5 + 0x24 ] <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
2020e40: c6 27 bf ec st %g3, [ %fp + -20 ] <== NOT EXECUTED
2020e44: 90 10 00 03 mov %g3, %o0 <== NOT EXECUTED
2020e48: 7f ff 9d 6e call 2008400 <calloc> <== NOT EXECUTED
2020e4c: 92 10 20 14 mov 0x14, %o1 <== NOT EXECUTED
if (!nvd->devices)
2020e50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020e54: 02 80 00 4b be 2020f80 <rtems_nvdisk_initialize+0x20c> <== NOT EXECUTED
2020e58: d0 27 60 14 st %o0, [ %i5 + 0x14 ] <== NOT EXECUTED
2020e5c: aa 10 00 08 mov %o0, %l5 <== NOT EXECUTED
2020e60: b0 10 20 00 clr %i0 <== NOT EXECUTED
2020e64: 10 80 00 1a b 2020ecc <rtems_nvdisk_initialize+0x158> <== NOT EXECUTED
2020e68: ac 10 20 00 clr %l6 <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
2020e6c: 83 2d a0 04 sll %l6, 4, %g1 <== NOT EXECUTED
2020e70: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_pages_in_device (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
return dd->size / nvd->block_size;
2020e74: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
2020e78: ec 25 40 00 st %l6, [ %l5 ] <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_pages_in_device (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
return dd->size / nvd->block_size;
2020e7c: c4 27 bf e4 st %g2, [ %fp + -28 ] <== NOT EXECUTED
2020e80: 40 00 e9 74 call 205b450 <.udiv> <== NOT EXECUTED
2020e84: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
2020e88: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
2020e8c: d0 25 60 04 st %o0, [ %l5 + 4 ] <== NOT EXECUTED
rtems_nvdisk_page_desc_pages (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);
uint32_t bytes = pages * sizeof (uint16_t);
return ((bytes - 1) / nvd->block_size) + 1;
2020e90: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED
static uint32_t
rtems_nvdisk_page_desc_pages (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);
uint32_t bytes = pages * sizeof (uint16_t);
2020e94: 91 2a 20 01 sll %o0, 1, %o0 <== NOT EXECUTED
return ((bytes - 1) / nvd->block_size) + 1;
2020e98: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
2020e9c: 40 00 e9 6d call 205b450 <.udiv> <== NOT EXECUTED
2020ea0: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
2020ea4: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED
dc->descriptor = &c->devices[device];
2020ea8: c4 07 bf e4 ld [ %fp + -28 ], %g2 <== NOT EXECUTED
rtems_nvdisk_page_desc_pages (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);
uint32_t bytes = pages * sizeof (uint16_t);
return ((bytes - 1) / nvd->block_size) + 1;
2020eac: 90 02 20 01 inc %o0 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
2020eb0: f0 25 60 0c st %i0, [ %l5 + 0xc ] <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
2020eb4: d0 25 60 08 st %o0, [ %l5 + 8 ] <== NOT EXECUTED
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
2020eb8: 82 20 40 08 sub %g1, %o0, %g1 <== NOT EXECUTED
dc->descriptor = &c->devices[device];
2020ebc: c4 25 60 10 st %g2, [ %l5 + 0x10 ] <== NOT EXECUTED
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
2020ec0: b0 06 00 01 add %i0, %g1, %i0 <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
2020ec4: ac 05 a0 01 inc %l6 <== NOT EXECUTED
2020ec8: aa 05 60 14 add %l5, 0x14, %l5 <== NOT EXECUTED
2020ecc: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED
2020ed0: 80 a5 80 01 cmp %l6, %g1 <== NOT EXECUTED
2020ed4: 32 bf ff e6 bne,a 2020e6c <rtems_nvdisk_initialize+0xf8> <== NOT EXECUTED
2020ed8: c4 07 20 08 ld [ %i4 + 8 ], %g2 <== NOT EXECUTED
blocks += dc->pages - dc->pages_desc;
dc->descriptor = &c->devices[device];
}
nvd->block_count = blocks;
2020edc: f0 27 60 10 st %i0, [ %i5 + 0x10 ] <== NOT EXECUTED
nvd->device_count = c->device_count;
2020ee0: ec 27 60 18 st %l6, [ %i5 + 0x18 ] <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
2020ee4: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
2020ee8: e2 23 a0 5c st %l1, [ %sp + 0x5c ] <== NOT EXECUTED
2020eec: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2020ef0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2020ef4: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
2020ef8: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
2020efc: 7f ff 99 8b call 2007528 <rtems_disk_create_phys> <== NOT EXECUTED
2020f00: 9a 10 20 00 clr %o5 <== NOT EXECUTED
rtems_nvdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
2020f04: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2020f08: 22 80 00 05 be,a 2020f1c <rtems_nvdisk_initialize+0x1a8> <== NOT EXECUTED
2020f0c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk create phy failed");
2020f10: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2020f14: 10 80 00 0d b 2020f48 <rtems_nvdisk_initialize+0x1d4> <== NOT EXECUTED
2020f18: 90 12 20 30 or %o0, 0x30, %o0 ! 2062830 <msdos_ops+0xe8> <== NOT EXECUTED
return sc;
}
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
2020f1c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2020f20: 94 10 20 54 mov 0x54, %o2 <== NOT EXECUTED
2020f24: 96 10 20 00 clr %o3 <== NOT EXECUTED
2020f28: 98 07 60 20 add %i5, 0x20, %o4 <== NOT EXECUTED
2020f2c: 7f ff af d0 call 200ce6c <rtems_semaphore_create> <== NOT EXECUTED
2020f30: b4 06 a0 28 add %i2, 0x28, %i2 <== NOT EXECUTED
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
if (sc != RTEMS_SUCCESSFUL)
2020f34: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020f38: 02 80 00 08 be 2020f58 <rtems_nvdisk_initialize+0x1e4> <== NOT EXECUTED
2020f3c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk lock create failed");
2020f40: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2020f44: 90 12 20 48 or %o0, 0x48, %o0 ! 2062848 <msdos_ops+0x100> <== NOT EXECUTED
2020f48: 7f ff fe 03 call 2020754 <rtems_nvdisk_error> <== NOT EXECUTED
2020f4c: 01 00 00 00 nop <== NOT EXECUTED
return sc;
2020f50: 81 c7 e0 08 ret <== NOT EXECUTED
2020f54: 81 e8 00 00 restore <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
2020f58: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2020f5c: b8 07 20 14 add %i4, 0x14, %i4 <== NOT EXECUTED
2020f60: c2 04 e2 2c ld [ %l3 + 0x22c ], %g1 <== NOT EXECUTED
2020f64: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2020f68: 2a bf ff a4 bcs,a 2020df8 <rtems_nvdisk_initialize+0x84> <== NOT EXECUTED
2020f6c: e4 37 bf f8 sth %l2, [ %fp + -8 ] <== NOT EXECUTED
rtems_nvdisk_error ("disk lock create failed");
return sc;
}
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
2020f70: 05 00 81 ba sethi %hi(0x206e800), %g2 <== NOT EXECUTED
2020f74: c2 20 a3 4c st %g1, [ %g2 + 0x34c ] ! 206eb4c <rtems_nvdisk_count><== NOT EXECUTED
return RTEMS_SUCCESSFUL;
2020f78: 81 c7 e0 08 ret <== NOT EXECUTED
2020f7c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
nvd->block_size = c->block_size;
nvd->info_level = c->info_level;
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
2020f80: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
2020f84: 81 c7 e0 08 ret <== NOT EXECUTED
2020f88: 81 e8 00 00 restore <== NOT EXECUTED
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
2020f8c: d0 04 e2 2c ld [ %l3 + 0x22c ], %o0 <== NOT EXECUTED
2020f90: 7f ff 9d 1c call 2008400 <calloc> <== NOT EXECUTED
2020f94: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED
2020f98: 03 00 81 ba sethi %hi(0x206e800), %g1 <== NOT EXECUTED
2020f9c: d0 20 63 48 st %o0, [ %g1 + 0x348 ] ! 206eb48 <rtems_nvdisks><== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
2020fa0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020fa4: 02 bf ff eb be 2020f50 <rtems_nvdisk_initialize+0x1dc> <== NOT EXECUTED
2020fa8: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
2020fac: 39 00 81 79 sethi %hi(0x205e400), %i4 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
2020fb0: 25 00 00 18 sethi %hi(0x6000), %l2 <== NOT EXECUTED
}
nvd->block_count = blocks;
nvd->device_count = c->device_count;
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
2020fb4: 21 00 80 82 sethi %hi(0x2020800), %l0 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk create phy failed");
return sc;
}
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
2020fb8: 29 13 95 91 sethi %hi(0x4e564400), %l4 <== NOT EXECUTED
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
2020fbc: b4 10 20 00 clr %i2 <== NOT EXECUTED
2020fc0: b8 17 22 e8 or %i4, 0x2e8, %i4 <== NOT EXECUTED
2020fc4: b6 10 20 00 clr %i3 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
2020fc8: a4 14 a1 00 or %l2, 0x100, %l2 <== NOT EXECUTED
nvd->block_count = blocks;
nvd->device_count = c->device_count;
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
rtems_nvdisk_ioctl, NULL, name);
2020fcc: a2 07 bf f0 add %fp, -16, %l1 <== NOT EXECUTED
}
nvd->block_count = blocks;
nvd->device_count = c->device_count;
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
2020fd0: a0 14 20 60 or %l0, 0x60, %l0 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk create phy failed");
return sc;
}
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
2020fd4: 10 bf ff e3 b 2020f60 <rtems_nvdisk_initialize+0x1ec> <== NOT EXECUTED
2020fd8: a8 15 20 4b or %l4, 0x4b, %l4 <== NOT EXECUTED
02020860 <rtems_nvdisk_ioctl>:
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
2020860: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
if (minor >= rtems_nvdisk_count)
2020864: 05 00 81 ba sethi %hi(0x206e800), %g2 <== NOT EXECUTED
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
2020868: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
202086c: c4 00 a3 4c ld [ %g2 + 0x34c ], %g2 <== NOT EXECUTED
2020870: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2020874: 1a 80 00 0c bcc 20208a4 <rtems_nvdisk_ioctl+0x44> <== NOT EXECUTED
2020878: 01 00 00 00 nop <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
if (rtems_nvdisks[minor].device_count == 0)
202087c: b9 28 60 03 sll %g1, 3, %i4 <== NOT EXECUTED
2020880: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
2020884: 3b 00 81 ba sethi %hi(0x206e800), %i5 <== NOT EXECUTED
2020888: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
202088c: c2 07 63 48 ld [ %i5 + 0x348 ], %g1 <== NOT EXECUTED
2020890: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
2020894: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
2020898: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
202089c: 12 80 00 08 bne 20208bc <rtems_nvdisk_ioctl+0x5c> <== NOT EXECUTED
20208a0: 01 00 00 00 nop <== NOT EXECUTED
{
errno = ENODEV;
20208a4: 40 00 84 ff call 2041ca0 <__errno> <== NOT EXECUTED
20208a8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
20208ac: 82 10 20 13 mov 0x13, %g1 <== NOT EXECUTED
20208b0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
20208b4: 81 c7 e0 08 ret <== NOT EXECUTED
20208b8: 81 e8 00 00 restore <== NOT EXECUTED
}
errno = 0;
20208bc: 40 00 84 f9 call 2041ca0 <__errno> <== NOT EXECUTED
20208c0: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
20208c4: c2 07 63 48 ld [ %i5 + 0x348 ], %g1 <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
errno = 0;
20208c8: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
20208cc: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
20208d0: d0 00 60 20 ld [ %g1 + 0x20 ], %o0 <== NOT EXECUTED
20208d4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20208d8: 7f ff b2 19 call 200d13c <rtems_semaphore_obtain> <== NOT EXECUTED
20208dc: 94 10 20 00 clr %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20208e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20208e4: 12 80 01 13 bne 2020d30 <rtems_nvdisk_ioctl+0x4d0> <== NOT EXECUTED
20208e8: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
else
{
errno = 0;
20208ec: 40 00 84 ed call 2041ca0 <__errno> <== NOT EXECUTED
20208f0: 01 00 00 00 nop <== NOT EXECUTED
switch (req)
20208f4: 03 08 00 10 sethi %hi(0x20004000), %g1 <== NOT EXECUTED
20208f8: 84 10 62 82 or %g1, 0x282, %g2 ! 20004282 <RAM_END+0x1dc04282><== NOT EXECUTED
20208fc: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED
2020900: 02 80 00 fd be 2020cf4 <rtems_nvdisk_ioctl+0x494> <== NOT EXECUTED
2020904: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
2020908: 05 30 06 10 sethi %hi(0xc0184000), %g2 <== NOT EXECUTED
202090c: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <RAM_END+0xbdd84201><== NOT EXECUTED
2020910: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED
2020914: 02 80 00 06 be 202092c <rtems_nvdisk_ioctl+0xcc> <== NOT EXECUTED
2020918: 82 10 62 80 or %g1, 0x280, %g1 <== NOT EXECUTED
202091c: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
2020920: 32 80 00 f9 bne,a 2020d04 <rtems_nvdisk_ioctl+0x4a4> <== NOT EXECUTED
2020924: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020928: 30 80 00 cf b,a 2020c64 <rtems_nvdisk_ioctl+0x404> <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
202092c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
2020930: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2020934: 02 80 00 05 be 2020948 <rtems_nvdisk_ioctl+0xe8> <== NOT EXECUTED
2020938: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
202093c: 12 80 00 c5 bne 2020c50 <rtems_nvdisk_ioctl+0x3f0> <== NOT EXECUTED
2020940: 01 00 00 00 nop <== NOT EXECUTED
2020944: 30 80 00 6e b,a 2020afc <rtems_nvdisk_ioctl+0x29c> <== NOT EXECUTED
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
2020948: 40 00 84 d6 call 2041ca0 <__errno> <== NOT EXECUTED
202094c: 2b 00 00 3f sethi %hi(0xfc00), %l5 <== NOT EXECUTED
2020950: fa 07 63 48 ld [ %i5 + 0x348 ], %i5 <== NOT EXECUTED
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
2020954: 2f 00 81 89 sethi %hi(0x2062400), %l7 <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
2020958: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
202095c: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
* @retval int The ioctl return value.
*/
static int
rtems_nvdisk_read (rtems_nvdisk* nvd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
2020960: b6 06 a0 18 add %i2, 0x18, %i3 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "read: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020964: a2 10 20 00 clr %l1 <== NOT EXECUTED
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
return ret;
if (crc == 0xffff)
2020968: aa 15 63 ff or %l5, 0x3ff, %l5 <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
202096c: 29 00 81 ba sethi %hi(0x206e800), %l4 <== NOT EXECUTED
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
2020970: 10 80 00 52 b 2020ab8 <rtems_nvdisk_ioctl+0x258> <== NOT EXECUTED
2020974: ae 15 e3 f8 or %l7, 0x3f8, %l7 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020978: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
202097c: 40 00 ea b5 call 205b450 <.udiv> <== NOT EXECUTED
2020980: a0 10 20 00 clr %l0 <== NOT EXECUTED
data = sg->buffer;
2020984: f2 06 e0 08 ld [ %i3 + 8 ], %i1 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020988: 10 80 00 44 b 2020a98 <rtems_nvdisk_ioctl+0x238> <== NOT EXECUTED
202098c: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
uint32_t page;
uint16_t crc;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020990: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_read_block (nvd, sg->block + b, data);
2020994: a4 04 00 12 add %l0, %l2, %l2 <== NOT EXECUTED
uint32_t page;
uint16_t crc;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020998: 7f ff ff 8c call 20207c8 <rtems_nvdisk_get_device> <== NOT EXECUTED
202099c: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
if (!dc)
20209a0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20209a4: 02 80 00 3b be 2020a90 <rtems_nvdisk_ioctl+0x230> <== NOT EXECUTED
20209a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
20209ac: e6 06 20 0c ld [ %i0 + 0xc ], %l3 <== NOT EXECUTED
rtems_nvdisk_read_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
uint16_t* cs)
{
return rtems_nvdisk_device_read (nvd, device,
20209b0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
20209b4: a6 24 80 13 sub %l2, %l3, %l3 <== NOT EXECUTED
rtems_nvdisk_read_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
uint16_t* cs)
{
return rtems_nvdisk_device_read (nvd, device,
20209b8: 95 2c e0 01 sll %l3, 1, %o2 <== NOT EXECUTED
20209bc: 96 07 bf fe add %fp, -2, %o3 <== NOT EXECUTED
20209c0: 7f ff ff 41 call 20206c4 <rtems_nvdisk_device_read> <== NOT EXECUTED
20209c4: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
block, dc->device, page, crc);
#endif
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
20209c8: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED
20209cc: 32 80 00 38 bne,a 2020aac <rtems_nvdisk_ioctl+0x24c> <== NOT EXECUTED
20209d0: a2 04 60 01 inc %l1 <== NOT EXECUTED
return ret;
if (crc == 0xffff)
20209d4: c2 17 bf fe lduh [ %fp + -2 ], %g1 <== NOT EXECUTED
20209d8: 80 a0 40 15 cmp %g1, %l5 <== NOT EXECUTED
20209dc: 32 80 00 08 bne,a 20209fc <rtems_nvdisk_ioctl+0x19c> <== NOT EXECUTED
20209e0: d8 07 60 0c ld [ %i5 + 0xc ], %o4 <== NOT EXECUTED
{
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_warning (nvd, "read-block: crc not set: %d", block);
#endif
memset (buffer, 0, nvd->block_size);
20209e4: d4 07 60 0c ld [ %i5 + 0xc ], %o2 <== NOT EXECUTED
20209e8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20209ec: 40 00 92 7a call 20453d4 <memset> <== NOT EXECUTED
20209f0: 92 10 20 00 clr %o1 <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
20209f4: 10 80 00 db b 2020d60 <rtems_nvdisk_ioctl+0x500> <== NOT EXECUTED
20209f8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
rtems_nvdisk_read_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
void* buffer)
{
return rtems_nvdisk_device_read (nvd, device,
20209fc: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
#endif
memset (buffer, 0, nvd->block_size);
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
2020a00: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED
rtems_nvdisk_read_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
void* buffer)
{
return rtems_nvdisk_device_read (nvd, device,
2020a04: 92 10 00 0c mov %o4, %o1 <== NOT EXECUTED
2020a08: c2 27 bf f0 st %g1, [ %fp + -16 ] <== NOT EXECUTED
2020a0c: d8 27 bf ec st %o4, [ %fp + -20 ] <== NOT EXECUTED
2020a10: 7f ff 88 eb call 2002dbc <.umul> <== NOT EXECUTED
2020a14: 90 04 c0 08 add %l3, %o0, %o0 <== NOT EXECUTED
2020a18: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
2020a1c: d8 07 bf ec ld [ %fp + -20 ], %o4 <== NOT EXECUTED
2020a20: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020a24: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
2020a28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020a2c: 7f ff ff 26 call 20206c4 <rtems_nvdisk_device_read> <== NOT EXECUTED
2020a30: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
2020a34: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED
2020a38: 12 80 00 1c bne 2020aa8 <rtems_nvdisk_ioctl+0x248> <== NOT EXECUTED
2020a3c: c4 05 23 44 ld [ %l4 + 0x344 ], %g2 <== NOT EXECUTED
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
2020a40: c6 07 60 0c ld [ %i5 + 0xc ], %g3 <== NOT EXECUTED
* Calculate the checksum of a page.
*/
static uint16_t
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
2020a44: 10 80 00 09 b 2020a68 <rtems_nvdisk_ioctl+0x208> <== NOT EXECUTED
2020a48: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2020a4c: c8 0e 40 01 ldub [ %i1 + %g1 ], %g4 <== NOT EXECUTED
2020a50: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
2020a54: 94 19 00 0a xor %g4, %o2, %o2 <== NOT EXECUTED
2020a58: 94 0a a0 ff and %o2, 0xff, %o2 <== NOT EXECUTED
2020a5c: 95 2a a0 01 sll %o2, 1, %o2 <== NOT EXECUTED
2020a60: d4 10 80 0a lduh [ %g2 + %o2 ], %o2 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2020a64: 82 00 60 01 inc %g1 <== NOT EXECUTED
2020a68: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2020a6c: 12 bf ff f8 bne 2020a4c <rtems_nvdisk_ioctl+0x1ec> <== NOT EXECUTED
2020a70: 95 2a a0 10 sll %o2, 0x10, %o2 <== NOT EXECUTED
if (ret)
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
2020a74: d6 17 bf fe lduh [ %fp + -2 ], %o3 <== NOT EXECUTED
2020a78: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
2020a7c: 80 a2 80 0b cmp %o2, %o3 <== NOT EXECUTED
2020a80: 02 80 00 b7 be 2020d5c <rtems_nvdisk_ioctl+0x4fc> <== NOT EXECUTED
2020a84: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
2020a88: 7f ff ff 33 call 2020754 <rtems_nvdisk_error> <== NOT EXECUTED
2020a8c: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
if (!dc)
return EIO;
2020a90: 10 80 00 06 b 2020aa8 <rtems_nvdisk_ioctl+0x248> <== NOT EXECUTED
2020a94: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2020a98: 80 a4 00 16 cmp %l0, %l6 <== NOT EXECUTED
2020a9c: 32 bf ff bd bne,a 2020990 <rtems_nvdisk_ioctl+0x130> <== NOT EXECUTED
2020aa0: e4 06 c0 00 ld [ %i3 ], %l2 <== NOT EXECUTED
2020aa4: 82 10 20 00 clr %g1 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "read: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020aa8: a2 04 60 01 inc %l1 <== NOT EXECUTED
2020aac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2020ab0: 12 80 00 09 bne 2020ad4 <rtems_nvdisk_ioctl+0x274> <== NOT EXECUTED
2020ab4: b6 06 e0 10 add %i3, 0x10, %i3 <== NOT EXECUTED
2020ab8: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
2020abc: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED
2020ac0: 2a bf ff ae bcs,a 2020978 <rtems_nvdisk_ioctl+0x118> <== NOT EXECUTED
2020ac4: d0 06 e0 04 ld [ %i3 + 4 ], %o0 <== NOT EXECUTED
2020ac8: 82 10 20 00 clr %g1 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
2020acc: 10 80 00 03 b 2020ad8 <rtems_nvdisk_ioctl+0x278> <== NOT EXECUTED
2020ad0: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020ad4: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
2020ad8: c4 06 a0 04 ld [ %i2 + 4 ], %g2 <== NOT EXECUTED
2020adc: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
2020ae0: d2 26 a0 0c st %o1, [ %i2 + 0xc ] <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
2020ae4: 9f c0 80 00 call %g2 <== NOT EXECUTED
2020ae8: c2 27 bf f0 st %g1, [ %fp + -16 ] <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
2020aec: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
2020af0: c4 07 bf f4 ld [ %fp + -12 ], %g2 <== NOT EXECUTED
break;
2020af4: 10 80 00 87 b 2020d10 <rtems_nvdisk_ioctl+0x4b0> <== NOT EXECUTED
2020af8: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
2020afc: 40 00 84 69 call 2041ca0 <__errno> <== NOT EXECUTED
2020b00: b6 06 a0 18 add %i2, 0x18, %i3 <== NOT EXECUTED
2020b04: fa 07 63 48 ld [ %i5 + 0x348 ], %i5 <== NOT EXECUTED
2020b08: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
2020b0c: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020b10: a2 10 20 00 clr %l1 <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2020b14: 10 80 00 42 b 2020c1c <rtems_nvdisk_ioctl+0x3bc> <== NOT EXECUTED
2020b18: 2b 00 81 ba sethi %hi(0x206e800), %l5 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020b1c: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
2020b20: 40 00 ea 4c call 205b450 <.udiv> <== NOT EXECUTED
2020b24: b0 10 20 00 clr %i0 <== NOT EXECUTED
data = sg->buffer;
2020b28: e0 06 e0 08 ld [ %i3 + 8 ], %l0 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020b2c: 10 80 00 34 b 2020bfc <rtems_nvdisk_ioctl+0x39c> <== NOT EXECUTED
2020b30: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc;
uint32_t page;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020b34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);
2020b38: a6 06 00 13 add %i0, %l3, %l3 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc;
uint32_t page;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020b3c: 7f ff ff 23 call 20207c8 <rtems_nvdisk_get_device> <== NOT EXECUTED
2020b40: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
if (!dc)
2020b44: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2020b48: 02 80 00 89 be 2020d6c <rtems_nvdisk_ioctl+0x50c> <== NOT EXECUTED
2020b4c: a4 10 3f ff mov -1, %l2 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
2020b50: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
if (!dc)
return EIO;
page = rtems_nvdisk_get_page (dc, block);
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
2020b54: c4 07 60 0c ld [ %i5 + 0xc ], %g2 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
2020b58: a6 24 c0 01 sub %l3, %g1, %l3 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2020b5c: ae 10 20 00 clr %l7 <== NOT EXECUTED
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2020b60: 10 80 00 07 b 2020b7c <rtems_nvdisk_ioctl+0x31c> <== NOT EXECUTED
2020b64: c2 05 63 44 ld [ %l5 + 0x344 ], %g1 <== NOT EXECUTED
2020b68: a4 0c a0 ff and %l2, 0xff, %l2 <== NOT EXECUTED
2020b6c: a4 1c 80 03 xor %l2, %g3, %l2 <== NOT EXECUTED
2020b70: a5 2c a0 01 sll %l2, 1, %l2 <== NOT EXECUTED
2020b74: e4 10 40 12 lduh [ %g1 + %l2 ], %l2 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2020b78: ae 05 e0 01 inc %l7 <== NOT EXECUTED
2020b7c: 80 a5 c0 02 cmp %l7, %g2 <== NOT EXECUTED
2020b80: 32 bf ff fa bne,a 2020b68 <rtems_nvdisk_ioctl+0x308> <== NOT EXECUTED
2020b84: c6 0c 00 17 ldub [ %l0 + %l7 ], %g3 <== NOT EXECUTED
rtems_nvdisk_write_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const void* buffer)
{
return rtems_nvdisk_device_write (nvd, device,
2020b88: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
2020b8c: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
rtems_nvdisk_write_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const void* buffer)
{
return rtems_nvdisk_device_write (nvd, device,
2020b90: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
2020b94: c2 27 bf f0 st %g1, [ %fp + -16 ] <== NOT EXECUTED
2020b98: 7f ff 88 89 call 2002dbc <.umul> <== NOT EXECUTED
2020b9c: 90 04 c0 08 add %l3, %o0, %o0 <== NOT EXECUTED
2020ba0: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
2020ba4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020ba8: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
2020bac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020bb0: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2020bb4: 7f ff fe d6 call 202070c <rtems_nvdisk_device_write> <== NOT EXECUTED
2020bb8: 98 10 00 17 mov %l7, %o4 <== NOT EXECUTED
rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
2020bbc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020bc0: 32 80 00 15 bne,a 2020c14 <rtems_nvdisk_ioctl+0x3b4> <== NOT EXECUTED
2020bc4: a2 04 60 01 inc %l1 <== NOT EXECUTED
return ret;
return rtems_nvdisk_write_checksum (nvd, dc->device, page, cs);
2020bc8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
rtems_nvdisk_write_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const uint16_t cs)
{
return rtems_nvdisk_device_write (nvd, device,
2020bcc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
return ret;
return rtems_nvdisk_write_checksum (nvd, dc->device, page, cs);
2020bd0: e4 37 bf fe sth %l2, [ %fp + -2 ] <== NOT EXECUTED
rtems_nvdisk_write_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const uint16_t cs)
{
return rtems_nvdisk_device_write (nvd, device,
2020bd4: 95 2c e0 01 sll %l3, 1, %o2 <== NOT EXECUTED
2020bd8: 96 07 bf fe add %fp, -2, %o3 <== NOT EXECUTED
2020bdc: 7f ff fe cc call 202070c <rtems_nvdisk_device_write> <== NOT EXECUTED
2020be0: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);
if (ret)
2020be4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020be8: 32 80 00 0b bne,a 2020c14 <rtems_nvdisk_ioctl+0x3b4> <== NOT EXECUTED
2020bec: a2 04 60 01 inc %l1 <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2020bf0: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2020bf4: b0 06 20 01 inc %i0 <== NOT EXECUTED
2020bf8: a0 04 00 01 add %l0, %g1, %l0 <== NOT EXECUTED
2020bfc: 80 a6 00 16 cmp %i0, %l6 <== NOT EXECUTED
2020c00: 32 bf ff cd bne,a 2020b34 <rtems_nvdisk_ioctl+0x2d4> <== NOT EXECUTED
2020c04: e6 06 c0 00 ld [ %i3 ], %l3 <== NOT EXECUTED
2020c08: 90 10 20 00 clr %o0 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020c0c: a2 04 60 01 inc %l1 <== NOT EXECUTED
2020c10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020c14: 12 80 00 08 bne 2020c34 <rtems_nvdisk_ioctl+0x3d4> <== NOT EXECUTED
2020c18: b6 06 e0 10 add %i3, 0x10, %i3 <== NOT EXECUTED
2020c1c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
2020c20: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED
2020c24: 2a bf ff be bcs,a 2020b1c <rtems_nvdisk_ioctl+0x2bc> <== NOT EXECUTED
2020c28: d0 06 e0 04 ld [ %i3 + 4 ], %o0 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
2020c2c: 10 80 00 03 b 2020c38 <rtems_nvdisk_ioctl+0x3d8> <== NOT EXECUTED
2020c30: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020c34: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
2020c38: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
2020c3c: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
2020c40: 9f c0 40 00 call %g1 <== NOT EXECUTED
2020c44: d2 26 a0 0c st %o1, [ %i2 + 0xc ] <== NOT EXECUTED
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
break;
2020c48: 10 80 00 32 b 2020d10 <rtems_nvdisk_ioctl+0x4b0> <== NOT EXECUTED
2020c4c: c0 25 00 00 clr [ %l4 ] <== NOT EXECUTED
default:
errno = EINVAL;
2020c50: 40 00 84 14 call 2041ca0 <__errno> <== NOT EXECUTED
2020c54: 01 00 00 00 nop <== NOT EXECUTED
2020c58: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
break;
2020c5c: 10 80 00 2d b 2020d10 <rtems_nvdisk_ioctl+0x4b0> <== NOT EXECUTED
2020c60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
2020c64: 40 00 84 0f call 2041ca0 <__errno> <== NOT EXECUTED
2020c68: b4 10 20 00 clr %i2 <== NOT EXECUTED
2020c6c: f2 07 63 48 ld [ %i5 + 0x348 ], %i1 <== NOT EXECUTED
2020c70: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
2020c74: b2 06 40 1c add %i1, %i4, %i1 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
2020c78: b6 10 20 00 clr %i3 <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
2020c7c: 10 80 00 17 b 2020cd8 <rtems_nvdisk_ioctl+0x478> <== NOT EXECUTED
2020c80: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
2020c84: ba 10 20 00 clr %i5 <== NOT EXECUTED
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
2020c88: 10 80 00 0c b 2020cb8 <rtems_nvdisk_ioctl+0x458> <== NOT EXECUTED
2020c8c: b0 06 00 1a add %i0, %i2, %i0 <== NOT EXECUTED
rtems_nvdisk_write_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const uint16_t cs)
{
return rtems_nvdisk_device_write (nvd, device,
2020c90: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
2020c94: e2 37 bf fe sth %l1, [ %fp + -2 ] <== NOT EXECUTED
rtems_nvdisk_write_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const uint16_t cs)
{
return rtems_nvdisk_device_write (nvd, device,
2020c98: 95 2f 60 01 sll %i5, 1, %o2 <== NOT EXECUTED
2020c9c: 96 07 bf fe add %fp, -2, %o3 <== NOT EXECUTED
2020ca0: 7f ff fe 9b call 202070c <rtems_nvdisk_device_write> <== NOT EXECUTED
2020ca4: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
if (ret)
2020ca8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020cac: 32 80 00 19 bne,a 2020d10 <rtems_nvdisk_ioctl+0x4b0> <== NOT EXECUTED
2020cb0: d0 24 00 00 st %o0, [ %l0 ] <== NOT EXECUTED
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
2020cb4: ba 07 60 01 inc %i5 <== NOT EXECUTED
2020cb8: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED
2020cbc: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
2020cc0: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED
2020cc4: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2020cc8: 2a bf ff f2 bcs,a 2020c90 <rtems_nvdisk_ioctl+0x430> <== NOT EXECUTED
2020ccc: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
2020cd0: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2020cd4: b4 06 a0 14 add %i2, 0x14, %i2 <== NOT EXECUTED
2020cd8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 <== NOT EXECUTED
2020cdc: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2020ce0: 2a bf ff e9 bcs,a 2020c84 <rtems_nvdisk_ioctl+0x424> <== NOT EXECUTED
2020ce4: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
if (ret)
return ret;
}
}
return 0;
2020ce8: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
break;
2020cec: 10 80 00 09 b 2020d10 <rtems_nvdisk_ioctl+0x4b0> <== NOT EXECUTED
2020cf0: d0 24 00 00 st %o0, [ %l0 ] <== NOT EXECUTED
case RTEMS_NVDISK_IOCTL_INFO_LEVEL:
rtems_nvdisks[minor].info_level = (uintptr_t) argp;
2020cf4: c2 07 63 48 ld [ %i5 + 0x348 ], %g1 <== NOT EXECUTED
2020cf8: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
break;
2020cfc: 10 80 00 05 b 2020d10 <rtems_nvdisk_ioctl+0x4b0> <== NOT EXECUTED
2020d00: f4 20 60 24 st %i2, [ %g1 + 0x24 ] <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
2020d04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2020d08: 40 00 0e c7 call 2024824 <rtems_blkdev_ioctl> <== NOT EXECUTED
2020d0c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
break;
}
sc = rtems_semaphore_release (rtems_nvdisks[minor].lock);
2020d10: 03 00 81 ba sethi %hi(0x206e800), %g1 <== NOT EXECUTED
2020d14: c2 00 63 48 ld [ %g1 + 0x348 ], %g1 ! 206eb48 <rtems_nvdisks><== NOT EXECUTED
2020d18: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
2020d1c: 7f ff b1 52 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2020d20: d0 07 20 20 ld [ %i4 + 0x20 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2020d24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020d28: 02 80 00 06 be 2020d40 <rtems_nvdisk_ioctl+0x4e0> <== NOT EXECUTED
2020d2c: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
2020d30: 40 00 83 dc call 2041ca0 <__errno> <== NOT EXECUTED
2020d34: 01 00 00 00 nop <== NOT EXECUTED
2020d38: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2020d3c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
2020d40: 40 00 83 d8 call 2041ca0 <__errno> <== NOT EXECUTED
2020d44: 01 00 00 00 nop <== NOT EXECUTED
2020d48: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2020d4c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2020d50: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
}
2020d54: 81 c7 e0 08 ret <== NOT EXECUTED
2020d58: 81 e8 00 00 restore <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2020d5c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2020d60: a0 04 20 01 inc %l0 <== NOT EXECUTED
2020d64: 10 bf ff 4d b 2020a98 <rtems_nvdisk_ioctl+0x238> <== NOT EXECUTED
2020d68: b2 06 40 01 add %i1, %g1, %i1 <== NOT EXECUTED
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
if (!dc)
return EIO;
2020d6c: 10 bf ff a8 b 2020c0c <rtems_nvdisk_ioctl+0x3ac> <== NOT EXECUTED
2020d70: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
02021024 <rtems_nvdisk_sram_read>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
void* buffer,
size_t size)
{
2021024: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
memcpy (buffer, (base + offset), size);
return 0;
}
2021028: b0 10 20 00 clr %i0 <== NOT EXECUTED
void* base,
uint32_t offset,
void* buffer,
size_t size)
{
memcpy (buffer, (base + offset), size);
202102c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2021030: 92 06 80 1b add %i2, %i3, %o1 <== NOT EXECUTED
2021034: 40 00 90 5c call 20451a4 <memcpy> <== NOT EXECUTED
2021038: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return 0;
}
202103c: 81 c7 e0 08 ret <== NOT EXECUTED
2021040: 81 e8 00 00 restore <== NOT EXECUTED
02020fdc <rtems_nvdisk_sram_verify>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
2020fdc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
return memcmp ((base + offset), buffer, size) == 0 ? 0 : EIO;
2020fe0: 90 06 80 1b add %i2, %i3, %o0 <== NOT EXECUTED
2020fe4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2020fe8: 40 00 90 41 call 20450ec <memcmp> <== NOT EXECUTED
2020fec: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2020ff0: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
2020ff4: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
}
2020ff8: b0 0e 20 05 and %i0, 5, %i0 <== NOT EXECUTED
2020ffc: 81 c7 e0 08 ret <== NOT EXECUTED
2021000: 81 e8 00 00 restore <== NOT EXECUTED
02021004 <rtems_nvdisk_sram_write>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
2021004: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
memcpy ((base + offset), buffer, size);
return 0;
}
2021008: b0 10 20 00 clr %i0 <== NOT EXECUTED
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
memcpy ((base + offset), buffer, size);
202100c: 90 06 80 1b add %i2, %i3, %o0 <== NOT EXECUTED
2021010: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2021014: 40 00 90 64 call 20451a4 <memcpy> <== NOT EXECUTED
2021018: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return 0;
}
202101c: 81 c7 e0 08 ret <== NOT EXECUTED
2021020: 81 e8 00 00 restore <== NOT EXECUTED
02008d70 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
2008d70: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
2008d74: 80 a6 20 00 cmp %i0, 0
2008d78: 02 80 00 39 be 2008e5c <rtems_partition_create+0xec>
2008d7c: 82 10 20 03 mov 3, %g1
return RTEMS_INVALID_NAME;
if ( !starting_address )
2008d80: 80 a6 60 00 cmp %i1, 0
2008d84: 02 80 00 36 be 2008e5c <rtems_partition_create+0xec>
2008d88: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
2008d8c: 80 a7 60 00 cmp %i5, 0
2008d90: 02 80 00 33 be 2008e5c <rtems_partition_create+0xec> <== NEVER TAKEN
2008d94: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
2008d98: 02 80 00 31 be 2008e5c <rtems_partition_create+0xec>
2008d9c: 82 10 20 08 mov 8, %g1
2008da0: 80 a6 a0 00 cmp %i2, 0
2008da4: 02 80 00 2e be 2008e5c <rtems_partition_create+0xec>
2008da8: 80 a6 80 1b cmp %i2, %i3
2008dac: 0a 80 00 2c bcs 2008e5c <rtems_partition_create+0xec>
2008db0: 80 8e e0 07 btst 7, %i3
2008db4: 12 80 00 2a bne 2008e5c <rtems_partition_create+0xec>
2008db8: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
2008dbc: 12 80 00 28 bne 2008e5c <rtems_partition_create+0xec>
2008dc0: 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++;
2008dc4: 03 00 80 89 sethi %hi(0x2022400), %g1
2008dc8: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2022730 <_Thread_Dispatch_disable_level>
2008dcc: 84 00 a0 01 inc %g2
2008dd0: c4 20 63 30 st %g2, [ %g1 + 0x330 ]
return _Thread_Dispatch_disable_level;
2008dd4: c2 00 63 30 ld [ %g1 + 0x330 ], %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 );
2008dd8: 23 00 80 89 sethi %hi(0x2022400), %l1
2008ddc: 40 00 06 f6 call 200a9b4 <_Objects_Allocate>
2008de0: 90 14 61 4c or %l1, 0x14c, %o0 ! 202254c <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
2008de4: a0 92 20 00 orcc %o0, 0, %l0
2008de8: 32 80 00 06 bne,a 2008e00 <rtems_partition_create+0x90>
2008dec: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
2008df0: 40 00 0c 19 call 200be54 <_Thread_Enable_dispatch>
2008df4: 01 00 00 00 nop
return RTEMS_TOO_MANY;
2008df8: 10 80 00 19 b 2008e5c <rtems_partition_create+0xec>
2008dfc: 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 );
2008e00: 92 10 00 1b mov %i3, %o1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
2008e04: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
2008e08: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
2008e0c: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
2008e10: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
2008e14: 40 00 46 73 call 201a7e0 <.udiv>
2008e18: 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,
2008e1c: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
2008e20: 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,
2008e24: 96 10 00 1b mov %i3, %o3
2008e28: b8 04 20 24 add %l0, 0x24, %i4
2008e2c: 40 00 04 52 call 2009f74 <_Chain_Initialize>
2008e30: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008e34: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008e38: a2 14 61 4c or %l1, 0x14c, %l1
2008e3c: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008e40: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008e44: 85 28 a0 02 sll %g2, 2, %g2
2008e48: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2008e4c: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
2008e50: 40 00 0c 01 call 200be54 <_Thread_Enable_dispatch>
2008e54: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
2008e58: 82 10 20 00 clr %g1
}
2008e5c: 81 c7 e0 08 ret
2008e60: 91 e8 00 01 restore %g0, %g1, %o0
0203e9a0 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
203e9a0: 9d e3 bf 98 save %sp, -104, %sp
203e9a4: 11 00 81 bf sethi %hi(0x206fc00), %o0
203e9a8: 92 10 00 18 mov %i0, %o1
203e9ac: 90 12 22 70 or %o0, 0x270, %o0
203e9b0: 7f ff 41 69 call 200ef54 <_Objects_Get>
203e9b4: 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 ) {
203e9b8: c2 07 bf fc ld [ %fp + -4 ], %g1
203e9bc: 80 a0 60 00 cmp %g1, 0
203e9c0: 12 80 00 6a bne 203eb68 <rtems_rate_monotonic_period+0x1c8>
203e9c4: ba 10 00 08 mov %o0, %i5
203e9c8: 37 00 81 be sethi %hi(0x206f800), %i3
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
203e9cc: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
203e9d0: b6 16 e0 00 mov %i3, %i3
203e9d4: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
203e9d8: 80 a0 80 01 cmp %g2, %g1
203e9dc: 02 80 00 06 be 203e9f4 <rtems_rate_monotonic_period+0x54>
203e9e0: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
203e9e4: 7f ff 45 1b call 200fe50 <_Thread_Enable_dispatch>
203e9e8: b0 10 20 17 mov 0x17, %i0
return RTEMS_NOT_OWNER_OF_RESOURCE;
203e9ec: 81 c7 e0 08 ret
203e9f0: 81 e8 00 00 restore
}
if ( length == RTEMS_PERIOD_STATUS ) {
203e9f4: 12 80 00 0d bne 203ea28 <rtems_rate_monotonic_period+0x88>
203e9f8: 01 00 00 00 nop
switch ( the_period->state ) {
203e9fc: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
203ea00: 80 a0 60 04 cmp %g1, 4
203ea04: 18 80 00 05 bgu 203ea18 <rtems_rate_monotonic_period+0x78><== NEVER TAKEN
203ea08: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
203ea0c: 05 00 81 a4 sethi %hi(0x2069000), %g2
203ea10: 84 10 a2 a8 or %g2, 0x2a8, %g2 ! 20692a8 <CSWTCH.11>
203ea14: 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();
203ea18: 7f ff 45 0e call 200fe50 <_Thread_Enable_dispatch>
203ea1c: 01 00 00 00 nop
return( return_value );
203ea20: 81 c7 e0 08 ret
203ea24: 81 e8 00 00 restore
}
_ISR_Disable( level );
203ea28: 7f ff 15 4e call 2003f60 <sparc_disable_interrupts>
203ea2c: 01 00 00 00 nop
203ea30: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
203ea34: f8 07 60 38 ld [ %i5 + 0x38 ], %i4
203ea38: 80 a7 20 00 cmp %i4, 0
203ea3c: 12 80 00 15 bne 203ea90 <rtems_rate_monotonic_period+0xf0>
203ea40: 80 a7 20 02 cmp %i4, 2
_ISR_Enable( level );
203ea44: 7f ff 15 4b call 2003f70 <sparc_enable_interrupts>
203ea48: 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 );
203ea4c: 90 10 00 1d mov %i5, %o0
203ea50: 7f ff ff ba call 203e938 <_Rate_monotonic_Initiate_statistics>
203ea54: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
203ea58: 82 10 20 02 mov 2, %g1
203ea5c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
203ea60: 03 00 80 fa sethi %hi(0x203e800), %g1
203ea64: 82 10 63 74 or %g1, 0x374, %g1 ! 203eb74 <_Rate_monotonic_Timeout>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
203ea68: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
203ea6c: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
the_watchdog->id = id;
203ea70: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
203ea74: c0 27 60 34 clr [ %i5 + 0x34 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203ea78: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203ea7c: 11 00 81 bc sethi %hi(0x206f000), %o0
203ea80: 92 07 60 10 add %i5, 0x10, %o1
203ea84: 7f ff 48 35 call 2010b58 <_Watchdog_Insert>
203ea88: 90 12 23 80 or %o0, 0x380, %o0
203ea8c: 30 80 00 1b b,a 203eaf8 <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 ) {
203ea90: 12 80 00 1e bne 203eb08 <rtems_rate_monotonic_period+0x168>
203ea94: 80 a7 20 04 cmp %i4, 4
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
203ea98: 7f ff ff 5f call 203e814 <_Rate_monotonic_Update_statistics>
203ea9c: 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;
203eaa0: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
203eaa4: 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;
203eaa8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
203eaac: 7f ff 15 31 call 2003f70 <sparc_enable_interrupts>
203eab0: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
203eab4: d0 06 e0 0c ld [ %i3 + 0xc ], %o0
203eab8: c2 07 60 08 ld [ %i5 + 8 ], %g1
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
203eabc: 13 00 00 10 sethi %hi(0x4000), %o1
203eac0: 7f ff 47 17 call 201071c <_Thread_Set_state>
203eac4: c2 22 20 20 st %g1, [ %o0 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
203eac8: 7f ff 15 26 call 2003f60 <sparc_disable_interrupts>
203eacc: 01 00 00 00 nop
local_state = the_period->state;
203ead0: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
203ead4: f8 27 60 38 st %i4, [ %i5 + 0x38 ]
_ISR_Enable( level );
203ead8: 7f ff 15 26 call 2003f70 <sparc_enable_interrupts>
203eadc: 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 )
203eae0: 80 a6 a0 03 cmp %i2, 3
203eae4: 12 80 00 05 bne 203eaf8 <rtems_rate_monotonic_period+0x158>
203eae8: 01 00 00 00 nop
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
203eaec: d0 06 e0 0c ld [ %i3 + 0xc ], %o0
203eaf0: 7f ff 43 f9 call 200fad4 <_Thread_Clear_state>
203eaf4: 13 00 00 10 sethi %hi(0x4000), %o1
_Thread_Enable_dispatch();
203eaf8: 7f ff 44 d6 call 200fe50 <_Thread_Enable_dispatch>
203eafc: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
203eb00: 81 c7 e0 08 ret
203eb04: 81 e8 00 00 restore
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
203eb08: 12 bf ff b9 bne 203e9ec <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
203eb0c: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
203eb10: 7f ff ff 41 call 203e814 <_Rate_monotonic_Update_statistics>
203eb14: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
203eb18: 7f ff 15 16 call 2003f70 <sparc_enable_interrupts>
203eb1c: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
203eb20: 82 10 20 02 mov 2, %g1
203eb24: 92 07 60 10 add %i5, 0x10, %o1
203eb28: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
203eb2c: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203eb30: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203eb34: 11 00 81 bc sethi %hi(0x206f000), %o0
203eb38: 7f ff 48 08 call 2010b58 <_Watchdog_Insert>
203eb3c: 90 12 23 80 or %o0, 0x380, %o0 ! 206f380 <_Watchdog_Ticks_chain>
203eb40: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
203eb44: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
203eb48: 03 00 81 ab sethi %hi(0x206ac00), %g1
203eb4c: c2 00 63 b4 ld [ %g1 + 0x3b4 ], %g1 ! 206afb4 <_Scheduler+0x34>
203eb50: 9f c0 40 00 call %g1
203eb54: 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();
203eb58: 7f ff 44 be call 200fe50 <_Thread_Enable_dispatch>
203eb5c: 01 00 00 00 nop
return RTEMS_TIMEOUT;
203eb60: 81 c7 e0 08 ret
203eb64: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
203eb68: b0 10 20 04 mov 4, %i0
}
203eb6c: 81 c7 e0 08 ret
203eb70: 81 e8 00 00 restore
0202a3dc <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
202a3dc: 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 )
202a3e0: 80 a6 60 00 cmp %i1, 0
202a3e4: 02 80 00 75 be 202a5b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NEVER TAKEN
202a3e8: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
202a3ec: 13 00 81 90 sethi %hi(0x2064000), %o1
202a3f0: 9f c6 40 00 call %i1
202a3f4: 92 12 61 f8 or %o1, 0x1f8, %o1 ! 20641f8 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
202a3f8: 90 10 00 18 mov %i0, %o0
202a3fc: 13 00 81 90 sethi %hi(0x2064000), %o1
202a400: 9f c6 40 00 call %i1
202a404: 92 12 62 18 or %o1, 0x218, %o1 ! 2064218 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
202a408: 90 10 00 18 mov %i0, %o0
202a40c: 13 00 81 90 sethi %hi(0x2064000), %o1
202a410: 9f c6 40 00 call %i1
202a414: 92 12 62 40 or %o1, 0x240, %o1 ! 2064240 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
202a418: 90 10 00 18 mov %i0, %o0
202a41c: 13 00 81 90 sethi %hi(0x2064000), %o1
202a420: 9f c6 40 00 call %i1
202a424: 92 12 62 68 or %o1, 0x268, %o1 ! 2064268 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
202a428: 90 10 00 18 mov %i0, %o0
202a42c: 13 00 81 90 sethi %hi(0x2064000), %o1
202a430: 9f c6 40 00 call %i1
202a434: 92 12 62 b8 or %o1, 0x2b8, %o1 ! 20642b8 <_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 ;
202a438: 03 00 81 bf sethi %hi(0x206fc00), %g1
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
202a43c: 21 00 81 90 sethi %hi(0x2064000), %l0
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,
202a440: 35 00 81 90 sethi %hi(0x2064000), %i2
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,
202a444: 37 00 81 90 sethi %hi(0x2064000), %i3
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
202a448: 39 00 81 95 sethi %hi(0x2065400), %i4
/*
* 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 ;
202a44c: fa 00 62 78 ld [ %g1 + 0x278 ], %i5
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
202a450: a0 14 23 08 or %l0, 0x308, %l0
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,
202a454: b4 16 a3 20 or %i2, 0x320, %i2
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,
202a458: b6 16 e3 40 or %i3, 0x340, %i3
/*
* 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 ;
202a45c: 10 80 00 52 b 202a5a4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
202a460: b8 17 23 d8 or %i4, 0x3d8, %i4
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
202a464: 40 00 50 12 call 203e4ac <rtems_rate_monotonic_get_statistics>
202a468: 92 07 bf a0 add %fp, -96, %o1
if ( status != RTEMS_SUCCESSFUL )
202a46c: 80 a2 20 00 cmp %o0, 0
202a470: 32 80 00 4d bne,a 202a5a4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
202a474: 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 );
202a478: 92 07 bf d8 add %fp, -40, %o1
202a47c: 40 00 50 7c call 203e66c <rtems_rate_monotonic_get_status>
202a480: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
202a484: d0 07 bf d8 ld [ %fp + -40 ], %o0
202a488: 92 10 20 05 mov 5, %o1
202a48c: 7f ff 8a 75 call 200ce60 <rtems_object_get_name>
202a490: 94 07 bf f8 add %fp, -8, %o2
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
202a494: d8 1f bf a0 ldd [ %fp + -96 ], %o4
202a498: 92 10 00 10 mov %l0, %o1
202a49c: 90 10 00 18 mov %i0, %o0
202a4a0: 94 10 00 1d mov %i5, %o2
202a4a4: 9f c6 40 00 call %i1
202a4a8: 96 07 bf f8 add %fp, -8, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
202a4ac: d2 07 bf a0 ld [ %fp + -96 ], %o1
202a4b0: 80 a2 60 00 cmp %o1, 0
202a4b4: 12 80 00 07 bne 202a4d0 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>
202a4b8: 94 07 bf f0 add %fp, -16, %o2
(*print)( context, "\n" );
202a4bc: 90 10 00 18 mov %i0, %o0
202a4c0: 9f c6 40 00 call %i1
202a4c4: 92 10 00 1c mov %i4, %o1
continue;
202a4c8: 10 80 00 37 b 202a5a4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
202a4cc: 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 );
202a4d0: 40 00 04 f5 call 202b8a4 <_Timespec_Divide_by_integer>
202a4d4: 90 07 bf b8 add %fp, -72, %o0
(*print)( context,
202a4d8: d0 07 bf ac ld [ %fp + -84 ], %o0
202a4dc: 40 00 c3 df call 205b458 <.div>
202a4e0: 92 10 23 e8 mov 0x3e8, %o1
202a4e4: a6 10 00 08 mov %o0, %l3
202a4e8: d0 07 bf b4 ld [ %fp + -76 ], %o0
202a4ec: 40 00 c3 db call 205b458 <.div>
202a4f0: 92 10 23 e8 mov 0x3e8, %o1
202a4f4: c2 07 bf f0 ld [ %fp + -16 ], %g1
202a4f8: a2 10 00 08 mov %o0, %l1
202a4fc: d0 07 bf f4 ld [ %fp + -12 ], %o0
202a500: e8 07 bf a8 ld [ %fp + -88 ], %l4
202a504: e4 07 bf b0 ld [ %fp + -80 ], %l2
202a508: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
202a50c: 40 00 c3 d3 call 205b458 <.div>
202a510: 92 10 23 e8 mov 0x3e8, %o1
202a514: 96 10 00 13 mov %l3, %o3
202a518: 98 10 00 12 mov %l2, %o4
202a51c: 9a 10 00 11 mov %l1, %o5
202a520: 94 10 00 14 mov %l4, %o2
202a524: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
202a528: 92 10 00 1a mov %i2, %o1
202a52c: 9f c6 40 00 call %i1
202a530: 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);
202a534: d2 07 bf a0 ld [ %fp + -96 ], %o1
202a538: 94 07 bf f0 add %fp, -16, %o2
202a53c: 40 00 04 da call 202b8a4 <_Timespec_Divide_by_integer>
202a540: 90 07 bf d0 add %fp, -48, %o0
(*print)( context,
202a544: d0 07 bf c4 ld [ %fp + -60 ], %o0
202a548: 40 00 c3 c4 call 205b458 <.div>
202a54c: 92 10 23 e8 mov 0x3e8, %o1
202a550: a6 10 00 08 mov %o0, %l3
202a554: d0 07 bf cc ld [ %fp + -52 ], %o0
202a558: 40 00 c3 c0 call 205b458 <.div>
202a55c: 92 10 23 e8 mov 0x3e8, %o1
202a560: c2 07 bf f0 ld [ %fp + -16 ], %g1
202a564: a2 10 00 08 mov %o0, %l1
202a568: d0 07 bf f4 ld [ %fp + -12 ], %o0
202a56c: e8 07 bf c0 ld [ %fp + -64 ], %l4
202a570: e4 07 bf c8 ld [ %fp + -56 ], %l2
202a574: 92 10 23 e8 mov 0x3e8, %o1
202a578: 40 00 c3 b8 call 205b458 <.div>
202a57c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
202a580: 92 10 00 1b mov %i3, %o1
202a584: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
202a588: 94 10 00 14 mov %l4, %o2
202a58c: 90 10 00 18 mov %i0, %o0
202a590: 96 10 00 13 mov %l3, %o3
202a594: 98 10 00 12 mov %l2, %o4
202a598: 9f c6 40 00 call %i1
202a59c: 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++ ) {
202a5a0: 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 ;
202a5a4: 03 00 81 bf sethi %hi(0x206fc00), %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 ;
202a5a8: c2 00 62 7c ld [ %g1 + 0x27c ], %g1 ! 206fe7c <_Rate_monotonic_Information+0xc>
202a5ac: 80 a7 40 01 cmp %i5, %g1
202a5b0: 08 bf ff ad bleu 202a464 <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
202a5b4: 90 10 00 1d mov %i5, %o0
202a5b8: 81 c7 e0 08 ret
202a5bc: 81 e8 00 00 restore
02008960 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
2008960: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chain;
rtems_rbtree_control *page_tree = &control->page_tree;
uintptr_t page_alignment = control->page_alignment;
2008964: f8 06 20 30 ld [ %i0 + 0x30 ], %i4
#include <stdlib.h>
static uintptr_t align_up(uintptr_t page_alignment, uintptr_t value)
{
uintptr_t excess = value % page_alignment;
2008968: 90 10 00 19 mov %i1, %o0
200896c: 92 10 00 1c mov %i4, %o1
2008970: 40 00 44 fd call 2019d64 <.urem>
2008974: ba 10 00 18 mov %i0, %i5
if (excess > 0) {
2008978: 80 a2 20 00 cmp %o0, 0
200897c: 02 80 00 04 be 200898c <rtems_rbheap_allocate+0x2c> <== ALWAYS TAKEN
2008980: b6 10 00 19 mov %i1, %i3
value += page_alignment - excess;
2008984: b8 06 40 1c add %i1, %i4, %i4 <== NOT EXECUTED
2008988: b6 27 00 08 sub %i4, %o0, %i3 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chain;
rtems_rbtree_control *page_tree = &control->page_tree;
uintptr_t page_alignment = control->page_alignment;
uintptr_t aligned_size = align_up(page_alignment, size);
if (size > 0 && size <= aligned_size) {
200898c: 80 a6 c0 19 cmp %i3, %i1
2008990: 0a 80 00 31 bcs 2008a54 <rtems_rbheap_allocate+0xf4> <== NEVER TAKEN
2008994: 80 a6 60 00 cmp %i1, 0
2008998: 02 80 00 2f be 2008a54 <rtems_rbheap_allocate+0xf4>
200899c: 84 07 60 04 add %i5, 4, %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20089a0: c2 07 40 00 ld [ %i5 ], %g1
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_page *big_enough = NULL;
20089a4: 10 80 00 06 b 20089bc <rtems_rbheap_allocate+0x5c>
20089a8: b2 10 20 00 clr %i1
while (current != tail && big_enough == NULL) {
rtems_rbheap_page *free_page = (rtems_rbheap_page *) current;
if (free_page->size >= size) {
20089ac: 80 a0 c0 1b cmp %g3, %i3
20089b0: b2 40 3f ff addx %g0, -1, %i1
20089b4: b2 08 40 19 and %g1, %i1, %i1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
20089b8: 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_page *big_enough = NULL;
while (current != tail && big_enough == NULL) {
20089bc: 80 a6 60 00 cmp %i1, 0
20089c0: 12 80 00 04 bne 20089d0 <rtems_rbheap_allocate+0x70>
20089c4: 80 a0 40 02 cmp %g1, %g2
20089c8: 32 bf ff f9 bne,a 20089ac <rtems_rbheap_allocate+0x4c>
20089cc: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
uintptr_t aligned_size = align_up(page_alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_page *free_page = search_free_page(free_chain, aligned_size);
if (free_page != NULL) {
20089d0: 80 a6 60 00 cmp %i1, 0
20089d4: 02 80 00 16 be 2008a2c <rtems_rbheap_allocate+0xcc>
20089d8: b0 10 20 00 clr %i0
uintptr_t free_size = free_page->size;
20089dc: f4 06 60 1c ld [ %i1 + 0x1c ], %i2
if (free_size > aligned_size) {
20089e0: 80 a6 80 1b cmp %i2, %i3
20089e4: 28 80 00 14 bleu,a 2008a34 <rtems_rbheap_allocate+0xd4>
20089e8: c4 06 40 00 ld [ %i1 ], %g2
rtems_rbheap_page *new_page = get_page(control);
20089ec: 7f ff ff 72 call 20087b4 <get_page>
20089f0: 90 10 00 1d mov %i5, %o0
if (new_page != NULL) {
20089f4: b8 92 20 00 orcc %o0, 0, %i4
20089f8: 02 80 00 0d be 2008a2c <rtems_rbheap_allocate+0xcc> <== NEVER TAKEN
20089fc: b4 26 80 1b sub %i2, %i3, %i2
uintptr_t new_free_size = free_size - aligned_size;
free_page->size = new_free_size;
new_page->begin = free_page->begin + new_free_size;
2008a00: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
rtems_rbheap_page *new_page = get_page(control);
if (new_page != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_page->size = new_free_size;
2008a04: f4 26 60 1c st %i2, [ %i1 + 0x1c ]
new_page->begin = free_page->begin + new_free_size;
new_page->size = aligned_size;
2008a08: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
if (new_page != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_page->size = new_free_size;
new_page->begin = free_page->begin + new_free_size;
2008a0c: b4 06 80 01 add %i2, %g1, %i2
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008a10: c0 27 20 04 clr [ %i4 + 4 ]
2008a14: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
2008a18: c0 27 00 00 clr [ %i4 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_page *page
)
{
_RBTree_Insert_unprotected(tree, &page->tree_node);
2008a1c: 90 07 60 18 add %i5, 0x18, %o0
2008a20: 40 00 06 e0 call 200a5a0 <_RBTree_Insert_unprotected>
2008a24: 92 07 20 08 add %i4, 8, %o1
free_page->size = new_free_size;
new_page->begin = free_page->begin + new_free_size;
new_page->size = aligned_size;
rtems_chain_set_off_chain(&new_page->chain_node);
insert_into_tree(page_tree, new_page);
ptr = (void *) new_page->begin;
2008a28: f0 07 20 18 ld [ %i4 + 0x18 ], %i0
2008a2c: 81 c7 e0 08 ret
2008a30: 81 e8 00 00 restore
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
2008a34: c2 06 60 04 ld [ %i1 + 4 ], %g1
}
} else {
rtems_chain_extract_unprotected(&free_page->chain_node);
rtems_chain_set_off_chain(&free_page->chain_node);
ptr = (void *) free_page->begin;
2008a38: f0 06 60 18 ld [ %i1 + 0x18 ], %i0
next->previous = previous;
2008a3c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
2008a40: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008a44: c0 26 60 04 clr [ %i1 + 4 ]
2008a48: c0 26 40 00 clr [ %i1 ]
2008a4c: 81 c7 e0 08 ret
2008a50: 81 e8 00 00 restore
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
2008a54: b0 10 20 00 clr %i0
}
}
}
return ptr;
}
2008a58: 81 c7 e0 08 ret
2008a5c: 81 e8 00 00 restore
02008bf4 <rtems_rbheap_extend_page_pool_with_malloc>:
void rtems_rbheap_extend_page_pool_with_malloc(rtems_rbheap_control *control)
{
2008bf4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_page *page = malloc(sizeof(*page));
2008bf8: 7f ff ed 74 call 20041c8 <malloc> <== NOT EXECUTED
2008bfc: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (page != NULL) {
2008c00: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2008c04: 02 80 00 07 be 2008c20 <rtems_rbheap_extend_page_pool_with_malloc+0x2c><== NOT EXECUTED
2008c08: 82 06 20 0c add %i0, 0xc, %g1 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008c0c: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
2008c10: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
2008c14: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
the_node->next = before_node;
2008c18: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
2008c1c: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
2008c20: 81 c7 e0 08 ret <== NOT EXECUTED
2008c24: 81 e8 00 00 restore <== NOT EXECUTED
02008a60 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(page_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
2008a60: 9d e3 bf 80 save %sp, -128, %sp
#define NULL_PAGE rtems_rbheap_page_of_node(NULL)
static rtems_rbheap_page *find(rtems_rbtree_control *page_tree, uintptr_t key)
{
rtems_rbheap_page page = { .begin = key };
2008a64: 92 10 20 00 clr %o1
2008a68: 90 07 bf e0 add %fp, -32, %o0
2008a6c: 94 10 20 20 mov 0x20, %o2
2008a70: 40 00 22 c1 call 2011574 <memset>
2008a74: ba 10 00 18 mov %i0, %i5
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
2008a78: b8 10 20 00 clr %i4
2008a7c: 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;
2008a80: 10 80 00 12 b 2008ac8 <rtems_rbheap_free+0x68>
2008a84: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
2008a88: 90 07 bf e8 add %fp, -24, %o0
2008a8c: 9f c0 40 00 call %g1
2008a90: 92 10 00 1b mov %i3, %o1
if ( _RBTree_Is_equal( compare_result ) ) {
2008a94: 80 a2 20 00 cmp %o0, 0
2008a98: 12 80 00 07 bne 2008ab4 <rtems_rbheap_free+0x54>
2008a9c: 83 3a 20 1f sra %o0, 0x1f, %g1
found = iter_node;
if ( the_rbtree->is_unique )
2008aa0: c2 0f 60 2c ldub [ %i5 + 0x2c ], %g1
2008aa4: 80 a0 60 00 cmp %g1, 0
2008aa8: 12 80 00 0c bne 2008ad8 <rtems_rbheap_free+0x78> <== ALWAYS TAKEN
2008aac: b8 10 00 1b mov %i3, %i4
break;
}
RBTree_Direction dir =
2008ab0: 83 3a 20 1f sra %o0, 0x1f, %g1 <== NOT EXECUTED
2008ab4: 90 20 40 08 sub %g1, %o0, %o0
2008ab8: 91 32 20 1f srl %o0, 0x1f, %o0
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
2008abc: 91 2a 20 02 sll %o0, 2, %o0
2008ac0: b6 06 c0 08 add %i3, %o0, %i3
2008ac4: f6 06 e0 04 ld [ %i3 + 4 ], %i3
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
2008ac8: 80 a6 e0 00 cmp %i3, 0
2008acc: 32 bf ff ef bne,a 2008a88 <rtems_rbheap_free+0x28>
2008ad0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2008ad4: b6 10 00 1c mov %i4, %i3
return rtems_rbheap_page_of_node(
2008ad8: b8 06 ff f8 add %i3, -8, %i4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_control *free_chain = &control->free_chain;
rtems_rbtree_control *page_tree = &control->page_tree;
rtems_rbheap_page *page = find(page_tree, (uintptr_t) ptr);
if (page != NULL_PAGE) {
2008adc: 80 a7 3f f8 cmp %i4, -8
2008ae0: 02 80 00 41 be 2008be4 <rtems_rbheap_free+0x184>
2008ae4: 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);
2008ae8: c4 06 ff f8 ld [ %i3 + -8 ], %g2
2008aec: 80 a0 a0 00 cmp %g2, 0
2008af0: 12 80 00 05 bne 2008b04 <rtems_rbheap_free+0xa4>
2008af4: 82 10 20 00 clr %g1
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(page_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
2008af8: c2 07 20 04 ld [ %i4 + 4 ], %g1
2008afc: 80 a0 00 01 cmp %g0, %g1
2008b00: 82 60 3f ff subx %g0, -1, %g1
rtems_chain_control *free_chain = &control->free_chain;
rtems_rbtree_control *page_tree = &control->page_tree;
rtems_rbheap_page *page = find(page_tree, (uintptr_t) ptr);
if (page != NULL_PAGE) {
if (!rtems_rbheap_is_page_free(page)) {
2008b04: 80 a0 60 00 cmp %g1, 0
2008b08: 02 80 00 37 be 2008be4 <rtems_rbheap_free+0x184>
2008b0c: b0 10 20 0e mov 0xe, %i0
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_control *free_chain = &control->free_chain;
rtems_rbtree_control *page_tree = &control->page_tree;
2008b10: b6 07 60 18 add %i5, 0x18, %i3
const rtems_rbtree_control *page_tree,
const rtems_rbheap_page *page,
RBTree_Direction dir
)
{
return rtems_rbheap_page_of_node(
2008b14: b0 07 20 08 add %i4, 8, %i0
2008b18: 94 10 20 00 clr %o2
2008b1c: 92 10 00 18 mov %i0, %o1
2008b20: 40 00 07 27 call 200a7bc <_RBTree_Next_unprotected>
2008b24: 90 10 00 1b mov %i3, %o0
2008b28: 92 10 00 18 mov %i0, %o1
2008b2c: b2 10 00 08 mov %o0, %i1
2008b30: b4 02 3f f8 add %o0, -8, %i2
2008b34: 94 10 20 01 mov 1, %o2
2008b38: 40 00 07 21 call 200a7bc <_RBTree_Next_unprotected>
2008b3c: 90 10 00 1b mov %i3, %o0
2008b40: 96 02 3f f8 add %o0, -8, %o3
rtems_rbtree_control *page_tree,
rtems_rbheap_page *a,
rtems_rbheap_page *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_page_free(b)) {
2008b44: 80 a2 ff f8 cmp %o3, -8
2008b48: 22 80 00 11 be,a 2008b8c <rtems_rbheap_free+0x12c>
2008b4c: c2 07 40 00 ld [ %i5 ], %g1
2008b50: c4 02 3f f8 ld [ %o0 + -8 ], %g2
2008b54: 80 a0 a0 00 cmp %g2, 0
2008b58: 12 80 00 05 bne 2008b6c <rtems_rbheap_free+0x10c>
2008b5c: 82 10 20 00 clr %g1
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(page_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
2008b60: c2 02 e0 04 ld [ %o3 + 4 ], %g1
2008b64: 80 a0 00 01 cmp %g0, %g1
2008b68: 82 60 3f ff subx %g0, -1, %g1
rtems_rbtree_control *page_tree,
rtems_rbheap_page *a,
rtems_rbheap_page *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_page_free(b)) {
2008b6c: 80 a0 60 00 cmp %g1, 0
2008b70: 32 80 00 07 bne,a 2008b8c <rtems_rbheap_free+0x12c>
2008b74: c2 07 40 00 ld [ %i5 ], %g1
2008b78: 90 10 00 1d mov %i5, %o0
2008b7c: 92 10 00 1b mov %i3, %o1
2008b80: 7f ff ff 1c call 20087f0 <check_and_merge.part.0>
2008b84: 94 10 00 1c mov %i4, %o2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2008b88: c2 07 40 00 ld [ %i5 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008b8c: fa 27 20 04 st %i5, [ %i4 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
2008b90: f8 27 40 00 st %i4, [ %i5 ]
the_node->next = before_node;
2008b94: c2 27 00 00 st %g1, [ %i4 ]
before_node->previous = the_node;
2008b98: f8 20 60 04 st %i4, [ %g1 + 4 ]
2008b9c: 80 a6 bf f8 cmp %i2, -8
2008ba0: 02 80 00 11 be 2008be4 <rtems_rbheap_free+0x184>
2008ba4: b0 10 20 00 clr %i0
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
2008ba8: c4 06 7f f8 ld [ %i1 + -8 ], %g2
2008bac: 80 a0 a0 00 cmp %g2, 0
2008bb0: 12 80 00 05 bne 2008bc4 <rtems_rbheap_free+0x164>
2008bb4: 82 10 20 00 clr %g1
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(page_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
2008bb8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
2008bbc: 80 a0 00 01 cmp %g0, %g1
2008bc0: 82 60 3f ff subx %g0, -1, %g1
rtems_rbtree_control *page_tree,
rtems_rbheap_page *a,
rtems_rbheap_page *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_page_free(b)) {
2008bc4: 80 a0 60 00 cmp %g1, 0
2008bc8: 12 80 00 07 bne 2008be4 <rtems_rbheap_free+0x184>
2008bcc: b0 10 20 00 clr %i0
2008bd0: 90 10 00 1d mov %i5, %o0
2008bd4: 92 10 00 1b mov %i3, %o1
2008bd8: 94 10 00 1c mov %i4, %o2
2008bdc: 7f ff ff 05 call 20087f0 <check_and_merge.part.0>
2008be0: 96 10 00 1a mov %i2, %o3
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
2008be4: 81 c7 e0 08 ret
2008be8: 81 e8 00 00 restore
02041458 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
2041458: 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);
204145c: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
2041460: 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);
2041464: 7f ff fe 56 call 2040dbc <rtems_rfs_bitmap_load_map>
2041468: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
204146c: b0 92 20 00 orcc %o0, 0, %i0
2041470: 14 80 00 30 bg 2041530 <rtems_rfs_bitmap_create_search+0xd8><== NEVER TAKEN
2041474: 82 10 3f ff mov -1, %g1
return rc;
control->free = 0;
search_map = control->search_bits;
2041478: f2 07 20 14 ld [ %i4 + 0x14 ], %i1
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
204147c: c0 27 20 10 clr [ %i4 + 0x10 ]
search_map = control->search_bits;
size = control->size;
2041480: fa 07 20 0c ld [ %i4 + 0xc ], %i5
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2041484: f4 07 bf fc ld [ %fp + -4 ], %i2
2041488: c2 26 40 00 st %g1, [ %i1 ]
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
204148c: b6 10 20 00 clr %i3
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
2041490: a0 10 20 01 mov 1, %l0
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
2041494: 10 80 00 23 b 2041520 <rtems_rfs_bitmap_create_search+0xc8>
2041498: b0 10 3f ff mov -1, %i0
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
204149c: 38 80 00 09 bgu,a 20414c0 <rtems_rfs_bitmap_create_search+0x68>
20414a0: c2 06 80 00 ld [ %i2 ], %g1
{
bits = rtems_rfs_bitmap_merge (*map,
20414a4: 90 10 20 00 clr %o0
20414a8: 7f ff fe fb call 2041094 <rtems_rfs_bitmap_mask_section>
20414ac: 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;
20414b0: c2 06 80 00 ld [ %i2 ], %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;
20414b4: 86 10 00 1d mov %i5, %g3
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
20414b8: 10 80 00 03 b 20414c4 <rtems_rfs_bitmap_create_search+0x6c>
20414bc: 82 0a 00 01 and %o0, %g1, %g1
available = size;
}
else
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
20414c0: 86 10 20 20 mov 0x20, %g3
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
20414c4: 80 a0 60 00 cmp %g1, 0
20414c8: 02 80 00 0e be 2041500 <rtems_rfs_bitmap_create_search+0xa8>
20414cc: 80 a6 e0 20 cmp %i3, 0x20
20414d0: 84 10 20 00 clr %g2
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
20414d4: 89 2c 00 02 sll %l0, %g2, %g4
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
20414d8: 80 89 00 01 btst %g4, %g1
20414dc: 02 80 00 05 be 20414f0 <rtems_rfs_bitmap_create_search+0x98>
20414e0: 84 00 a0 01 inc %g2
control->free++;
20414e4: c8 07 20 10 ld [ %i4 + 0x10 ], %g4
20414e8: 88 01 20 01 inc %g4
20414ec: c8 27 20 10 st %g4, [ %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++)
20414f0: 80 a0 80 03 cmp %g2, %g3
20414f4: 06 bf ff f9 bl 20414d8 <rtems_rfs_bitmap_create_search+0x80>
20414f8: 89 2c 00 02 sll %l0, %g2, %g4
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
20414fc: 80 a6 e0 20 cmp %i3, 0x20
2041500: 12 80 00 06 bne 2041518 <rtems_rfs_bitmap_create_search+0xc0><== ALWAYS TAKEN
2041504: ba 27 40 03 sub %i5, %g3, %i5
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2041508: f0 26 60 04 st %i0, [ %i1 + 4 ] <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
204150c: b6 10 20 00 clr %i3 <== NOT EXECUTED
search_map++;
2041510: 10 80 00 03 b 204151c <rtems_rfs_bitmap_create_search+0xc4><== NOT EXECUTED
2041514: b2 06 60 04 add %i1, 4, %i1 <== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
2041518: b6 06 e0 01 inc %i3
204151c: b4 06 a0 04 add %i2, 4, %i2
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
2041520: 80 a7 60 00 cmp %i5, 0
2041524: 12 bf ff de bne 204149c <rtems_rfs_bitmap_create_search+0x44>
2041528: 80 a7 60 1f cmp %i5, 0x1f
else
bit++;
map++;
}
return 0;
204152c: b0 10 20 00 clr %i0
}
2041530: 81 c7 e0 08 ret
2041534: 81 e8 00 00 restore
02040dbc <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)
{
2040dbc: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
2040dc0: c2 06 00 00 ld [ %i0 ], %g1
2040dc4: 80 a0 60 00 cmp %g1, 0
2040dc8: 02 80 00 0f be 2040e04 <rtems_rfs_bitmap_load_map+0x48> <== NEVER TAKEN
2040dcc: 90 10 20 06 mov 6, %o0
return ENXIO;
*map = NULL;
2040dd0: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
2040dd4: d4 06 20 08 ld [ %i0 + 8 ], %o2
2040dd8: d0 06 20 04 ld [ %i0 + 4 ], %o0
2040ddc: d2 06 00 00 ld [ %i0 ], %o1
2040de0: 7f ff d8 35 call 2036eb4 <rtems_rfs_buffer_handle_request>
2040de4: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
2040de8: 80 a2 20 00 cmp %o0, 0
2040dec: 12 80 00 06 bne 2040e04 <rtems_rfs_bitmap_load_map+0x48> <== NEVER TAKEN
2040df0: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
2040df4: c2 06 00 00 ld [ %i0 ], %g1
2040df8: c2 00 60 08 ld [ %g1 + 8 ], %g1
2040dfc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2040e00: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
2040e04: 81 c7 e0 08 ret
2040e08: 91 e8 00 08 restore %g0, %o0, %o0
02041378 <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)
{
2041378: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
204137c: 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))
2041380: 10 80 00 26 b 2041418 <rtems_rfs_bitmap_map_alloc+0xa0>
2041384: 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)
2041388: 1a 80 00 0f bcc 20413c4 <rtems_rfs_bitmap_map_alloc+0x4c> <== NEVER TAKEN
204138c: 80 a6 60 00 cmp %i1, 0
{
*bit = upper_seed;
2041390: fa 26 c0 00 st %i5, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
2041394: 90 10 00 18 mov %i0, %o0
2041398: 92 10 00 1b mov %i3, %o1
204139c: 94 10 00 1a mov %i2, %o2
20413a0: 7f ff fe 9b call 2040e0c <rtems_rfs_search_map_for_clear_bit.constprop.1>
20413a4: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
20413a8: 80 a2 20 00 cmp %o0, 0
20413ac: 14 80 00 29 bg 2041450 <rtems_rfs_bitmap_map_alloc+0xd8> <== NEVER TAKEN
20413b0: 01 00 00 00 nop
20413b4: c2 0e 80 00 ldub [ %i2 ], %g1
20413b8: 80 a0 60 00 cmp %g1, 0
20413bc: 12 80 00 25 bne 2041450 <rtems_rfs_bitmap_map_alloc+0xd8>
20413c0: 80 a6 60 00 cmp %i1, 0
break;
}
if (lower_seed >= 0)
20413c4: 06 80 00 0e bl 20413fc <rtems_rfs_bitmap_map_alloc+0x84> <== NEVER TAKEN
20413c8: 90 10 00 18 mov %i0, %o0
{
*bit = lower_seed;
20413cc: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
20413d0: 92 10 00 1b mov %i3, %o1
20413d4: 94 10 00 1a mov %i2, %o2
20413d8: 7f ff fe 8d call 2040e0c <rtems_rfs_search_map_for_clear_bit.constprop.1>
20413dc: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
20413e0: 80 a2 20 00 cmp %o0, 0
20413e4: 14 80 00 1b bg 2041450 <rtems_rfs_bitmap_map_alloc+0xd8> <== NEVER TAKEN
20413e8: 01 00 00 00 nop
20413ec: c2 0e 80 00 ldub [ %i2 ], %g1
20413f0: 80 a0 60 00 cmp %g1, 0
20413f4: 12 80 00 17 bne 2041450 <rtems_rfs_bitmap_map_alloc+0xd8>
20413f8: 01 00 00 00 nop
/*
* 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)
20413fc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2041400: 80 a7 40 01 cmp %i5, %g1
2041404: 2a 80 00 02 bcs,a 204140c <rtems_rfs_bitmap_map_alloc+0x94><== ALWAYS TAKEN
2041408: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
204140c: 80 a6 60 00 cmp %i1, 0
2041410: 36 80 00 02 bge,a 2041418 <rtems_rfs_bitmap_map_alloc+0xa0><== ALWAYS TAKEN
2041414: 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))
2041418: 80 a7 60 00 cmp %i5, 0
204141c: 06 80 00 07 bl 2041438 <rtems_rfs_bitmap_map_alloc+0xc0> <== NEVER TAKEN
2041420: 80 a6 60 00 cmp %i1, 0
2041424: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2041428: 80 a7 40 01 cmp %i5, %g1
204142c: 0a bf ff d7 bcs 2041388 <rtems_rfs_bitmap_map_alloc+0x10>
2041430: 01 00 00 00 nop
|| ((lower_seed >= 0) && (lower_seed < control->size)))
2041434: 80 a6 60 00 cmp %i1, 0
2041438: 06 80 00 06 bl 2041450 <rtems_rfs_bitmap_map_alloc+0xd8>
204143c: 01 00 00 00 nop
2041440: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2041444: 80 a6 40 01 cmp %i1, %g1
2041448: 0a bf ff d0 bcs 2041388 <rtems_rfs_bitmap_map_alloc+0x10> <== NEVER TAKEN
204144c: 80 a7 40 01 cmp %i5, %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
2041450: 81 c7 e0 08 ret
2041454: 91 e8 20 00 restore %g0, 0, %o0
0204114c <rtems_rfs_bitmap_map_clear>:
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
204114c: 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);
2041150: 90 10 00 18 mov %i0, %o0
2041154: 7f ff ff 1a call 2040dbc <rtems_rfs_bitmap_load_map>
2041158: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
204115c: 80 a2 20 00 cmp %o0, 0
2041160: 14 80 00 1b bg 20411cc <rtems_rfs_bitmap_map_clear+0x80> <== NEVER TAKEN
2041164: 01 00 00 00 nop
return rc;
if (bit >= control->size)
2041168: c2 06 20 0c ld [ %i0 + 0xc ], %g1
204116c: 80 a6 40 01 cmp %i1, %g1
2041170: 1a 80 00 17 bcc 20411cc <rtems_rfs_bitmap_map_clear+0x80> <== NEVER TAKEN
2041174: 90 10 20 16 mov 0x16, %o0
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);
2041178: de 07 bf fc ld [ %fp + -4 ], %o7
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
204117c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
index = rtems_rfs_bitmap_map_index (bit);
2041180: 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);
2041184: 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);
2041188: d8 03 c0 04 ld [ %o7 + %g4 ], %o4
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);
204118c: 82 10 20 01 mov 1, %g1
2041190: 9b 28 40 19 sll %g1, %i1, %o5
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
2041194: 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);
2041198: 9a 13 00 0d or %o4, %o5, %o5
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);
204119c: 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);
20411a0: da 23 c0 04 st %o5, [ %o7 + %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);
20411a4: 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);
20411a8: 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);
20411ac: 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);
20411b0: c6 20 80 19 st %g3, [ %g2 + %i1 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
20411b4: c4 06 00 00 ld [ %i0 ], %g2
control->free++;
return 0;
20411b8: 90 10 20 00 clr %o0
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);
20411bc: c2 28 80 00 stb %g1, [ %g2 ]
control->free++;
20411c0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20411c4: 82 00 60 01 inc %g1
20411c8: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
return 0;
}
20411cc: 81 c7 e0 08 ret
20411d0: 91 e8 00 08 restore %g0, %o0, %o0
020412c4 <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
20412c4: 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);
20412c8: 90 10 00 18 mov %i0, %o0
20412cc: 92 07 bf fc add %fp, -4, %o1
20412d0: 7f ff fe bb call 2040dbc <rtems_rfs_bitmap_load_map>
20412d4: ba 10 00 18 mov %i0, %i5
if (rc > 0)
20412d8: 80 a2 20 00 cmp %o0, 0
20412dc: 14 80 00 25 bg 2041370 <rtems_rfs_bitmap_map_clear_all+0xac><== NEVER TAKEN
20412e0: de 07 bf fc ld [ %fp + -4 ], %o7
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
20412e4: c8 06 20 0c ld [ %i0 + 0xc ], %g4
20412e8: 88 01 3f ff add %g4, -1, %g4
control->free = elements;
for (e = 0; e < elements; e++)
20412ec: 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);
20412f0: 89 31 20 05 srl %g4, 5, %g4
control->free = elements;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
20412f4: 86 10 3f ff mov -1, %g3
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
20412f8: 82 01 20 01 add %g4, 1, %g1
control->free = elements;
for (e = 0; e < elements; e++)
20412fc: 10 80 00 04 b 204130c <rtems_rfs_bitmap_map_clear_all+0x48>
2041300: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
2041304: 84 00 a0 01 inc %g2
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2041308: c6 23 c0 0d st %g3, [ %o7 + %o5 ]
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
204130c: 80 a0 80 01 cmp %g2, %g1
2041310: 0a bf ff fd bcs 2041304 <rtems_rfs_bitmap_map_clear_all+0x40>
2041314: 9b 28 a0 02 sll %g2, 2, %o5
* 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)
2041318: 86 88 60 1f andcc %g1, 0x1f, %g3
204131c: 22 80 00 02 be,a 2041324 <rtems_rfs_bitmap_map_clear_all+0x60>
2041320: 86 10 20 20 mov 0x20, %g3
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
2041324: 89 31 20 05 srl %g4, 5, %g4
for (e = 0; e < (elements - 1); e++)
2041328: 82 10 20 00 clr %g1
204132c: 10 80 00 05 b 2041340 <rtems_rfs_bitmap_map_clear_all+0x7c>
2041330: 9e 10 3f ff mov -1, %o7
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2041334: 9b 28 60 02 sll %g1, 2, %o5 <== 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++)
2041338: 82 00 60 01 inc %g1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
204133c: de 20 80 0d st %o7, [ %g2 + %o5 ] <== 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++)
2041340: 80 a0 40 04 cmp %g1, %g4
2041344: 12 bf ff fc bne 2041334 <rtems_rfs_bitmap_map_clear_all+0x70><== NEVER TAKEN
2041348: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
204134c: 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);
2041350: 86 20 00 03 neg %g3
2041354: 88 10 3f ff mov -1, %g4
2041358: 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] =
204135c: 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);
2041360: c2 07 40 00 ld [ %i5 ], %g1
2041364: 84 10 20 01 mov 1, %g2
return 0;
2041368: 90 10 20 00 clr %o0
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);
204136c: c4 28 40 00 stb %g2, [ %g1 ]
return 0;
}
2041370: 81 c7 e0 08 ret
2041374: 91 e8 00 08 restore %g0, %o0, %o0
020410bc <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
20410bc: 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);
20410c0: 90 10 00 18 mov %i0, %o0
20410c4: 7f ff ff 3e call 2040dbc <rtems_rfs_bitmap_load_map>
20410c8: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
20410cc: 80 a2 20 00 cmp %o0, 0
20410d0: 14 80 00 1d bg 2041144 <rtems_rfs_bitmap_map_set+0x88> <== NEVER TAKEN
20410d4: 01 00 00 00 nop
return rc;
if (bit >= control->size)
20410d8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20410dc: 80 a6 40 01 cmp %i1, %g1
20410e0: 1a 80 00 19 bcc 2041144 <rtems_rfs_bitmap_map_set+0x88> <== NEVER TAKEN
20410e4: 90 10 20 16 mov 0x16, %o0
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);
20410e8: da 07 bf fc ld [ %fp + -4 ], %o5
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
20410ec: 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);
20410f0: 9f 28 e0 02 sll %g3, 2, %o7
*/
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);
20410f4: c8 03 40 0f ld [ %o5 + %o7 ], %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;
20410f8: c4 06 20 14 ld [ %i0 + 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);
20410fc: 82 10 20 01 mov 1, %g1
2041100: 99 28 40 19 sll %g1, %i1, %o4
*/
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);
2041104: 88 29 00 0c andn %g4, %o4, %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);
2041108: c8 23 40 0f st %g4, [ %o5 + %o7 ]
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
204110c: 80 a1 20 00 cmp %g4, 0
2041110: 12 80 00 0d bne 2041144 <rtems_rfs_bitmap_map_set+0x88> <== ALWAYS TAKEN
2041114: 90 10 20 00 clr %o0
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
2041118: 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);
204111c: 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);
2041120: 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);
2041124: 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);
2041128: 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);
204112c: c6 20 80 19 st %g3, [ %g2 + %i1 ] <== NOT EXECUTED
control->free--;
2041130: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
2041134: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
2041138: c4 26 20 10 st %g2, [ %i0 + 0x10 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
204113c: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
2041140: c2 28 80 00 stb %g1, [ %g2 ] <== NOT EXECUTED
}
return 0;
}
2041144: 81 c7 e0 08 ret
2041148: 91 e8 00 08 restore %g0, %o0, %o0
02041234 <rtems_rfs_bitmap_map_set_all>:
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
2041234: 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);
2041238: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
204123c: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED
2041240: 7f ff fe df call 2040dbc <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
2041244: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
if (rc > 0)
2041248: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
204124c: 14 80 00 1c bg 20412bc <rtems_rfs_bitmap_map_set_all+0x88><== NOT EXECUTED
2041250: 82 10 20 00 clr %g1 <== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
2041254: c4 06 20 0c ld [ %i0 + 0xc ], %g2 <== NOT EXECUTED
control->free = 0;
2041258: c0 26 20 10 clr [ %i0 + 0x10 ] <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
204125c: 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;
2041260: c6 07 bf fc ld [ %fp + -4 ], %g3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
2041264: 85 30 a0 05 srl %g2, 5, %g2 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
2041268: 10 80 00 04 b 2041278 <rtems_rfs_bitmap_map_set_all+0x44> <== NOT EXECUTED
204126c: 88 00 a0 01 add %g2, 1, %g4 <== NOT EXECUTED
2041270: 82 00 60 01 inc %g1 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2041274: c0 20 c0 0f clr [ %g3 + %o7 ] <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
2041278: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED
204127c: 0a bf ff fd bcs 2041270 <rtems_rfs_bitmap_map_set_all+0x3c><== NOT EXECUTED
2041280: 9f 28 60 02 sll %g1, 2, %o7 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
2041284: 85 30 a0 05 srl %g2, 5, %g2 <== NOT EXECUTED
for (e = 0; e < elements; e++)
2041288: 82 10 20 00 clr %g1 <== NOT EXECUTED
204128c: 10 80 00 05 b 20412a0 <rtems_rfs_bitmap_map_set_all+0x6c> <== NOT EXECUTED
2041290: 84 00 a0 01 inc %g2 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2041294: 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++)
2041298: 82 00 60 01 inc %g1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
204129c: 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++)
20412a0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20412a4: 2a bf ff fc bcs,a 2041294 <rtems_rfs_bitmap_map_set_all+0x60><== NOT EXECUTED
20412a8: 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);
20412ac: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
20412b0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
return 0;
20412b4: 90 10 20 00 clr %o0 <== 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);
20412b8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
return 0;
}
20412bc: 81 c7 e0 08 ret <== NOT EXECUTED
20412c0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
020411d4 <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
20411d4: 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);
20411d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20411dc: 7f ff fe f8 call 2040dbc <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
20411e0: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED
if (rc > 0)
20411e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20411e8: 14 80 00 11 bg 204122c <rtems_rfs_bitmap_map_test+0x58> <== NOT EXECUTED
20411ec: 01 00 00 00 nop <== NOT EXECUTED
return rc;
if (bit >= control->size)
20411f0: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
20411f4: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
20411f8: 1a 80 00 0d bcc 204122c <rtems_rfs_bitmap_map_test+0x58> <== NOT EXECUTED
20411fc: 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);
2041200: 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);
2041204: 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);
2041208: b3 28 80 19 sll %g2, %i1, %i1 <== NOT EXECUTED
204120c: 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);
2041210: 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);
2041214: 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;
2041218: 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);
204121c: b2 0e 40 01 and %i1, %g1, %i1 <== NOT EXECUTED
2041220: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
2041224: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
2041228: 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;
}
204122c: 81 c7 e0 08 ret <== NOT EXECUTED
2041230: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02041084 <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;
}
2041084: 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);
2041088: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
204108c: 81 c3 e0 08 retl <== NOT EXECUTED
2041090: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
02041094 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
2041094: 82 10 00 08 mov %o0, %g1
rtems_rfs_bitmap_element mask = 0;
if (end > start)
2041098: 80 a2 40 01 cmp %o1, %g1
204109c: 08 80 00 06 bleu 20410b4 <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
20410a0: 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);
20410a4: 92 20 40 09 sub %g1, %o1, %o1
20410a8: 90 10 3f ff mov -1, %o0
20410ac: 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;
20410b0: 91 2a 00 01 sll %o0, %g1, %o0
return mask;
}
20410b4: 81 c3 e0 08 retl
02041538 <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)
{
2041538: 9d e3 bf a0 save %sp, -96, %sp
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
204153c: f4 26 00 00 st %i2, [ %i0 ]
control->fs = fs;
2041540: f2 26 20 04 st %i1, [ %i0 + 4 ]
control->block = block;
2041544: f8 26 20 08 st %i4, [ %i0 + 8 ]
control->size = size;
2041548: 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);
204154c: 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);
2041550: 91 32 20 0a srl %o0, 0xa, %o0
2041554: 90 02 20 01 inc %o0
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
2041558: 7f ff 1e 08 call 2008d78 <malloc>
204155c: 91 2a 20 02 sll %o0, 2, %o0
if (!control->search_bits)
2041560: 80 a2 20 00 cmp %o0, 0
2041564: 02 80 00 04 be 2041574 <rtems_rfs_bitmap_open+0x3c> <== NEVER TAKEN
2041568: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
204156c: 7f ff ff bb call 2041458 <rtems_rfs_bitmap_create_search>
2041570: 81 e8 00 00 restore
}
2041574: 81 c7 e0 08 ret <== NOT EXECUTED
2041578: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED
02035d24 <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)
{
2035d24: 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);
2035d28: 96 10 20 01 mov 1, %o3
2035d2c: 90 10 00 18 mov %i0, %o0
2035d30: 92 10 00 19 mov %i1, %o1
2035d34: 40 00 04 60 call 2036eb4 <rtems_rfs_buffer_handle_request>
2035d38: 94 10 00 1a mov %i2, %o2
if (rc > 0)
2035d3c: 80 a2 20 00 cmp %o0, 0
2035d40: 14 80 00 26 bg 2035dd8 <rtems_rfs_block_find_indirect+0xb4><== NEVER TAKEN
2035d44: 87 2e e0 02 sll %i3, 2, %g3
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
2035d48: c2 06 60 08 ld [ %i1 + 8 ], %g1
2035d4c: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
2035d50: 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);
2035d54: 84 01 00 03 add %g4, %g3, %g2
2035d58: c2 09 00 03 ldub [ %g4 + %g3 ], %g1
2035d5c: f2 08 a0 03 ldub [ %g2 + 3 ], %i1
2035d60: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
2035d64: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
2035d68: 83 28 60 18 sll %g1, 0x18, %g1
2035d6c: 85 28 a0 08 sll %g2, 8, %g2
2035d70: 82 16 40 01 or %i1, %g1, %g1
2035d74: 87 28 e0 10 sll %g3, 0x10, %g3
2035d78: 82 10 40 03 or %g1, %g3, %g1
2035d7c: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
2035d80: 84 38 00 01 xnor %g0, %g1, %g2
2035d84: 80 a0 00 02 cmp %g0, %g2
2035d88: 84 60 20 00 subx %g0, 0, %g2
2035d8c: 82 08 40 02 and %g1, %g2, %g1
if (*result >= rtems_rfs_fs_blocks (fs))
2035d90: c4 06 20 04 ld [ %i0 + 4 ], %g2
2035d94: 80 a0 40 02 cmp %g1, %g2
2035d98: 0a 80 00 10 bcs 2035dd8 <rtems_rfs_block_find_indirect+0xb4><== ALWAYS TAKEN
2035d9c: c2 27 00 00 st %g1, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
2035da0: 90 10 20 00 clr %o0 <== NOT EXECUTED
2035da4: 7f ff b6 41 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2035da8: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
2035dac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2035db0: 22 80 00 09 be,a 2035dd4 <rtems_rfs_block_find_indirect+0xb0><== NOT EXECUTED
2035db4: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
2035db8: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
2035dbc: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2035dc0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2035dc4: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
2035dc8: 40 00 41 ef call 2046584 <printf> <== NOT EXECUTED
2035dcc: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
2035dd0: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
2035dd4: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
2035dd8: 81 c7 e0 08 ret
2035ddc: 91 e8 00 08 restore %g0, %o0, %o0
02035e44 <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)
{
2035e44: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
2035e48: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
2035e4c: 32 80 00 06 bne,a 2035e64 <rtems_rfs_block_get_block_size+0x20><== NOT EXECUTED
2035e50: 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;
2035e54: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
2035e58: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
2035e5c: 81 c7 e0 08 ret <== NOT EXECUTED
2035e60: 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;
2035e64: 94 10 20 00 clr %o2 <== NOT EXECUTED
2035e68: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
2035e6c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2035e70: 40 00 99 33 call 205c33c <__udivdi3> <== NOT EXECUTED
2035e74: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2035e78: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
2035e7c: 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;
2035e80: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
2035e84: 94 10 20 00 clr %o2 <== NOT EXECUTED
2035e88: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2035e8c: 40 00 9a 01 call 205c690 <__umoddi3> <== NOT EXECUTED
2035e90: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
2035e94: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
2035e98: 81 c7 e0 08 ret <== NOT EXECUTED
2035e9c: 81 e8 00 00 restore <== NOT EXECUTED
02036080 <rtems_rfs_block_map_close>:
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
2036080: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
2036084: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
2036088: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
203608c: 80 a0 60 00 cmp %g1, 0
2036090: 02 80 00 62 be 2036218 <rtems_rfs_block_map_close+0x198>
2036094: b0 10 20 00 clr %i0
2036098: d2 06 60 04 ld [ %i1 + 4 ], %o1
203609c: 80 a2 60 00 cmp %o1, 0
20360a0: 22 80 00 5f be,a 203621c <rtems_rfs_block_map_close+0x19c><== NEVER TAKEN
20360a4: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
20360a8: 40 00 14 bb call 203b394 <rtems_rfs_inode_load>
20360ac: 90 10 00 1d mov %i5, %o0
if (brc > 0)
20360b0: b0 92 20 00 orcc %o0, 0, %i0
20360b4: 14 80 00 5a bg 203621c <rtems_rfs_block_map_close+0x19c> <== NEVER TAKEN
20360b8: 92 06 60 38 add %i1, 0x38, %o1
20360bc: 82 10 20 01 mov 1, %g1
20360c0: 88 10 20 00 clr %g4
*/
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);
20360c4: b0 10 20 01 mov 1, %i0
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]);
20360c8: c4 06 60 04 ld [ %i1 + 4 ], %g2
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
20360cc: 86 06 40 01 add %i1, %g1, %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);
20360d0: da 00 a0 0c ld [ %g2 + 0xc ], %o5
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]);
20360d4: c6 00 e0 23 ld [ %g3 + 0x23 ], %g3
20360d8: 9e 01 20 06 add %g4, 6, %o7
20360dc: 9f 2b e0 02 sll %o7, 2, %o7
20360e0: 9e 03 40 0f add %o5, %o7, %o7
20360e4: 9b 30 e0 18 srl %g3, 0x18, %o5
20360e8: da 2b e0 04 stb %o5, [ %o7 + 4 ]
20360ec: de 00 a0 0c ld [ %g2 + 0xc ], %o7
20360f0: 9b 30 e0 10 srl %g3, 0x10, %o5
20360f4: 9e 03 c0 01 add %o7, %g1, %o7
20360f8: da 2b e0 1c stb %o5, [ %o7 + 0x1c ]
20360fc: de 00 a0 0c ld [ %g2 + 0xc ], %o7
2036100: 9b 30 e0 08 srl %g3, 8, %o5
2036104: 9e 03 c0 01 add %o7, %g1, %o7
2036108: da 2b e0 1d stb %o5, [ %o7 + 0x1d ]
203610c: de 00 a0 0c ld [ %g2 + 0xc ], %o7
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
2036110: 88 01 20 01 inc %g4
2036114: 9e 03 c0 01 add %o7, %g1, %o7
2036118: c6 2b e0 1e stb %g3, [ %o7 + 0x1e ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203611c: f0 28 a0 10 stb %i0, [ %g2 + 0x10 ]
2036120: 86 10 20 01 mov 1, %g3
2036124: 80 a1 20 05 cmp %g4, 5
2036128: 12 bf ff e8 bne 20360c8 <rtems_rfs_block_map_close+0x48>
203612c: 82 00 60 04 add %g1, 4, %g1
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
2036130: c2 06 60 04 ld [ %i1 + 4 ], %g1
2036134: 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);
2036138: c8 00 60 0c ld [ %g1 + 0xc ], %g4
203613c: b1 30 a0 18 srl %g2, 0x18, %i0
2036140: f0 29 20 0c stb %i0, [ %g4 + 0xc ]
2036144: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036148: b1 30 a0 10 srl %g2, 0x10, %i0
203614c: f0 29 20 0d stb %i0, [ %g4 + 0xd ]
2036150: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036154: b1 30 a0 08 srl %g2, 8, %i0
2036158: f0 29 20 0e stb %i0, [ %g4 + 0xe ]
203615c: 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);
2036160: 90 10 00 1d mov %i5, %o0
2036164: c4 29 20 0f stb %g2, [ %g4 + 0xf ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2036168: 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);
203616c: c2 06 60 04 ld [ %i1 + 4 ], %g1
2036170: c4 06 60 0c ld [ %i1 + 0xc ], %g2
*/
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);
2036174: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036178: b1 30 a0 08 srl %g2, 8, %i0
203617c: f0 29 20 0a stb %i0, [ %g4 + 0xa ]
2036180: c8 00 60 0c ld [ %g1 + 0xc ], %g4
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);
2036184: 94 10 20 01 mov 1, %o2
2036188: c4 29 20 0b stb %g2, [ %g4 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203618c: 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);
2036190: c2 06 60 04 ld [ %i1 + 4 ], %g1
2036194: 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);
2036198: c8 00 60 0c ld [ %g1 + 0xc ], %g4
203619c: b1 30 a0 18 srl %g2, 0x18, %i0
20361a0: f0 29 20 30 stb %i0, [ %g4 + 0x30 ]
20361a4: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20361a8: b1 30 a0 10 srl %g2, 0x10, %i0
20361ac: f0 29 20 31 stb %i0, [ %g4 + 0x31 ]
20361b0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20361b4: b1 30 a0 08 srl %g2, 8, %i0
20361b8: f0 29 20 32 stb %i0, [ %g4 + 0x32 ]
20361bc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20361c0: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20361c4: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
20361c8: c2 06 60 04 ld [ %i1 + 4 ], %g1
20361cc: 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);
20361d0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20361d4: b1 30 a0 18 srl %g2, 0x18, %i0
20361d8: f0 29 20 34 stb %i0, [ %g4 + 0x34 ]
20361dc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20361e0: b1 30 a0 10 srl %g2, 0x10, %i0
20361e4: f0 29 20 35 stb %i0, [ %g4 + 0x35 ]
20361e8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20361ec: b1 30 a0 08 srl %g2, 8, %i0
20361f0: f0 29 20 36 stb %i0, [ %g4 + 0x36 ]
20361f4: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20361f8: c4 29 20 37 stb %g2, [ %g4 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
20361fc: d2 06 60 04 ld [ %i1 + 4 ], %o1
2036200: 40 00 14 c7 call 203b51c <rtems_rfs_inode_unload>
2036204: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
2036208: c0 2e 40 00 clrb [ %i1 ]
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
203620c: 82 38 00 08 xnor %g0, %o0, %g1
2036210: 83 38 60 1f sra %g1, 0x1f, %g1
2036214: 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);
2036218: 92 06 60 38 add %i1, 0x38, %o1
map->dirty = false;
}
}
map->inode = NULL;
203621c: c0 26 60 04 clr [ %i1 + 4 ]
2036220: 40 00 02 b3 call 2036cec <rtems_rfs_buffer_handle_release>
2036224: 90 10 00 1d mov %i5, %o0
2036228: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
203622c: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
2036230: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
2036234: 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);
2036238: 40 00 02 ad call 2036cec <rtems_rfs_buffer_handle_release>
203623c: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
2036240: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
2036244: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
2036248: 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;
}
203624c: 81 c7 e0 08 ret
2036250: 81 e8 00 00 restore
02036254 <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)
{
2036254: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
2036258: 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))
203625c: e0 06 80 00 ld [ %i2 ], %l0
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)
{
2036260: ba 10 00 18 mov %i0, %i5
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
2036264: 80 a4 20 00 cmp %l0, 0
2036268: 02 80 00 05 be 203627c <rtems_rfs_block_map_find+0x28>
203626c: e2 06 60 08 ld [ %i1 + 8 ], %l1
2036270: 80 a4 60 00 cmp %l1, 0
2036274: 02 80 00 52 be 20363bc <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
2036278: 90 10 20 06 mov 6, %o0
203627c: 80 a4 00 11 cmp %l0, %l1
2036280: 1a 80 00 4f bcc 20363bc <rtems_rfs_block_map_find+0x168>
2036284: 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))
2036288: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
203628c: 80 a4 00 01 cmp %l0, %g1
2036290: 12 80 00 07 bne 20362ac <rtems_rfs_block_map_find+0x58>
2036294: 80 a4 60 05 cmp %l1, 5
2036298: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
203629c: 80 a0 60 00 cmp %g1, 0
20362a0: 32 80 00 3e bne,a 2036398 <rtems_rfs_block_map_find+0x144>
20362a4: 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)
20362a8: 80 a4 60 05 cmp %l1, 5
20362ac: 38 80 00 08 bgu,a 20362cc <rtems_rfs_block_map_find+0x78>
20362b0: e4 07 60 34 ld [ %i5 + 0x34 ], %l2
{
*block = map->blocks[bpos->bno];
20362b4: a0 04 20 08 add %l0, 8, %l0
20362b8: a1 2c 20 02 sll %l0, 2, %l0
20362bc: a0 06 40 10 add %i1, %l0, %l0
20362c0: c2 04 20 04 ld [ %l0 + 4 ], %g1
20362c4: 10 80 00 35 b 2036398 <rtems_rfs_block_map_find+0x144>
20362c8: 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;
20362cc: 90 10 00 10 mov %l0, %o0
20362d0: 40 00 95 0c call 205b700 <.urem>
20362d4: 92 10 00 12 mov %l2, %o1
singly = bpos->bno / fs->blocks_per_block;
20362d8: 92 10 00 12 mov %l2, %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;
20362dc: b8 10 00 08 mov %o0, %i4
singly = bpos->bno / fs->blocks_per_block;
20362e0: 40 00 94 5c call 205b450 <.udiv>
20362e4: 90 10 00 10 mov %l0, %o0
if (map->size.count <= fs->block_map_singly_blocks)
20362e8: c2 07 60 38 ld [ %i5 + 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;
20362ec: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
20362f0: 80 a4 40 01 cmp %l1, %g1
20362f4: 18 80 00 09 bgu 2036318 <rtems_rfs_block_map_find+0xc4> <== NEVER TAKEN
20362f8: a6 10 00 08 mov %o0, %l3
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
20362fc: a6 02 20 08 add %o0, 8, %l3
2036300: 92 06 60 38 add %i1, 0x38, %o1
2036304: a7 2c e0 02 sll %l3, 2, %l3
2036308: 90 10 00 1d mov %i5, %o0
203630c: a6 06 40 13 add %i1, %l3, %l3
2036310: 10 80 00 1c b 2036380 <rtems_rfs_block_map_find+0x12c>
2036314: d4 04 e0 04 ld [ %l3 + 4 ], %o2
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
2036318: 40 00 94 fa call 205b700 <.urem> <== NOT EXECUTED
203631c: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
2036320: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
2036324: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
2036328: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
203632c: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED
2036330: 1a 80 00 23 bcc 20363bc <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
2036334: 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;
2036338: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
203633c: 40 00 94 45 call 205b450 <.udiv> <== NOT EXECUTED
2036340: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
singly %= fs->blocks_per_block;
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
2036344: 82 02 20 08 add %o0, 8, %g1 <== NOT EXECUTED
2036348: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
203634c: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
2036350: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
2036354: a2 06 60 44 add %i1, 0x44, %l1 <== NOT EXECUTED
2036358: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203635c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2036360: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2036364: 7f ff fe 70 call 2035d24 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
2036368: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
203636c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2036370: 12 80 00 13 bne 20363bc <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
2036374: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
2036378: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203637c: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
2036380: 96 10 00 1c mov %i4, %o3
2036384: 7f ff fe 68 call 2035d24 <rtems_rfs_block_find_indirect>
2036388: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
203638c: 80 a2 20 00 cmp %o0, 0
2036390: 12 80 00 0b bne 20363bc <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
2036394: 01 00 00 00 nop
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
2036398: c2 06 80 00 ld [ %i2 ], %g1
map->bpos.block = *block;
203639c: 90 10 20 00 clr %o0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
20363a0: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
20363a4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
20363a8: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
20363ac: c2 06 a0 08 ld [ %i2 + 8 ], %g1
20363b0: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
map->bpos.block = *block;
20363b4: c2 06 c0 00 ld [ %i3 ], %g1
20363b8: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
20363bc: 81 c7 e0 08 ret
20363c0: 91 e8 00 08 restore %g0, %o0, %o0
0203646c <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)
{
203646c: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
2036470: 90 10 20 00 clr %o0
2036474: 13 00 00 08 sethi %hi(0x2000), %o1
2036478: 7f ff b4 8c call 20236a8 <rtems_rfs_trace>
203647c: ba 10 00 18 mov %i0, %i5
2036480: 80 8a 20 ff btst 0xff, %o0
2036484: 22 80 00 08 be,a 20364a4 <rtems_rfs_block_map_grow+0x38> <== ALWAYS TAKEN
2036488: c4 06 60 08 ld [ %i1 + 8 ], %g2
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
203648c: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
2036490: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036494: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2036498: 40 00 40 3b call 2046584 <printf> <== NOT EXECUTED
203649c: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
20364a0: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
20364a4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
20364a8: 84 06 80 02 add %i2, %g2, %g2
20364ac: 80 a0 80 01 cmp %g2, %g1
20364b0: 1a 80 00 b3 bcc 203677c <rtems_rfs_block_map_grow+0x310> <== NEVER TAKEN
20364b4: 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,
20364b8: a0 10 20 00 clr %l0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
20364bc: aa 10 20 01 mov 1, %l5
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
20364c0: a8 06 60 44 add %i1, 0x44, %l4
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
20364c4: 10 80 00 d1 b 2036808 <rtems_rfs_block_map_grow+0x39c>
20364c8: b8 06 60 38 add %i1, 0x38, %i4
/*
* 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,
20364cc: 90 10 00 1d mov %i5, %o0
20364d0: 94 10 20 00 clr %o2
20364d4: 40 00 12 8d call 203af08 <rtems_rfs_group_bitmap_alloc>
20364d8: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
20364dc: b0 92 20 00 orcc %o0, 0, %i0
20364e0: 14 80 00 ce bg 2036818 <rtems_rfs_block_map_grow+0x3ac>
20364e4: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
20364e8: f0 06 60 08 ld [ %i1 + 8 ], %i0
20364ec: 80 a6 20 04 cmp %i0, 4
20364f0: 38 80 00 08 bgu,a 2036510 <rtems_rfs_block_map_grow+0xa4>
20364f4: e4 07 60 34 ld [ %i5 + 0x34 ], %l2
map->blocks[map->size.count] = block;
20364f8: c2 07 bf f8 ld [ %fp + -8 ], %g1
20364fc: b0 06 20 08 add %i0, 8, %i0
2036500: b1 2e 20 02 sll %i0, 2, %i0
2036504: b0 06 40 18 add %i1, %i0, %i0
2036508: 10 80 00 b5 b 20367dc <rtems_rfs_block_map_grow+0x370>
203650c: c2 26 20 04 st %g1, [ %i0 + 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;
2036510: 90 10 00 18 mov %i0, %o0
2036514: 40 00 94 7b call 205b700 <.urem>
2036518: 92 10 00 12 mov %l2, %o1
singly = map->size.count / fs->blocks_per_block;
203651c: 92 10 00 12 mov %l2, %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;
2036520: a2 10 00 08 mov %o0, %l1
singly = map->size.count / fs->blocks_per_block;
2036524: 40 00 93 cb call 205b450 <.udiv>
2036528: 90 10 00 18 mov %i0, %o0
if (map->size.count < fs->block_map_singly_blocks)
203652c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
2036530: 80 a6 00 01 cmp %i0, %g1
2036534: 1a 80 00 1d bcc 20365a8 <rtems_rfs_block_map_grow+0x13c> <== NEVER TAKEN
2036538: 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) ||
203653c: 80 a4 60 00 cmp %l1, 0
2036540: 22 80 00 07 be,a 203655c <rtems_rfs_block_map_grow+0xf0> <== NEVER TAKEN
2036544: 82 1e 20 05 xor %i0, 5, %g1 <== NOT EXECUTED
2036548: 80 a4 60 05 cmp %l1, 5
203654c: 12 80 00 10 bne 203658c <rtems_rfs_block_map_grow+0x120>
2036550: 80 a2 20 00 cmp %o0, 0
2036554: 12 80 00 0e bne 203658c <rtems_rfs_block_map_grow+0x120> <== NEVER TAKEN
2036558: 82 1e 20 05 xor %i0, 5, %g1
/*
* 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,
203655c: 80 a0 00 01 cmp %g0, %g1
2036560: 96 05 a0 08 add %l6, 8, %o3
2036564: 90 10 00 1d mov %i5, %o0
2036568: 97 2a e0 02 sll %o3, 2, %o3
203656c: 92 10 00 19 mov %i1, %o1
2036570: 96 06 40 0b add %i1, %o3, %o3
2036574: 94 10 00 1c mov %i4, %o2
2036578: 96 02 e0 04 add %o3, 4, %o3
203657c: 7f ff fd 9a call 2035be4 <rtems_rfs_block_map_indirect_alloc>
2036580: 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)
2036584: 10 80 00 78 b 2036764 <rtems_rfs_block_map_grow+0x2f8>
2036588: b0 92 20 00 orcc %o0, 0, %i0
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
203658c: ac 05 a0 08 add %l6, 8, %l6
2036590: 90 10 00 1d mov %i5, %o0
2036594: ad 2d a0 02 sll %l6, 2, %l6
2036598: 92 10 00 1c mov %i4, %o1
203659c: ac 06 40 16 add %i1, %l6, %l6
20365a0: 10 80 00 6e b 2036758 <rtems_rfs_block_map_grow+0x2ec>
20365a4: 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;
20365a8: 40 00 93 aa call 205b450 <.udiv> <== NOT EXECUTED
20365ac: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
20365b0: 92 10 00 12 mov %l2, %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;
20365b4: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
singly %= fs->blocks_per_block;
20365b8: 40 00 94 52 call 205b700 <.urem> <== NOT EXECUTED
20365bc: 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)
20365c0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
20365c4: 12 80 00 49 bne 20366e8 <rtems_rfs_block_map_grow+0x27c> <== NOT EXECUTED
20365c8: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
20365cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20365d0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20365d4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
20365d8: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
20365dc: 7f ff fd 82 call 2035be4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
20365e0: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
20365e4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20365e8: 14 80 00 62 bg 2036770 <rtems_rfs_block_map_grow+0x304> <== NOT EXECUTED
20365ec: 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) ||
20365f0: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
20365f4: 22 80 00 08 be,a 2036614 <rtems_rfs_block_map_grow+0x1a8><== NOT EXECUTED
20365f8: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
20365fc: 80 a4 a0 05 cmp %l2, 5 <== NOT EXECUTED
2036600: 12 80 00 13 bne 203664c <rtems_rfs_block_map_grow+0x1e0> <== NOT EXECUTED
2036604: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
2036608: 32 80 00 12 bne,a 2036650 <rtems_rfs_block_map_grow+0x1e4><== NOT EXECUTED
203660c: 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;
2036610: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
2036614: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
2036618: 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;
203661c: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
2036620: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2036624: 97 2a e0 02 sll %o3, 2, %o3 <== NOT EXECUTED
2036628: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203662c: 96 06 40 0b add %i1, %o3, %o3 <== NOT EXECUTED
2036630: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2036634: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
2036638: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
203663c: 7f ff fd 6a call 2035be4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
2036640: 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)
2036644: 10 80 00 0b b 2036670 <rtems_rfs_block_map_grow+0x204> <== NOT EXECUTED
2036648: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
203664c: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
2036650: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
2036654: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
2036658: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
203665c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036660: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2036664: 40 00 02 14 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2036668: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
203666c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2036670: 24 80 00 08 ble,a 2036690 <rtems_rfs_block_map_grow+0x224><== NOT EXECUTED
2036674: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
2036678: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
203667c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036680: 40 00 12 a2 call 203b108 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
2036684: 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);
2036688: 10 80 00 3a b 2036770 <rtems_rfs_block_map_grow+0x304> <== NOT EXECUTED
203668c: 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,
2036690: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
2036694: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2036698: a5 2c a0 02 sll %l2, 2, %l2 <== NOT EXECUTED
203669c: c4 28 40 12 stb %g2, [ %g1 + %l2 ] <== NOT EXECUTED
20366a0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
20366a4: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
20366a8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
20366ac: 82 00 40 12 add %g1, %l2, %g1 <== NOT EXECUTED
20366b0: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
20366b4: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
20366b8: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
20366bc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
20366c0: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
20366c4: 82 00 40 12 add %g1, %l2, %g1 <== NOT EXECUTED
20366c8: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
20366cc: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
20366d0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
20366d4: a4 00 40 12 add %g1, %l2, %l2 <== NOT EXECUTED
20366d8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
20366dc: c2 2c a0 03 stb %g1, [ %l2 + 3 ] <== NOT EXECUTED
20366e0: 10 80 00 29 b 2036784 <rtems_rfs_block_map_grow+0x318> <== NOT EXECUTED
20366e4: ea 2e 60 44 stb %l5, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
20366e8: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
20366ec: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
20366f0: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
20366f4: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
20366f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20366fc: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2036700: 40 00 01 ed call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2036704: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
2036708: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203670c: 14 80 00 19 bg 2036770 <rtems_rfs_block_map_grow+0x304> <== NOT EXECUTED
2036710: 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,
2036714: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
2036718: a5 2c a0 02 sll %l2, 2, %l2 <== NOT EXECUTED
203671c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036720: 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,
2036724: 82 00 80 12 add %g2, %l2, %g1 <== NOT EXECUTED
2036728: d4 08 80 12 ldub [ %g2 + %l2 ], %o2 <== NOT EXECUTED
203672c: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED
2036730: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
2036734: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
2036738: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED
203673c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2036740: 94 10 c0 0a or %g3, %o2, %o2 <== NOT EXECUTED
2036744: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
2036748: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
203674c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
2036750: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
2036754: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036758: 40 00 01 d7 call 2036eb4 <rtems_rfs_buffer_handle_request>
203675c: 96 10 20 01 mov 1, %o3
singly_block, true);
if (rc > 0)
2036760: b0 92 20 00 orcc %o0, 0, %i0
2036764: 24 80 00 09 ble,a 2036788 <rtems_rfs_block_map_grow+0x31c><== ALWAYS TAKEN
2036768: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
{
rtems_rfs_group_bitmap_free (fs, false, block);
203676c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
2036770: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036774: 40 00 12 65 call 203b108 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
2036778: 92 10 20 00 clr %o1 <== NOT EXECUTED
return rc;
203677c: 81 c7 e0 08 ret <== NOT EXECUTED
2036780: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
2036784: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
2036788: c4 0f bf f8 ldub [ %fp + -8 ], %g2
203678c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2036790: a3 2c 60 02 sll %l1, 2, %l1
2036794: c4 28 40 11 stb %g2, [ %g1 + %l1 ]
2036798: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
203679c: c4 17 bf f8 lduh [ %fp + -8 ], %g2
20367a0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20367a4: 82 00 40 11 add %g1, %l1, %g1
20367a8: c4 28 60 01 stb %g2, [ %g1 + 1 ]
20367ac: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
20367b0: c4 07 bf f8 ld [ %fp + -8 ], %g2
20367b4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20367b8: 85 30 a0 08 srl %g2, 8, %g2
20367bc: 82 00 40 11 add %g1, %l1, %g1
20367c0: c4 28 60 02 stb %g2, [ %g1 + 2 ]
20367c4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
20367c8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20367cc: a2 00 40 11 add %g1, %l1, %l1
20367d0: c2 07 bf f8 ld [ %fp + -8 ], %g1
20367d4: c2 2c 60 03 stb %g1, [ %l1 + 3 ]
20367d8: ea 2e 60 38 stb %l5, [ %i1 + 0x38 ]
}
map->size.count++;
20367dc: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
20367e0: c0 26 60 0c clr [ %i1 + 0xc ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
20367e4: 82 00 60 01 inc %g1
20367e8: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
if (b == 0)
20367ec: 80 a4 20 00 cmp %l0, 0
20367f0: 12 80 00 03 bne 20367fc <rtems_rfs_block_map_grow+0x390> <== NEVER TAKEN
20367f4: c2 07 bf f8 ld [ %fp + -8 ], %g1
*new_block = block;
20367f8: c2 26 c0 00 st %g1, [ %i3 ]
map->last_data_block = block;
20367fc: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
map->dirty = true;
2036800: ea 2e 40 00 stb %l5, [ %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++)
2036804: a0 04 20 01 inc %l0
2036808: 80 a4 00 1a cmp %l0, %i2
203680c: 32 bf ff 30 bne,a 20364cc <rtems_rfs_block_map_grow+0x60>
2036810: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
2036814: b0 10 20 00 clr %i0
}
2036818: 81 c7 e0 08 ret
203681c: 81 e8 00 00 restore
02035be4 <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)
{
2035be4: 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);
2035be8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
2035bec: 90 10 00 18 mov %i0, %o0
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)
{
2035bf0: ba 10 00 18 mov %i0, %i5
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);
2035bf4: 94 10 20 00 clr %o2
2035bf8: 40 00 14 c4 call 203af08 <rtems_rfs_group_bitmap_alloc>
2035bfc: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
2035c00: b0 92 20 00 orcc %o0, 0, %i0
2035c04: 14 80 00 0c bg 2035c34 <rtems_rfs_block_map_indirect_alloc+0x50><== NEVER TAKEN
2035c08: d4 07 bf fc ld [ %fp + -4 ], %o2
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
2035c0c: 90 10 00 1d mov %i5, %o0
2035c10: 92 10 00 1a mov %i2, %o1
2035c14: 40 00 04 a8 call 2036eb4 <rtems_rfs_buffer_handle_request>
2035c18: 96 10 20 00 clr %o3
if (rc > 0)
2035c1c: b0 92 20 00 orcc %o0, 0, %i0
2035c20: 04 80 00 07 ble 2035c3c <rtems_rfs_block_map_indirect_alloc+0x58><== ALWAYS TAKEN
2035c24: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
2035c28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2035c2c: 40 00 15 37 call 203b108 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
2035c30: 92 10 20 00 clr %o1 <== NOT EXECUTED
return rc;
2035c34: 81 c7 e0 08 ret <== NOT EXECUTED
2035c38: 81 e8 00 00 restore <== NOT EXECUTED
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
2035c3c: c2 06 a0 08 ld [ %i2 + 8 ], %g1
2035c40: d4 07 60 08 ld [ %i5 + 8 ], %o2
2035c44: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2035c48: 40 00 3d e3 call 20453d4 <memset>
2035c4c: 92 10 20 ff mov 0xff, %o1
if (upping)
2035c50: 80 a7 20 00 cmp %i4, 0
2035c54: 02 80 00 2d be 2035d08 <rtems_rfs_block_map_indirect_alloc+0x124><== NEVER TAKEN
2035c58: 82 10 20 01 mov 1, %g1
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
2035c5c: 90 10 20 00 clr %o0
2035c60: 7f ff b6 92 call 20236a8 <rtems_rfs_trace>
2035c64: 13 00 00 08 sethi %hi(0x2000), %o1
2035c68: 80 8a 20 ff btst 0xff, %o0
2035c6c: 02 80 00 07 be 2035c88 <rtems_rfs_block_map_indirect_alloc+0xa4><== ALWAYS TAKEN
2035c70: 84 10 00 19 mov %i1, %g2
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
2035c74: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2035c78: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2035c7c: 40 00 42 42 call 2046584 <printf> <== NOT EXECUTED
2035c80: 90 12 20 b8 or %o0, 0xb8, %o0 ! 2066cb8 <__FUNCTION__.7646+0x30><== NOT EXECUTED
2035c84: 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)
{
2035c88: 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]);
2035c8c: 86 10 20 01 mov 1, %g3
2035c90: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2035c94: fa 08 a0 24 ldub [ %g2 + 0x24 ], %i5
2035c98: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
2035c9c: fa 29 00 01 stb %i5, [ %g4 + %g1 ]
2035ca0: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2035ca4: fa 10 a0 24 lduh [ %g2 + 0x24 ], %i5
2035ca8: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
2035cac: 88 01 00 01 add %g4, %g1, %g4
2035cb0: fa 29 20 01 stb %i5, [ %g4 + 1 ]
2035cb4: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2035cb8: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
2035cbc: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
2035cc0: bb 37 60 08 srl %i5, 8, %i5
2035cc4: 88 01 00 01 add %g4, %g1, %g4
2035cc8: fa 29 20 02 stb %i5, [ %g4 + 2 ]
2035ccc: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2035cd0: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
2035cd4: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
2035cd8: 84 00 a0 04 add %g2, 4, %g2
2035cdc: 88 01 00 01 add %g4, %g1, %g4
2035ce0: fa 29 20 03 stb %i5, [ %g4 + 3 ]
2035ce4: 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++)
2035ce8: 80 a0 60 14 cmp %g1, 0x14
2035cec: 12 bf ff e9 bne 2035c90 <rtems_rfs_block_map_indirect_alloc+0xac>
2035cf0: c6 2e 80 00 stb %g3, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
2035cf4: 90 06 60 24 add %i1, 0x24, %o0
2035cf8: 92 10 20 00 clr %o1
2035cfc: 40 00 3d b6 call 20453d4 <memset>
2035d00: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
2035d04: 82 10 20 01 mov 1, %g1
2035d08: c2 2e 80 00 stb %g1, [ %i2 ]
*block = new_block;
2035d0c: c2 07 bf fc ld [ %fp + -4 ], %g1
map->last_map_block = new_block;
return 0;
2035d10: b0 10 20 00 clr %i0
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;
2035d14: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
2035d18: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
}
2035d1c: 81 c7 e0 08 ret
2035d20: 81 e8 00 00 restore
02035b08 <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)
{
2035b08: 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) ||
2035b0c: 80 a7 20 00 cmp %i4, 0
2035b10: 02 80 00 08 be 2035b30 <rtems_rfs_block_map_indirect_shrink+0x28><== NEVER TAKEN
2035b14: 90 10 00 18 mov %i0, %o0
2035b18: 80 a7 20 05 cmp %i4, 5
2035b1c: 32 80 00 2f bne,a 2035bd8 <rtems_rfs_block_map_indirect_shrink+0xd0>
2035b20: 90 10 20 00 clr %o0
2035b24: 80 a6 e0 00 cmp %i3, 0
2035b28: 32 80 00 2c bne,a 2035bd8 <rtems_rfs_block_map_indirect_shrink+0xd0><== NEVER TAKEN
2035b2c: 90 10 20 00 clr %o0 <== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
2035b30: 82 06 e0 08 add %i3, 8, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
2035b34: 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];
2035b38: 83 28 60 02 sll %g1, 2, %g1
2035b3c: 82 06 40 01 add %i1, %g1, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
2035b40: 12 80 00 1a bne 2035ba8 <rtems_rfs_block_map_indirect_shrink+0xa0><== NEVER TAKEN
2035b44: fa 00 60 04 ld [ %g1 + 4 ], %i5
2035b48: 80 a6 e0 00 cmp %i3, 0
2035b4c: 32 80 00 18 bne,a 2035bac <rtems_rfs_block_map_indirect_shrink+0xa4><== NEVER TAKEN
2035b50: 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);
2035b54: c2 06 a0 08 ld [ %i2 + 8 ], %g1
2035b58: 84 10 20 00 clr %g2
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
2035b5c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
/*
* 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);
2035b60: f8 08 40 00 ldub [ %g1 ], %i4
2035b64: c8 08 60 01 ldub [ %g1 + 1 ], %g4
2035b68: b9 2f 20 18 sll %i4, 0x18, %i4
2035b6c: 89 29 20 10 sll %g4, 0x10, %g4
2035b70: 88 17 00 04 or %i4, %g4, %g4
2035b74: 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,
2035b78: 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);
2035b7c: 88 11 00 1c or %g4, %i4, %g4
2035b80: f8 08 60 02 ldub [ %g1 + 2 ], %i4
2035b84: 84 00 a0 04 add %g2, 4, %g2
2035b88: b9 2f 20 08 sll %i4, 8, %i4
2035b8c: 88 11 00 1c or %g4, %i4, %g4
2035b90: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
2035b94: 80 a0 a0 14 cmp %g2, 0x14
2035b98: 12 bf ff f2 bne 2035b60 <rtems_rfs_block_map_indirect_shrink+0x58>
2035b9c: 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);
2035ba0: 10 80 00 07 b 2035bbc <rtems_rfs_block_map_indirect_shrink+0xb4>
2035ba4: 92 10 20 00 clr %o1
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
2035ba8: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
2035bac: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
2035bb0: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
2035bb4: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
2035bb8: 92 10 20 00 clr %o1 <== NOT EXECUTED
2035bbc: 40 00 15 53 call 203b108 <rtems_rfs_group_bitmap_free>
2035bc0: 94 10 00 1d mov %i5, %o2
if (rc > 0)
2035bc4: 80 a2 20 00 cmp %o0, 0
2035bc8: 24 80 00 04 ble,a 2035bd8 <rtems_rfs_block_map_indirect_shrink+0xd0><== ALWAYS TAKEN
2035bcc: fa 26 60 1c st %i5, [ %i1 + 0x1c ]
map->last_map_block = block_to_free;
}
return rc;
}
2035bd0: 81 c7 e0 08 ret <== NOT EXECUTED
2035bd4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
2035bd8: b0 10 00 08 mov %o0, %i0
2035bdc: 81 c7 e0 08 ret
2035be0: 81 e8 00 00 restore
02035ef8 <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)
{
2035ef8: 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;
2035efc: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
2035f00: 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;
2035f04: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
2035f08: 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;
2035f0c: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
2035f10: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
2035f14: 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;
2035f18: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
2035f1c: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
2035f20: 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;
2035f24: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
2035f28: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
2035f2c: 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);
2035f30: 90 10 00 18 mov %i0, %o0
2035f34: 40 00 15 18 call 203b394 <rtems_rfs_inode_load>
2035f38: 92 10 00 19 mov %i1, %o1
if (rc > 0)
2035f3c: ba 92 20 00 orcc %o0, 0, %i5
2035f40: 24 80 00 11 ble,a 2035f84 <rtems_rfs_block_map_open+0x8c><== ALWAYS TAKEN
2035f44: c2 06 60 0c ld [ %i1 + 0xc ], %g1
*/
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);
2035f48: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
2035f4c: 40 00 03 68 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2035f50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2035f54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2035f58: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
2035f5c: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
2035f60: 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);
2035f64: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
2035f68: 40 00 03 61 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2035f6c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
handle->dirty = false;
2035f70: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
2035f74: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
2035f78: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
2035f7c: 81 c7 e0 08 ret <== NOT EXECUTED
2035f80: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
2035f84: f2 26 a0 04 st %i1, [ %i2 + 4 ]
* @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]);
2035f88: 84 00 60 1c add %g1, 0x1c, %g2
2035f8c: 88 10 00 1a mov %i2, %g4
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
2035f90: 86 10 20 00 clr %g3
2035f94: de 08 a0 03 ldub [ %g2 + 3 ], %o7
2035f98: ba 00 e0 06 add %g3, 6, %i5
2035f9c: bb 2f 60 02 sll %i5, 2, %i5
2035fa0: ba 00 40 1d add %g1, %i5, %i5
2035fa4: fa 0f 60 04 ldub [ %i5 + 4 ], %i5
2035fa8: 86 00 e0 01 inc %g3
2035fac: bb 2f 60 18 sll %i5, 0x18, %i5
2035fb0: ba 13 c0 1d or %o7, %i5, %i5
2035fb4: de 08 a0 01 ldub [ %g2 + 1 ], %o7
2035fb8: 80 a0 e0 05 cmp %g3, 5
2035fbc: 9f 2b e0 10 sll %o7, 0x10, %o7
2035fc0: ba 17 40 0f or %i5, %o7, %i5
2035fc4: de 08 a0 02 ldub [ %g2 + 2 ], %o7
2035fc8: 84 00 a0 04 add %g2, 4, %g2
2035fcc: 9f 2b e0 08 sll %o7, 8, %o7
2035fd0: ba 17 40 0f or %i5, %o7, %i5
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
2035fd4: fa 21 20 24 st %i5, [ %g4 + 0x24 ]
/*
* 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++)
2035fd8: 12 bf ff ef bne 2035f94 <rtems_rfs_block_map_open+0x9c>
2035fdc: 88 01 20 04 add %g4, 4, %g4
* @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);
2035fe0: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2035fe4: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
2035fe8: 87 28 e0 18 sll %g3, 0x18, %g3
2035fec: 85 28 a0 10 sll %g2, 0x10, %g2
2035ff0: 84 10 c0 02 or %g3, %g2, %g2
2035ff4: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
2035ff8: 84 10 80 03 or %g2, %g3, %g2
2035ffc: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
2036000: 87 28 e0 08 sll %g3, 8, %g3
2036004: 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);
2036008: c4 26 a0 08 st %g2, [ %i2 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
203600c: 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);
2036010: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
2036014: 85 28 a0 08 sll %g2, 8, %g2
2036018: 84 10 c0 02 or %g3, %g2, %g2
203601c: 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);
2036020: c6 08 60 30 ldub [ %g1 + 0x30 ], %g3
2036024: c4 08 60 31 ldub [ %g1 + 0x31 ], %g2
2036028: 87 28 e0 18 sll %g3, 0x18, %g3
203602c: 85 28 a0 10 sll %g2, 0x10, %g2
2036030: 84 10 c0 02 or %g3, %g2, %g2
2036034: c6 08 60 33 ldub [ %g1 + 0x33 ], %g3
2036038: 84 10 80 03 or %g2, %g3, %g2
203603c: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
2036040: 87 28 e0 08 sll %g3, 8, %g3
2036044: 84 10 80 03 or %g2, %g3, %g2
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
2036048: 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);
203604c: c4 08 60 35 ldub [ %g1 + 0x35 ], %g2
2036050: c6 08 60 34 ldub [ %g1 + 0x34 ], %g3
2036054: 85 28 a0 10 sll %g2, 0x10, %g2
2036058: 87 28 e0 18 sll %g3, 0x18, %g3
203605c: 86 10 c0 02 or %g3, %g2, %g3
2036060: c4 08 60 37 ldub [ %g1 + 0x37 ], %g2
2036064: 86 10 c0 02 or %g3, %g2, %g3
2036068: c4 08 60 36 ldub [ %g1 + 0x36 ], %g2
203606c: 85 28 a0 08 sll %g2, 8, %g2
2036070: 82 10 c0 02 or %g3, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
2036074: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
2036078: 40 00 15 29 call 203b51c <rtems_rfs_inode_unload>
203607c: 95 e8 20 00 restore %g0, 0, %o2
02036820 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
2036820: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
2036824: 90 10 20 00 clr %o0
2036828: 13 00 00 10 sethi %hi(0x4000), %o1
203682c: 7f ff b3 9f call 20236a8 <rtems_rfs_trace>
2036830: ba 10 00 18 mov %i0, %i5
2036834: 80 8a 20 ff btst 0xff, %o0
2036838: 22 80 00 08 be,a 2036858 <rtems_rfs_block_map_shrink+0x38><== ALWAYS TAKEN
203683c: c2 06 60 08 ld [ %i1 + 8 ], %g1
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
2036840: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
2036844: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036848: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
203684c: 40 00 3f 4e call 2046584 <printf> <== NOT EXECUTED
2036850: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
2036854: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
2036858: 80 a0 60 00 cmp %g1, 0
203685c: 02 80 00 be be 2036b54 <rtems_rfs_block_map_shrink+0x334>
2036860: 90 10 20 00 clr %o0
2036864: 80 a6 80 01 cmp %i2, %g1
2036868: 38 80 00 95 bgu,a 2036abc <rtems_rfs_block_map_shrink+0x29c><== NEVER TAKEN
203686c: 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,
2036870: 10 80 00 94 b 2036ac0 <rtems_rfs_block_map_shrink+0x2a0>
2036874: a0 06 60 44 add %i1, 0x44, %l0
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
2036878: a4 00 7f ff add %g1, -1, %l2
if (block < RTEMS_RFS_INODE_BLOCKS)
203687c: 80 a4 a0 04 cmp %l2, 4
2036880: 38 80 00 08 bgu,a 20368a0 <rtems_rfs_block_map_shrink+0x80>
2036884: f8 07 60 34 ld [ %i5 + 0x34 ], %i4
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
2036888: 82 00 60 07 add %g1, 7, %g1
203688c: 83 28 60 02 sll %g1, 2, %g1
2036890: 82 06 40 01 add %i1, %g1, %g1
2036894: f8 00 60 04 ld [ %g1 + 4 ], %i4
map->blocks[block] = 0;
2036898: 10 80 00 7b b 2036a84 <rtems_rfs_block_map_shrink+0x264>
203689c: 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;
20368a0: 90 10 00 12 mov %l2, %o0
20368a4: 40 00 93 97 call 205b700 <.urem>
20368a8: 92 10 00 1c mov %i4, %o1
singly = block / fs->blocks_per_block;
20368ac: 92 10 00 1c mov %i4, %o1
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
20368b0: aa 10 00 08 mov %o0, %l5
singly = block / fs->blocks_per_block;
20368b4: 40 00 92 e7 call 205b450 <.udiv>
20368b8: 90 10 00 12 mov %l2, %o0
if (block < fs->block_map_singly_blocks)
20368bc: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
20368c0: 80 a4 80 01 cmp %l2, %g1
20368c4: 1a 80 00 26 bcc 203695c <rtems_rfs_block_map_shrink+0x13c><== NEVER TAKEN
20368c8: ac 10 00 08 mov %o0, %l6
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
20368cc: 82 02 20 08 add %o0, 8, %g1
20368d0: 83 28 60 02 sll %g1, 2, %g1
20368d4: 82 06 40 01 add %i1, %g1, %g1
20368d8: d4 00 60 04 ld [ %g1 + 4 ], %o2
20368dc: 90 10 00 1d mov %i5, %o0
20368e0: 92 10 00 1b mov %i3, %o1
20368e4: 40 00 01 74 call 2036eb4 <rtems_rfs_buffer_handle_request>
20368e8: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
20368ec: 80 a2 20 00 cmp %o0, 0
20368f0: 14 80 00 99 bg 2036b54 <rtems_rfs_block_map_shrink+0x334> <== NEVER TAKEN
20368f4: 92 10 00 19 mov %i1, %o1
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
20368f8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
20368fc: 90 10 00 1d mov %i5, %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,
2036900: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
2036904: 83 2d 60 02 sll %l5, 2, %g1
2036908: e8 08 80 01 ldub [ %g2 + %g1 ], %l4
203690c: 82 00 80 01 add %g2, %g1, %g1
2036910: e6 08 60 01 ldub [ %g1 + 1 ], %l3
2036914: e4 08 60 02 ldub [ %g1 + 2 ], %l2
2036918: f8 08 60 03 ldub [ %g1 + 3 ], %i4
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
203691c: 94 10 00 1b mov %i3, %o2
2036920: 96 10 00 16 mov %l6, %o3
2036924: 7f ff fc 79 call 2035b08 <rtems_rfs_block_map_indirect_shrink>
2036928: 98 10 00 15 mov %l5, %o4
singly, direct);
if (rc)
203692c: 80 a2 20 00 cmp %o0, 0
2036930: 12 80 00 89 bne 2036b54 <rtems_rfs_block_map_shrink+0x334><== NEVER TAKEN
2036934: b8 0f 20 ff and %i4, 0xff, %i4
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,
2036938: a9 2d 20 18 sll %l4, 0x18, %l4
203693c: a6 0c e0 ff and %l3, 0xff, %l3
2036940: b8 17 00 14 or %i4, %l4, %i4
2036944: a7 2c e0 10 sll %l3, 0x10, %l3
2036948: a4 0c a0 ff and %l2, 0xff, %l2
203694c: b8 17 00 13 or %i4, %l3, %i4
2036950: a5 2c a0 08 sll %l2, 8, %l2
2036954: 10 80 00 4c b 2036a84 <rtems_rfs_block_map_shrink+0x264>
2036958: b8 17 00 12 or %i4, %l2, %i4
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
203695c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
2036960: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED
2036964: 3a 80 00 5c bcc,a 2036ad4 <rtems_rfs_block_map_shrink+0x2b4><== NOT EXECUTED
2036968: 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;
203696c: 40 00 92 b9 call 205b450 <.udiv> <== NOT EXECUTED
2036970: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
2036974: 82 02 20 08 add %o0, 8, %g1 <== NOT EXECUTED
2036978: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
203697c: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
2036980: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== 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;
2036984: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
2036988: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203698c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036990: 40 00 01 49 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2036994: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
2036998: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
203699c: 14 80 00 6e bg 2036b54 <rtems_rfs_block_map_shrink+0x334> <== NOT EXECUTED
20369a0: 92 10 00 1c mov %i4, %o1 <== 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;
20369a4: 40 00 93 57 call 205b700 <.urem> <== NOT EXECUTED
20369a8: 90 10 00 16 mov %l6, %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,
20369ac: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
20369b0: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED
20369b4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== 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;
20369b8: a6 10 00 08 mov %o0, %l3 <== 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,
20369bc: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
20369c0: e4 08 c0 02 ldub [ %g3 + %g2 ], %l2 <== NOT EXECUTED
20369c4: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
20369c8: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
20369cc: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
20369d0: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
20369d4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
20369d8: a5 2c a0 18 sll %l2, 0x18, %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,
20369dc: 90 10 00 1d mov %i5, %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,
20369e0: a4 11 00 12 or %g4, %l2, %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,
20369e4: 92 10 00 1b mov %i3, %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,
20369e8: a4 14 80 02 or %l2, %g2, %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,
20369ec: 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,
20369f0: a4 14 80 01 or %l2, %g1, %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,
20369f4: 40 00 01 30 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
20369f8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
20369fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2036a00: 14 80 00 55 bg 2036b54 <rtems_rfs_block_map_shrink+0x334> <== NOT EXECUTED
2036a04: 85 2d 60 02 sll %l5, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
2036a08: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
2036a0c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
2036a10: 80 a5 60 00 cmp %l5, 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,
2036a14: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
2036a18: f8 08 c0 02 ldub [ %g3 + %g2 ], %i4 <== NOT EXECUTED
2036a1c: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
2036a20: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
2036a24: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
2036a28: b9 2f 20 18 sll %i4, 0x18, %i4 <== NOT EXECUTED
2036a2c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2036a30: b8 11 00 1c or %g4, %i4, %i4 <== NOT EXECUTED
2036a34: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
2036a38: b8 17 00 02 or %i4, %g2, %i4 <== NOT EXECUTED
direct);
if (direct == 0)
2036a3c: 12 80 00 12 bne 2036a84 <rtems_rfs_block_map_shrink+0x264><== NOT EXECUTED
2036a40: b8 17 00 01 or %i4, %g1, %i4 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
2036a44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036a48: 92 10 20 00 clr %o1 <== NOT EXECUTED
2036a4c: 40 00 11 af call 203b108 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
2036a50: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
if (rc > 0)
2036a54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2036a58: 14 80 00 3f bg 2036b54 <rtems_rfs_block_map_shrink+0x334> <== NOT EXECUTED
2036a5c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
2036a60: e4 26 60 1c st %l2, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
2036a64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036a68: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2036a6c: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
2036a70: 7f ff fc 26 call 2035b08 <rtems_rfs_block_map_indirect_shrink><== NOT EXECUTED
2036a74: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
2036a78: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2036a7c: 12 80 00 36 bne 2036b54 <rtems_rfs_block_map_shrink+0x334><== NOT EXECUTED
2036a80: 01 00 00 00 nop <== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
2036a84: 90 10 00 1d mov %i5, %o0
2036a88: 92 10 20 00 clr %o1
2036a8c: 40 00 11 9f call 203b108 <rtems_rfs_group_bitmap_free>
2036a90: 94 10 00 1c mov %i4, %o2
if (rc > 0)
2036a94: 80 a2 20 00 cmp %o0, 0
2036a98: 14 80 00 2f bg 2036b54 <rtems_rfs_block_map_shrink+0x334> <== NEVER TAKEN
2036a9c: b4 06 bf ff add %i2, -1, %i2
return rc;
map->size.count--;
2036aa0: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
2036aa4: 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--;
2036aa8: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
map->last_data_block = block_to_free;
2036aac: f8 26 60 20 st %i4, [ %i1 + 0x20 ]
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
2036ab0: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
2036ab4: 10 80 00 05 b 2036ac8 <rtems_rfs_block_map_shrink+0x2a8>
2036ab8: e2 2e 40 00 stb %l1, [ %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,
2036abc: a0 06 60 44 add %i1, 0x44, %l0 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036ac0: b6 06 60 38 add %i1, 0x38, %i3
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
2036ac4: a2 10 20 01 mov 1, %l1
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
2036ac8: 80 a6 a0 00 cmp %i2, 0
2036acc: 12 bf ff 6b bne 2036878 <rtems_rfs_block_map_shrink+0x58>
2036ad0: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
2036ad4: 80 a0 60 00 cmp %g1, 0
2036ad8: 32 80 00 05 bne,a 2036aec <rtems_rfs_block_map_shrink+0x2cc><== NEVER TAKEN
2036adc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED
{
map->last_map_block = 0;
2036ae0: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
2036ae4: c0 26 60 20 clr [ %i1 + 0x20 ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
2036ae8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
2036aec: 80 a0 a0 00 cmp %g2, 0
2036af0: 02 80 00 06 be 2036b08 <rtems_rfs_block_map_shrink+0x2e8> <== ALWAYS TAKEN
2036af4: 80 a0 80 01 cmp %g2, %g1
2036af8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2036afc: 22 80 00 0e be,a 2036b34 <rtems_rfs_block_map_shrink+0x314><== NOT EXECUTED
2036b00: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
2036b04: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2036b08: 3a 80 00 0b bcc,a 2036b34 <rtems_rfs_block_map_shrink+0x314><== ALWAYS TAKEN
2036b0c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
2036b10: 86 00 7f ff add %g1, -1, %g3 <== NOT EXECUTED
2036b14: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
2036b18: 12 80 00 0f bne 2036b54 <rtems_rfs_block_map_shrink+0x334><== NOT EXECUTED
2036b1c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2036b20: c6 06 60 14 ld [ %i1 + 0x14 ], %g3 <== NOT EXECUTED
2036b24: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
2036b28: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
2036b2c: 08 80 00 0a bleu 2036b54 <rtems_rfs_block_map_shrink+0x334><== NOT EXECUTED
2036b30: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
2036b34: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
2036b38: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
2036b3c: c0 26 60 18 clr [ %i1 + 0x18 ]
2036b40: 80 a0 a0 00 cmp %g2, 0
2036b44: 02 80 00 04 be 2036b54 <rtems_rfs_block_map_shrink+0x334> <== ALWAYS TAKEN
2036b48: 90 10 20 00 clr %o0
2036b4c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2036b50: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
}
2036b54: 81 c7 e0 08 ret
2036b58: 91 e8 00 08 restore %g0, %o0, %o0
020415d8 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
20415d8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
20415dc: 90 10 20 00 clr %o0
20415e0: 7f ff 88 32 call 20236a8 <rtems_rfs_trace>
20415e4: 92 10 20 40 mov 0x40, %o1
20415e8: 80 8a 20 ff btst 0xff, %o0
20415ec: 02 80 00 0d be 2041620 <rtems_rfs_buffer_bdbuf_release+0x48><== ALWAYS TAKEN
20415f0: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
20415f4: 17 00 81 81 sethi %hi(0x2060400), %o3 <== NOT EXECUTED
20415f8: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
20415fc: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
2041600: 02 80 00 04 be 2041610 <rtems_rfs_buffer_bdbuf_release+0x38><== NOT EXECUTED
2041604: 96 12 e2 60 or %o3, 0x260, %o3 <== NOT EXECUTED
2041608: 17 00 81 a6 sethi %hi(0x2069800), %o3 <== NOT EXECUTED
204160c: 96 12 e0 e8 or %o3, 0xe8, %o3 ! 20698e8 <msdos_map+0x100> <== NOT EXECUTED
2041610: 11 00 81 a6 sethi %hi(0x2069800), %o0 <== NOT EXECUTED
2041614: 40 00 13 dc call 2046584 <printf> <== NOT EXECUTED
2041618: 90 12 20 f8 or %o0, 0xf8, %o0 ! 20698f8 <msdos_map+0x110> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
204161c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2041620: 02 80 00 06 be 2041638 <rtems_rfs_buffer_bdbuf_release+0x60>
2041624: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
2041628: 7f ff 13 d4 call 2006578 <rtems_bdbuf_release_modified>
204162c: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
2041630: 10 80 00 05 b 2041644 <rtems_rfs_buffer_bdbuf_release+0x6c>
2041634: 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);
2041638: 7f ff 13 97 call 2006494 <rtems_bdbuf_release>
204163c: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
2041640: 80 a0 00 08 cmp %g0, %o0
2041644: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
2041648: b0 0e 20 05 and %i0, 5, %i0
204164c: 81 c7 e0 08 ret
2041650: 81 e8 00 00 restore
020374d0 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
20374d0: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
20374d4: 90 10 20 00 clr %o0
20374d8: 7f ff b0 74 call 20236a8 <rtems_rfs_trace>
20374dc: 92 10 20 10 mov 0x10, %o1
20374e0: 80 8a 20 ff btst 0xff, %o0
20374e4: 22 80 00 06 be,a 20374fc <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
20374e8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
printf ("rtems-rfs: buffer-close: closing\n");
20374ec: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20374f0: 40 00 3c c0 call 20467f0 <puts> <== NOT EXECUTED
20374f4: 90 12 22 48 or %o0, 0x248, %o0 ! 2067248 <__FUNCTION__.7646+0x5c0><== 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));
20374f8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
20374fc: 90 10 00 18 mov %i0, %o0
2037500: 7f ff ff b9 call 20373e4 <rtems_rfs_buffer_setblksize>
2037504: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
2037508: ba 92 20 00 orcc %o0, 0, %i5
203750c: 04 80 00 0e ble 2037544 <rtems_rfs_buffer_close+0x74> <== ALWAYS TAKEN
2037510: 90 10 20 00 clr %o0
2037514: 7f ff b0 65 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037518: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
203751c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037520: 02 80 00 09 be 2037544 <rtems_rfs_buffer_close+0x74> <== NOT EXECUTED
2037524: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
2037528: 40 00 45 d4 call 2048c78 <strerror> <== NOT EXECUTED
203752c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037530: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037534: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037538: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
203753c: 40 00 3c 12 call 2046584 <printf> <== NOT EXECUTED
2037540: 90 12 22 70 or %o0, 0x270, %o0 ! 2067270 <__FUNCTION__.7646+0x5e8><== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
2037544: 7f ff 43 d4 call 2008494 <close>
2037548: d0 06 20 0c ld [ %i0 + 0xc ], %o0
203754c: 80 a2 20 00 cmp %o0, 0
2037550: 16 80 00 12 bge 2037598 <rtems_rfs_buffer_close+0xc8> <== ALWAYS TAKEN
2037554: 01 00 00 00 nop
{
rc = errno;
2037558: 40 00 29 d2 call 2041ca0 <__errno> <== NOT EXECUTED
203755c: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
2037560: 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;
2037564: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
2037568: 7f ff b0 50 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203756c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037570: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037574: 02 80 00 09 be 2037598 <rtems_rfs_buffer_close+0xc8> <== NOT EXECUTED
2037578: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
203757c: 40 00 45 bf call 2048c78 <strerror> <== NOT EXECUTED
2037580: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037584: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037588: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203758c: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037590: 40 00 3b fd call 2046584 <printf> <== NOT EXECUTED
2037594: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 20672b0 <__FUNCTION__.7646+0x628><== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
2037598: 81 c7 e0 08 ret
203759c: 91 e8 00 1d restore %g0, %i5, %o0
02036cec <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
2036cec: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
2036cf0: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
2036cf4: ba 10 00 18 mov %i0, %i5
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
2036cf8: 80 a0 60 00 cmp %g1, 0
2036cfc: 02 80 00 6c be 2036eac <rtems_rfs_buffer_handle_release+0x1c0>
2036d00: b0 10 20 00 clr %i0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
2036d04: 90 10 20 00 clr %o0
2036d08: 7f ff b2 68 call 20236a8 <rtems_rfs_trace>
2036d0c: 92 10 22 00 mov 0x200, %o1
2036d10: 80 8a 20 ff btst 0xff, %o0
2036d14: 22 80 00 16 be,a 2036d6c <rtems_rfs_buffer_handle_release+0x80><== ALWAYS TAKEN
2036d18: d0 06 60 08 ld [ %i1 + 8 ], %o0
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
2036d1c: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
2036d20: 15 00 81 81 sethi %hi(0x2060400), %o2 <== NOT EXECUTED
2036d24: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
2036d28: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2036d2c: 02 80 00 04 be 2036d3c <rtems_rfs_buffer_handle_release+0x50><== NOT EXECUTED
2036d30: 94 12 a2 60 or %o2, 0x260, %o2 <== NOT EXECUTED
2036d34: 15 00 81 9b sethi %hi(0x2066c00), %o2 <== NOT EXECUTED
2036d38: 94 12 a2 38 or %o2, 0x238, %o2 ! 2066e38 <__FUNCTION__.7646+0x1b0><== 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" : "");
2036d3c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== 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",
2036d40: 19 00 81 81 sethi %hi(0x2060400), %o4 <== 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" : "");
2036d44: 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",
2036d48: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
2036d4c: 12 80 00 04 bne 2036d5c <rtems_rfs_buffer_handle_release+0x70><== NOT EXECUTED
2036d50: 98 13 22 60 or %o4, 0x260, %o4 <== NOT EXECUTED
2036d54: 19 00 81 9b sethi %hi(0x2066c00), %o4 <== NOT EXECUTED
2036d58: 98 13 22 40 or %o4, 0x240, %o4 ! 2066e40 <__FUNCTION__.7646+0x1b8><== NOT EXECUTED
2036d5c: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036d60: 40 00 3e 09 call 2046584 <printf> <== NOT EXECUTED
2036d64: 90 12 22 50 or %o0, 0x250, %o0 ! 2066e50 <__FUNCTION__.7646+0x1c8><== 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)
2036d68: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
2036d6c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
2036d70: 80 a0 60 00 cmp %g1, 0
2036d74: 04 80 00 03 ble 2036d80 <rtems_rfs_buffer_handle_release+0x94><== NEVER TAKEN
2036d78: 82 00 7f ff add %g1, -1, %g1
rtems_rfs_buffer_refs_down (handle);
2036d7c: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
2036d80: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
2036d84: 80 a0 60 00 cmp %g1, 0
2036d88: 12 80 00 48 bne 2036ea8 <rtems_rfs_buffer_handle_release+0x1bc>
2036d8c: b0 10 20 00 clr %i0
2036d90: 7f ff 5c 3c call 200de80 <_Chain_Extract>
2036d94: 01 00 00 00 nop
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
2036d98: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (rtems_rfs_fs_no_local_cache (fs))
2036d9c: 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--;
2036da0: 82 00 7f ff add %g1, -1, %g1
if (rtems_rfs_fs_no_local_cache (fs))
2036da4: b0 8e 20 02 andcc %i0, 2, %i0
2036da8: 02 80 00 08 be 2036dc8 <rtems_rfs_buffer_handle_release+0xdc>
2036dac: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
{
handle->buffer->user = (void*) 0;
2036db0: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
2036db4: d2 0e 40 00 ldub [ %i1 ], %o1
2036db8: 40 00 2a 08 call 20415d8 <rtems_rfs_buffer_bdbuf_release>
2036dbc: c0 22 20 34 clr [ %o0 + 0x34 ]
2036dc0: 10 80 00 3a b 2036ea8 <rtems_rfs_buffer_handle_release+0x1bc>
2036dc4: 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 +
2036dc8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2036dcc: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
2036dd0: 84 00 80 01 add %g2, %g1, %g2
2036dd4: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
2036dd8: 80 a0 80 01 cmp %g2, %g1
2036ddc: 2a 80 00 25 bcs,a 2036e70 <rtems_rfs_buffer_handle_release+0x184>
2036de0: 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))
2036de4: 90 10 20 00 clr %o0
2036de8: 7f ff b2 30 call 20236a8 <rtems_rfs_trace>
2036dec: 92 10 22 00 mov 0x200, %o1
2036df0: 80 8a 20 ff btst 0xff, %o0
2036df4: 22 80 00 09 be,a 2036e18 <rtems_rfs_buffer_handle_release+0x12c><== ALWAYS TAKEN
2036df8: c4 07 60 60 ld [ %i5 + 0x60 ], %g2
printf ("rtems-rfs: buffer-release: local cache overflow:"
2036dfc: d2 07 60 70 ld [ %i5 + 0x70 ], %o1 <== NOT EXECUTED
2036e00: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
2036e04: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036e08: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
2036e0c: 40 00 3d de call 2046584 <printf> <== NOT EXECUTED
2036e10: 90 12 22 88 or %o0, 0x288, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
2036e14: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
2036e18: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
2036e1c: 80 a0 80 01 cmp %g2, %g1
2036e20: 08 80 00 09 bleu 2036e44 <rtems_rfs_buffer_handle_release+0x158>
2036e24: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
2036e28: 7f ff 5c 1f call 200dea4 <_Chain_Get>
2036e2c: 90 07 60 54 add %i5, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
2036e30: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
modified = false;
2036e34: 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--;
2036e38: 82 00 7f ff add %g1, -1, %g1
2036e3c: 10 80 00 08 b 2036e5c <rtems_rfs_buffer_handle_release+0x170>
2036e40: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
2036e44: 7f ff 5c 18 call 200dea4 <_Chain_Get>
2036e48: 90 07 60 64 add %i5, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
2036e4c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
modified = true;
2036e50: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
2036e54: 82 00 7f ff add %g1, -1, %g1
2036e58: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
modified = true;
}
buffer->user = (void*) 0;
2036e5c: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
2036e60: 40 00 29 de call 20415d8 <rtems_rfs_buffer_bdbuf_release>
2036e64: 92 0a 60 01 and %o1, 1, %o1
2036e68: b0 10 00 08 mov %o0, %i0
}
if (rtems_rfs_buffer_dirty (handle))
2036e6c: c2 0e 40 00 ldub [ %i1 ], %g1
2036e70: 80 a0 60 00 cmp %g1, 0
2036e74: 02 80 00 08 be 2036e94 <rtems_rfs_buffer_handle_release+0x1a8>
2036e78: 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 );
2036e7c: 7f ff 5b f6 call 200de54 <_Chain_Append>
2036e80: 90 07 60 64 add %i5, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
2036e84: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
2036e88: 82 00 60 01 inc %g1
2036e8c: 10 80 00 07 b 2036ea8 <rtems_rfs_buffer_handle_release+0x1bc>
2036e90: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
2036e94: 7f ff 5b f0 call 200de54 <_Chain_Append>
2036e98: 90 07 60 54 add %i5, 0x54, %o0
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
2036e9c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2036ea0: 82 00 60 01 inc %g1
2036ea4: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
}
}
}
handle->buffer = NULL;
2036ea8: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
2036eac: 81 c7 e0 08 ret
2036eb0: 81 e8 00 00 restore
02036eb4 <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)
{
2036eb4: 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))
2036eb8: c2 06 60 08 ld [ %i1 + 8 ], %g1
2036ebc: 80 a0 60 00 cmp %g1, 0
2036ec0: 02 80 00 1b be 2036f2c <rtems_rfs_buffer_handle_request+0x78>
2036ec4: 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))
2036ec8: 80 a6 a0 00 cmp %i2, 0
2036ecc: 02 80 00 07 be 2036ee8 <rtems_rfs_buffer_handle_request+0x34><== NEVER TAKEN
2036ed0: 90 10 20 00 clr %o0
2036ed4: c2 06 60 04 ld [ %i1 + 4 ], %g1
2036ed8: 80 a0 40 1a cmp %g1, %i2
2036edc: 02 80 00 75 be 20370b0 <rtems_rfs_buffer_handle_request+0x1fc>
2036ee0: b0 10 20 00 clr %i0
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
2036ee4: 90 10 20 00 clr %o0
2036ee8: 7f ff b1 f0 call 20236a8 <rtems_rfs_trace>
2036eec: 92 10 21 00 mov 0x100, %o1
2036ef0: 80 8a 20 ff btst 0xff, %o0
2036ef4: 22 80 00 07 be,a 2036f10 <rtems_rfs_buffer_handle_request+0x5c><== ALWAYS TAKEN
2036ef8: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
2036efc: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
2036f00: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036f04: 40 00 3d a0 call 2046584 <printf> <== NOT EXECUTED
2036f08: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 2066ec8 <__FUNCTION__.7646+0x240><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
2036f0c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036f10: 7f ff ff 77 call 2036cec <rtems_rfs_buffer_handle_release>
2036f14: 92 10 00 19 mov %i1, %o1
if (rc > 0)
2036f18: b0 92 20 00 orcc %o0, 0, %i0
2036f1c: 14 80 00 8a bg 2037144 <rtems_rfs_buffer_handle_request+0x290><== NEVER TAKEN
2036f20: 01 00 00 00 nop
return rc;
handle->dirty = false;
2036f24: c0 2e 40 00 clrb [ %i1 ]
handle->bnum = 0;
2036f28: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
2036f2c: 90 10 20 00 clr %o0
2036f30: 7f ff b1 de call 20236a8 <rtems_rfs_trace>
2036f34: 92 10 21 00 mov 0x100, %o1
2036f38: 80 8a 20 ff btst 0xff, %o0
2036f3c: 22 80 00 07 be,a 2036f58 <rtems_rfs_buffer_handle_request+0xa4><== ALWAYS TAKEN
2036f40: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
2036f44: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036f48: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2036f4c: 40 00 3d 8e call 2046584 <printf> <== NOT EXECUTED
2036f50: 90 12 23 00 or %o0, 0x300, %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)
2036f54: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
2036f58: 80 a0 60 00 cmp %g1, 0
2036f5c: 22 80 00 16 be,a 2036fb4 <rtems_rfs_buffer_handle_request+0x100>
2036f60: c2 07 40 00 ld [ %i5 ], %g1
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
2036f64: 90 07 60 44 add %i5, 0x44, %o0
2036f68: 92 07 60 50 add %i5, 0x50, %o1
2036f6c: 7f ff ff 23 call 2036bf8 <rtems_rfs_scan_chain>
2036f70: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
2036f74: 80 a2 20 00 cmp %o0, 0
2036f78: 02 80 00 0e be 2036fb0 <rtems_rfs_buffer_handle_request+0xfc>
2036f7c: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
2036f80: 90 10 20 00 clr %o0
2036f84: 7f ff b1 c9 call 20236a8 <rtems_rfs_trace>
2036f88: 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) &&
2036f8c: 80 8a 20 ff btst 0xff, %o0
2036f90: 22 80 00 09 be,a 2036fb4 <rtems_rfs_buffer_handle_request+0x100><== ALWAYS TAKEN
2036f94: 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);
2036f98: 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",
2036f9c: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036fa0: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
2036fa4: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
2036fa8: 40 00 3d 77 call 2046584 <printf> <== NOT EXECUTED
2036fac: 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) &&
2036fb0: c2 07 40 00 ld [ %i5 ], %g1
2036fb4: 80 88 60 02 btst 2, %g1
2036fb8: 12 80 00 20 bne 2037038 <rtems_rfs_buffer_handle_request+0x184>
2036fbc: c2 06 60 08 ld [ %i1 + 8 ], %g1
2036fc0: 80 a0 60 00 cmp %g1, 0
2036fc4: 32 80 00 41 bne,a 20370c8 <rtems_rfs_buffer_handle_request+0x214>
2036fc8: 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)
2036fcc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2036fd0: 80 a0 60 00 cmp %g1, 0
2036fd4: 22 80 00 08 be,a 2036ff4 <rtems_rfs_buffer_handle_request+0x140>
2036fd8: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->buffer = rtems_rfs_scan_chain (&fs->release,
2036fdc: 90 07 60 54 add %i5, 0x54, %o0
2036fe0: 92 07 60 60 add %i5, 0x60, %o1
2036fe4: 7f ff ff 05 call 2036bf8 <rtems_rfs_scan_chain>
2036fe8: 94 10 00 1a mov %i2, %o2
2036fec: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
2036ff0: c2 06 60 08 ld [ %i1 + 8 ], %g1
2036ff4: 80 a0 60 00 cmp %g1, 0
2036ff8: 32 80 00 10 bne,a 2037038 <rtems_rfs_buffer_handle_request+0x184>
2036ffc: c2 06 60 08 ld [ %i1 + 8 ], %g1
2037000: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
2037004: 80 a0 60 00 cmp %g1, 0
2037008: 22 80 00 0c be,a 2037038 <rtems_rfs_buffer_handle_request+0x184>
203700c: c2 06 60 08 ld [ %i1 + 8 ], %g1
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
2037010: 90 07 60 64 add %i5, 0x64, %o0
2037014: 92 07 60 70 add %i5, 0x70, %o1
2037018: 7f ff fe f8 call 2036bf8 <rtems_rfs_scan_chain>
203701c: 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))
2037020: 80 a2 20 00 cmp %o0, 0
2037024: 02 80 00 04 be 2037034 <rtems_rfs_buffer_handle_request+0x180>
2037028: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_buffer_mark_dirty (handle);
203702c: 82 10 20 01 mov 1, %g1
2037030: 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))
2037034: c2 06 60 08 ld [ %i1 + 8 ], %g1
2037038: 80 a0 60 00 cmp %g1, 0
203703c: 32 80 00 23 bne,a 20370c8 <rtems_rfs_buffer_handle_request+0x214>
2037040: d2 06 60 08 ld [ %i1 + 8 ], %o1
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
2037044: 90 10 00 1d mov %i5, %o0
2037048: 92 10 00 1a mov %i2, %o1
203704c: 94 10 00 1b mov %i3, %o2
2037050: 40 00 29 51 call 2041594 <rtems_rfs_buffer_bdbuf_request>
2037054: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
2037058: b0 92 20 00 orcc %o0, 0, %i0
203705c: 04 80 00 17 ble 20370b8 <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
2037060: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
2037064: 7f ff b1 91 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037068: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
203706c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037070: 02 80 00 10 be 20370b0 <rtems_rfs_buffer_handle_request+0x1fc><== NOT EXECUTED
2037074: 3b 00 81 9b sethi %hi(0x2066c00), %i5 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
2037078: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
203707c: 02 80 00 04 be 203708c <rtems_rfs_buffer_handle_request+0x1d8><== NOT EXECUTED
2037080: ba 17 62 c0 or %i5, 0x2c0, %i5 <== NOT EXECUTED
2037084: 3b 00 81 8d sethi %hi(0x2063400), %i5 <== NOT EXECUTED
2037088: ba 17 62 c8 or %i5, 0x2c8, %i5 ! 20636c8 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
203708c: 40 00 46 fb call 2048c78 <strerror> <== NOT EXECUTED
2037090: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037094: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2037098: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
203709c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
20370a0: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
20370a4: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
20370a8: 40 00 3d 37 call 2046584 <printf> <== NOT EXECUTED
20370ac: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED
20370b0: 81 c7 e0 08 ret
20370b4: 81 e8 00 00 restore
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
20370b8: c2 06 60 08 ld [ %i1 + 8 ], %g1
20370bc: c0 20 60 04 clr [ %g1 + 4 ]
20370c0: c0 20 40 00 clr [ %g1 ]
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
20370c4: d2 06 60 08 ld [ %i1 + 8 ], %o1
20370c8: 90 07 60 44 add %i5, 0x44, %o0
20370cc: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
20370d0: b0 10 20 00 clr %i0
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
20370d4: 82 00 60 01 inc %g1
20370d8: 7f ff 5b 5f call 200de54 <_Chain_Append>
20370dc: c2 22 60 30 st %g1, [ %o1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
20370e0: 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))
20370e4: 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++;
20370e8: 82 00 60 01 inc %g1
20370ec: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
20370f0: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
20370f4: 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);
20370f8: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
20370fc: 7f ff b1 6b call 20236a8 <rtems_rfs_trace>
2037100: f4 26 60 04 st %i2, [ %i1 + 4 ]
2037104: 80 8a 20 ff btst 0xff, %o0
2037108: 02 bf ff ea be 20370b0 <rtems_rfs_buffer_handle_request+0x1fc><== ALWAYS TAKEN
203710c: 15 00 81 9b sethi %hi(0x2066c00), %o2
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
2037110: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
2037114: 02 80 00 04 be 2037124 <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
2037118: 94 12 a2 c0 or %o2, 0x2c0, %o2 <== NOT EXECUTED
203711c: 15 00 81 8d sethi %hi(0x2063400), %o2 <== NOT EXECUTED
2037120: 94 12 a2 c8 or %o2, 0x2c8, %o2 ! 20636c8 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
2037124: 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",
2037128: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
203712c: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
2037130: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
2037134: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
2037138: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
203713c: 40 00 3d 12 call 2046584 <printf> <== NOT EXECUTED
2037140: b0 10 20 00 clr %i0 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
}
2037144: 81 c7 e0 08 ret <== NOT EXECUTED
2037148: 81 e8 00 00 restore <== NOT EXECUTED
0203714c <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
203714c: 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))
2037150: 90 10 20 00 clr %o0
2037154: 7f ff b1 55 call 20236a8 <rtems_rfs_trace>
2037158: 92 10 20 20 mov 0x20, %o1
203715c: 80 8a 20 ff btst 0xff, %o0
2037160: 22 80 00 07 be,a 203717c <rtems_rfs_buffer_open+0x30> <== ALWAYS TAKEN
2037164: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
2037168: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
203716c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2037170: 40 00 3d 05 call 2046584 <printf> <== NOT EXECUTED
2037174: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
2037178: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203717c: 7f ff 49 5e call 20096f4 <open>
2037180: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
2037184: 80 a2 20 00 cmp %o0, 0
2037188: 16 80 00 0c bge 20371b8 <rtems_rfs_buffer_open+0x6c> <== ALWAYS TAKEN
203718c: d0 26 60 0c st %o0, [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
2037190: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037194: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
2037198: 7f ff b1 44 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203719c: ba 10 20 06 mov 6, %i5 <== NOT EXECUTED
20371a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20371a4: 22 80 00 4c be,a 20372d4 <rtems_rfs_buffer_open+0x188> <== NOT EXECUTED
20371a8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
20371ac: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20371b0: 10 80 00 39 b 2037294 <rtems_rfs_buffer_open+0x148> <== NOT EXECUTED
20371b4: 90 12 20 00 mov %o0, %o0 ! 2067000 <__FUNCTION__.7646+0x378><== NOT EXECUTED
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
20371b8: 7f ff c1 a6 call 2027850 <fstat>
20371bc: 92 07 bf b8 add %fp, -72, %o1
20371c0: 80 a2 20 00 cmp %o0, 0
20371c4: 16 80 00 12 bge 203720c <rtems_rfs_buffer_open+0xc0> <== ALWAYS TAKEN
20371c8: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
20371cc: 90 10 20 00 clr %o0 <== NOT EXECUTED
20371d0: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
20371d4: 7f ff b1 35 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20371d8: ba 10 20 06 mov 6, %i5 <== NOT EXECUTED
20371dc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20371e0: 22 80 00 3d be,a 20372d4 <rtems_rfs_buffer_open+0x188> <== NOT EXECUTED
20371e4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
20371e8: 40 00 2a ae call 2041ca0 <__errno> <== NOT EXECUTED
20371ec: 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",
20371f0: 40 00 46 a2 call 2048c78 <strerror> <== NOT EXECUTED
20371f4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20371f8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20371fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037200: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037204: 10 80 00 32 b 20372cc <rtems_rfs_buffer_open+0x180> <== NOT EXECUTED
2037208: 90 12 20 30 or %o0, 0x30, %o0 ! 2067030 <__FUNCTION__.7646+0x3a8><== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
203720c: 03 00 00 3c sethi %hi(0xf000), %g1
2037210: 84 08 80 01 and %g2, %g1, %g2
2037214: 03 00 00 18 sethi %hi(0x6000), %g1
2037218: 80 a0 80 01 cmp %g2, %g1
203721c: 22 80 00 0f be,a 2037258 <rtems_rfs_buffer_open+0x10c> <== ALWAYS TAKEN
2037220: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
2037224: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037228: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
203722c: 7f ff b1 1f call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037230: ba 10 20 06 mov 6, %i5 <== NOT EXECUTED
2037234: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037238: 22 80 00 27 be,a 20372d4 <rtems_rfs_buffer_open+0x188> <== NOT EXECUTED
203723c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
2037240: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037244: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2037248: 40 00 3c cf call 2046584 <printf> <== NOT EXECUTED
203724c: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
2037250: 81 c7 e0 08 ret <== NOT EXECUTED
2037254: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
2037258: 13 10 01 10 sethi %hi(0x40044000), %o1
203725c: 94 06 60 10 add %i1, 0x10, %o2
2037260: 7f ff 45 9d call 20088d4 <ioctl>
2037264: 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)
2037268: 80 a2 20 00 cmp %o0, 0
203726c: 02 80 00 0d be 20372a0 <rtems_rfs_buffer_open+0x154> <== ALWAYS TAKEN
2037270: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
2037274: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
2037278: 7f ff b1 0c call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203727c: ba 10 20 06 mov 6, %i5 <== NOT EXECUTED
2037280: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037284: 22 80 00 14 be,a 20372d4 <rtems_rfs_buffer_open+0x188> <== NOT EXECUTED
2037288: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
203728c: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037290: 90 12 20 98 or %o0, 0x98, %o0 ! 2067098 <__FUNCTION__.7646+0x410><== NOT EXECUTED
2037294: 40 00 3d 57 call 20467f0 <puts> <== NOT EXECUTED
2037298: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
203729c: 30 80 00 0e b,a 20372d4 <rtems_rfs_buffer_open+0x188> <== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
20372a0: 92 10 20 20 mov 0x20, %o1
20372a4: 7f ff b1 01 call 20236a8 <rtems_rfs_trace>
20372a8: ba 10 20 00 clr %i5
20372ac: 80 8a 20 ff btst 0xff, %o0
20372b0: 22 80 00 09 be,a 20372d4 <rtems_rfs_buffer_open+0x188> <== ALWAYS TAKEN
20372b4: b0 10 00 1d mov %i5, %i0
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
20372b8: 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",
20372bc: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20372c0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
20372c4: d4 00 60 24 ld [ %g1 + 0x24 ], %o2 <== NOT EXECUTED
20372c8: 90 12 20 c8 or %o0, 0xc8, %o0 <== NOT EXECUTED
20372cc: 40 00 3c ae call 2046584 <printf> <== NOT EXECUTED
20372d0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
20372d4: 81 c7 e0 08 ret
20372d8: 81 e8 00 00 restore
020373e4 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
20373e4: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
20373e8: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
20373ec: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
20373f0: 7f ff b0 ae call 20236a8 <rtems_rfs_trace>
20373f4: 92 10 24 00 mov 0x400, %o1
20373f8: 80 8a 20 ff btst 0xff, %o0
20373fc: 02 80 00 05 be 2037410 <rtems_rfs_buffer_setblksize+0x2c> <== ALWAYS TAKEN
2037400: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
2037404: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037408: 40 00 3c 5f call 2046584 <printf> <== NOT EXECUTED
203740c: 90 12 21 98 or %o0, 0x198, %o0 ! 2067198 <__FUNCTION__.7646+0x510><== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
2037410: 7f ff ff d5 call 2037364 <rtems_rfs_buffers_release>
2037414: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
2037418: ba 92 20 00 orcc %o0, 0, %i5
203741c: 04 80 00 0e ble 2037454 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
2037420: 90 10 20 00 clr %o0
2037424: 7f ff b0 a1 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037428: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
203742c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037430: 02 80 00 09 be 2037454 <rtems_rfs_buffer_setblksize+0x70> <== NOT EXECUTED
2037434: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
2037438: 40 00 46 10 call 2048c78 <strerror> <== NOT EXECUTED
203743c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037440: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037444: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037448: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
203744c: 40 00 3c 4e call 2046584 <printf> <== NOT EXECUTED
2037450: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 20671c8 <__FUNCTION__.7646+0x540><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
2037454: 7f ff ff a2 call 20372dc <rtems_rfs_buffer_sync>
2037458: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
203745c: ba 92 20 00 orcc %o0, 0, %i5
2037460: 04 80 00 0e ble 2037498 <rtems_rfs_buffer_setblksize+0xb4><== ALWAYS TAKEN
2037464: 90 10 20 00 clr %o0
2037468: 7f ff b0 90 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203746c: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
2037470: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037474: 22 80 00 0a be,a 203749c <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
2037478: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
203747c: 40 00 45 ff call 2048c78 <strerror> <== NOT EXECUTED
2037480: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037484: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037488: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203748c: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037490: 40 00 3c 3d call 2046584 <printf> <== NOT EXECUTED
2037494: 90 12 22 08 or %o0, 0x208, %o0 ! 2067208 <__FUNCTION__.7646+0x580><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
2037498: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
203749c: 13 20 01 10 sethi %hi(0x80044000), %o1
20374a0: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
20374a4: 92 12 62 04 or %o1, 0x204, %o1
20374a8: 9f c0 40 00 call %g1
20374ac: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
20374b0: b0 92 20 00 orcc %o0, 0, %i0
20374b4: 16 80 00 05 bge 20374c8 <rtems_rfs_buffer_setblksize+0xe4><== ALWAYS TAKEN
20374b8: 01 00 00 00 nop
rc = errno;
20374bc: 40 00 29 f9 call 2041ca0 <__errno> <== NOT EXECUTED
20374c0: 01 00 00 00 nop <== NOT EXECUTED
20374c4: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
20374c8: 81 c7 e0 08 ret
20374cc: 81 e8 00 00 restore
020372dc <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
20372dc: 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))
20372e0: 90 10 20 00 clr %o0
20372e4: 7f ff b0 f1 call 20236a8 <rtems_rfs_trace>
20372e8: 92 10 20 20 mov 0x20, %o1
20372ec: 80 8a 20 ff btst 0xff, %o0
20372f0: 22 80 00 06 be,a 2037308 <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
20372f4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: syncing\n");
20372f8: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20372fc: 40 00 3d 3d call 20467f0 <puts> <== NOT EXECUTED
2037300: 90 12 20 f8 or %o0, 0xf8, %o0 ! 20670f8 <__FUNCTION__.7646+0x470><== 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));
2037304: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2037308: 7f ff 3d 15 call 200675c <rtems_bdbuf_syncdev>
203730c: ba 10 20 00 clr %i5
if (sc != RTEMS_SUCCESSFUL)
2037310: 80 a2 20 00 cmp %o0, 0
2037314: 02 80 00 0f be 2037350 <rtems_rfs_buffer_sync+0x74> <== ALWAYS TAKEN
2037318: b8 10 00 08 mov %o0, %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
203731c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037320: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
2037324: 7f ff b0 e1 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037328: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
203732c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037330: 22 80 00 09 be,a 2037354 <rtems_rfs_buffer_sync+0x78> <== NOT EXECUTED
2037334: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
2037338: 7f ff 44 79 call 200851c <rtems_status_text> <== NOT EXECUTED
203733c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2037340: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2037344: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037348: 40 00 3c 8f call 2046584 <printf> <== NOT EXECUTED
203734c: 90 12 21 18 or %o0, 0x118, %o0 ! 2067118 <__FUNCTION__.7646+0x490><== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
2037350: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
2037354: 7f ff 41 5e call 20078cc <rtems_disk_release>
2037358: b0 10 00 1d mov %i5, %i0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
203735c: 81 c7 e0 08 ret
2037360: 81 e8 00 00 restore
02037364 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
2037364: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
2037368: 90 10 20 00 clr %o0
203736c: 92 10 20 40 mov 0x40, %o1
2037370: 7f ff b0 ce call 20236a8 <rtems_rfs_trace>
2037374: ba 10 00 18 mov %i0, %i5
2037378: 80 8a 20 ff btst 0xff, %o0
203737c: 02 80 00 09 be 20373a0 <rtems_rfs_buffers_release+0x3c> <== ALWAYS TAKEN
2037380: 92 07 60 60 add %i5, 0x60, %o1
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
2037384: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
2037388: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
203738c: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
2037390: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037394: 40 00 3c 7c call 2046584 <printf> <== NOT EXECUTED
2037398: 90 12 21 48 or %o0, 0x148, %o0 ! 2067148 <__FUNCTION__.7646+0x4c0><== 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,
203739c: 92 07 60 60 add %i5, 0x60, %o1 <== NOT EXECUTED
20373a0: 94 10 20 00 clr %o2
20373a4: 7f ff fd f2 call 2036b6c <rtems_rfs_release_chain>
20373a8: 90 07 60 54 add %i5, 0x54, %o0
20373ac: 82 38 00 08 xnor %g0, %o0, %g1
20373b0: 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,
20373b4: 92 07 60 70 add %i5, 0x70, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
20373b8: b0 0a 00 01 and %o0, %g1, %i0
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
20373bc: 94 10 20 01 mov 1, %o2
20373c0: 7f ff fd eb call 2036b6c <rtems_rfs_release_chain>
20373c4: 90 07 60 64 add %i5, 0x64, %o0
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
20373c8: 80 a6 20 00 cmp %i0, 0
20373cc: 12 80 00 04 bne 20373dc <rtems_rfs_buffers_release+0x78> <== NEVER TAKEN
20373d0: 80 a2 20 00 cmp %o0, 0
20373d4: 34 80 00 02 bg,a 20373dc <rtems_rfs_buffers_release+0x78><== NEVER TAKEN
20373d8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
20373dc: 81 c7 e0 08 ret
20373e0: 81 e8 00 00 restore
02037aa8 <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)
{
2037aa8: 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))
2037aac: 90 10 20 00 clr %o0
2037ab0: 13 08 00 00 sethi %hi(0x20000000), %o1
2037ab4: 7f ff ae fd call 20236a8 <rtems_rfs_trace>
2037ab8: ba 10 00 18 mov %i0, %i5
2037abc: 80 8a 20 ff btst 0xff, %o0
2037ac0: 02 80 00 13 be 2037b0c <rtems_rfs_dir_add_entry+0x64> <== ALWAYS TAKEN
2037ac4: a0 07 bf 94 add %fp, -108, %l0
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
2037ac8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037acc: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
2037ad0: b0 10 20 00 clr %i0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
2037ad4: 40 00 3a ac call 2046584 <printf> <== NOT EXECUTED
2037ad8: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
2037adc: 10 80 00 05 b 2037af0 <rtems_rfs_dir_add_entry+0x48> <== NOT EXECUTED
2037ae0: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
2037ae4: 40 00 3b 15 call 2046738 <putchar> <== NOT EXECUTED
2037ae8: b0 06 20 01 inc %i0 <== 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++)
2037aec: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
2037af0: 32 bf ff fd bne,a 2037ae4 <rtems_rfs_dir_add_entry+0x3c> <== NOT EXECUTED
2037af4: d0 4e 80 18 ldsb [ %i2 + %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
2037af8: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037afc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2037b00: 40 00 3a a1 call 2046584 <printf> <== NOT EXECUTED
2037b04: 90 12 21 e8 or %o0, 0x1e8, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
2037b08: a0 07 bf 94 add %fp, -108, %l0 <== NOT EXECUTED
2037b0c: 90 10 00 1d mov %i5, %o0
2037b10: 92 10 00 19 mov %i1, %o1
2037b14: 7f ff f8 f9 call 2035ef8 <rtems_rfs_block_map_open>
2037b18: 94 10 00 10 mov %l0, %o2
if (rc > 0)
2037b1c: b0 92 20 00 orcc %o0, 0, %i0
2037b20: 14 80 00 8d bg 2037d54 <rtems_rfs_dir_add_entry+0x2ac> <== NEVER TAKEN
2037b24: 27 00 00 3f sethi %hi(0xfc00), %l3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2037b28: c0 2f bf f0 clrb [ %fp + -16 ]
handle->bnum = 0;
2037b2c: c0 27 bf f4 clr [ %fp + -12 ]
handle->buffer = NULL;
2037b30: c0 27 bf f8 clr [ %fp + -8 ]
* @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;
2037b34: c0 27 bf e4 clr [ %fp + -28 ]
bpos->boff = 0;
2037b38: c0 27 bf e8 clr [ %fp + -24 ]
bpos->block = 0;
2037b3c: c0 27 bf ec clr [ %fp + -20 ]
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2037b40: a6 14 e3 ff or %l3, 0x3ff, %l3
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
2037b44: a4 06 e0 0a add %i3, 0xa, %l2
/*
* 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);
2037b48: 90 10 00 1d mov %i5, %o0
2037b4c: 92 10 00 10 mov %l0, %o1
2037b50: 94 07 bf e4 add %fp, -28, %o2
2037b54: 7f ff f9 c0 call 2036254 <rtems_rfs_block_map_find>
2037b58: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
2037b5c: b0 92 20 00 orcc %o0, 0, %i0
2037b60: 04 80 00 29 ble 2037c04 <rtems_rfs_dir_add_entry+0x15c>
2037b64: 80 a6 20 06 cmp %i0, 6
{
if (rc != ENXIO)
2037b68: 02 80 00 0f be 2037ba4 <rtems_rfs_dir_add_entry+0xfc> <== ALWAYS TAKEN
2037b6c: 90 10 00 1d mov %i5, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
2037b70: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037b74: 7f ff ae cd call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037b78: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2037b7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037b80: 22 80 00 a9 be,a 2037e24 <rtems_rfs_dir_add_entry+0x37c> <== NOT EXECUTED
2037b84: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
2037b88: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2037b8c: 40 00 44 3b call 2048c78 <strerror> <== NOT EXECUTED
2037b90: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037b94: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2037b98: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037b9c: 10 80 00 15 b 2037bf0 <rtems_rfs_dir_add_entry+0x148> <== NOT EXECUTED
2037ba0: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 20675f8 <__FUNCTION__.7646+0x970><== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
2037ba4: 92 10 00 10 mov %l0, %o1
2037ba8: 94 10 20 01 mov 1, %o2
2037bac: 7f ff fa 30 call 203646c <rtems_rfs_block_map_grow>
2037bb0: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
2037bb4: b0 92 20 00 orcc %o0, 0, %i0
2037bb8: 04 80 00 14 ble 2037c08 <rtems_rfs_dir_add_entry+0x160> <== ALWAYS TAKEN
2037bbc: a2 10 20 00 clr %l1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
2037bc0: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037bc4: 7f ff ae b9 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037bc8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2037bcc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037bd0: 22 80 00 95 be,a 2037e24 <rtems_rfs_dir_add_entry+0x37c> <== NOT EXECUTED
2037bd4: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
2037bd8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2037bdc: 40 00 44 27 call 2048c78 <strerror> <== NOT EXECUTED
2037be0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037be4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2037be8: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037bec: 90 12 22 40 or %o0, 0x240, %o0 ! 2067640 <__FUNCTION__.7646+0x9b8><== NOT EXECUTED
2037bf0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2037bf4: 40 00 3a 64 call 2046584 <printf> <== NOT EXECUTED
2037bf8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2037bfc: 10 80 00 8a b 2037e24 <rtems_rfs_dir_add_entry+0x37c> <== NOT EXECUTED
2037c00: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2037c04: a2 10 20 01 mov 1, %l1
}
read = false;
}
bpos.bno++;
2037c08: c2 07 bf e4 ld [ %fp + -28 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
2037c0c: d4 07 bf fc ld [ %fp + -4 ], %o2
}
read = false;
}
bpos.bno++;
2037c10: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
2037c14: a2 0c 60 ff and %l1, 0xff, %l1
}
read = false;
}
bpos.bno++;
2037c18: c2 27 bf e4 st %g1, [ %fp + -28 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
2037c1c: 90 10 00 1d mov %i5, %o0
2037c20: 92 07 bf f0 add %fp, -16, %o1
2037c24: 7f ff fc a4 call 2036eb4 <rtems_rfs_buffer_handle_request>
2037c28: 96 10 00 11 mov %l1, %o3
if (rc > 0)
2037c2c: b0 92 20 00 orcc %o0, 0, %i0
2037c30: 04 80 00 0f ble 2037c6c <rtems_rfs_dir_add_entry+0x1c4> <== ALWAYS TAKEN
2037c34: c2 07 bf f8 ld [ %fp + -8 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
2037c38: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037c3c: 7f ff ae 9b call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037c40: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2037c44: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037c48: 22 80 00 77 be,a 2037e24 <rtems_rfs_dir_add_entry+0x37c> <== NOT EXECUTED
2037c4c: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
2037c50: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2037c54: 40 00 44 09 call 2048c78 <strerror> <== NOT EXECUTED
2037c58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037c5c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2037c60: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037c64: 10 bf ff e3 b 2037bf0 <rtems_rfs_dir_add_entry+0x148> <== NOT EXECUTED
2037c68: 90 12 22 88 or %o0, 0x288, %o0 ! 2067688 <__FUNCTION__.7646+0xa00><== NOT EXECUTED
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
2037c6c: 80 a4 60 00 cmp %l1, 0
2037c70: 12 80 00 06 bne 2037c88 <rtems_rfs_dir_add_entry+0x1e0>
2037c74: e8 00 60 1c ld [ %g1 + 0x1c ], %l4
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
2037c78: d4 07 60 08 ld [ %i5 + 8 ], %o2
2037c7c: 90 10 00 14 mov %l4, %o0
2037c80: 40 00 35 d5 call 20453d4 <memset>
2037c84: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2037c88: c2 07 60 08 ld [ %i5 + 8 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
2037c8c: b0 10 20 00 clr %i0
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2037c90: 10 80 00 60 b 2037e10 <rtems_rfs_dir_add_entry+0x368>
2037c94: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
2037c98: ea 0d 20 08 ldub [ %l4 + 8 ], %l5
eino = rtems_rfs_dir_entry_ino (entry);
2037c9c: e2 0d 00 00 ldub [ %l4 ], %l1
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);
2037ca0: ab 2d 60 08 sll %l5, 8, %l5
eino = rtems_rfs_dir_entry_ino (entry);
2037ca4: de 0d 20 01 ldub [ %l4 + 1 ], %o7
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);
2037ca8: aa 15 40 03 or %l5, %g3, %l5
eino = rtems_rfs_dir_entry_ino (entry);
2037cac: c8 0d 20 03 ldub [ %l4 + 3 ], %g4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2037cb0: 80 a5 40 13 cmp %l5, %l3
2037cb4: 12 80 00 2a bne 2037d5c <rtems_rfs_dir_add_entry+0x2b4>
2037cb8: c6 0d 20 02 ldub [ %l4 + 2 ], %g3
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
2037cbc: b0 20 40 18 sub %g1, %i0, %i0
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) <
2037cc0: 80 a4 80 18 cmp %l2, %i0
2037cc4: 3a bf ff a2 bcc,a 2037b4c <rtems_rfs_dir_add_entry+0xa4> <== NEVER TAKEN
2037cc8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
2037ccc: 92 10 00 1b mov %i3, %o1
2037cd0: 40 00 26 6d call 2041684 <rtems_rfs_dir_hash>
2037cd4: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
2037cd8: 83 32 20 18 srl %o0, 0x18, %g1
2037cdc: c2 2d 20 04 stb %g1, [ %l4 + 4 ]
2037ce0: 83 32 20 10 srl %o0, 0x10, %g1
2037ce4: c2 2d 20 05 stb %g1, [ %l4 + 5 ]
2037ce8: 83 32 20 08 srl %o0, 8, %g1
2037cec: c2 2d 20 06 stb %g1, [ %l4 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
2037cf0: 83 37 20 18 srl %i4, 0x18, %g1
2037cf4: c2 2d 00 00 stb %g1, [ %l4 ]
2037cf8: 83 37 20 10 srl %i4, 0x10, %g1
2037cfc: c2 2d 20 01 stb %g1, [ %l4 + 1 ]
2037d00: 83 37 20 08 srl %i4, 8, %g1
2037d04: c2 2d 20 02 stb %g1, [ %l4 + 2 ]
rtems_rfs_dir_set_entry_length (entry,
2037d08: 82 06 e0 0a add %i3, 0xa, %g1
2037d0c: 85 30 60 08 srl %g1, 8, %g2
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
2037d10: 94 10 00 1b mov %i3, %o2
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
2037d14: c4 2d 20 08 stb %g2, [ %l4 + 8 ]
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);
2037d18: d0 2d 20 07 stb %o0, [ %l4 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
2037d1c: c2 2d 20 09 stb %g1, [ %l4 + 9 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
2037d20: 92 10 00 1a mov %i2, %o1
(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);
2037d24: f8 2d 20 03 stb %i4, [ %l4 + 3 ]
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
2037d28: 40 00 35 1f call 20451a4 <memcpy>
2037d2c: 90 05 20 0a add %l4, 0xa, %o0
rtems_rfs_buffer_mark_dirty (&buffer);
2037d30: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
2037d34: 92 07 bf f0 add %fp, -16, %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);
2037d38: c2 2f bf f0 stb %g1, [ %fp + -16 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
2037d3c: 7f ff fe 19 call 20375a0 <rtems_rfs_buffer_handle_close>
2037d40: 90 10 00 1d mov %i5, %o0
rtems_rfs_block_map_close (fs, &map);
2037d44: 90 10 00 1d mov %i5, %o0
2037d48: 92 07 bf 94 add %fp, -108, %o1
2037d4c: 7f ff f8 cd call 2036080 <rtems_rfs_block_map_close>
2037d50: b0 10 20 00 clr %i0
return 0;
2037d54: 81 c7 e0 08 ret
2037d58: 81 e8 00 00 restore
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
2037d5c: a3 2c 60 18 sll %l1, 0x18, %l1
2037d60: 9e 0b e0 ff and %o7, 0xff, %o7
2037d64: 88 09 20 ff and %g4, 0xff, %g4
2037d68: 9f 2b e0 10 sll %o7, 0x10, %o7
2037d6c: 86 08 e0 ff and %g3, 0xff, %g3
2037d70: a2 14 40 0f or %l1, %o7, %l1
2037d74: 87 28 e0 08 sll %g3, 8, %g3
2037d78: a2 14 40 04 or %l1, %g4, %l1
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
2037d7c: 80 a5 60 0a cmp %l5, 0xa
2037d80: 04 80 00 0d ble 2037db4 <rtems_rfs_dir_add_entry+0x30c> <== NEVER TAKEN
2037d84: a2 14 40 03 or %l1, %g3, %l1
2037d88: 80 a4 60 00 cmp %l1, 0
2037d8c: 02 80 00 0b be 2037db8 <rtems_rfs_dir_add_entry+0x310> <== NEVER TAKEN
2037d90: 90 10 20 00 clr %o0
2037d94: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
2037d98: 80 a5 40 03 cmp %l5, %g3
2037d9c: 1a 80 00 07 bcc 2037db8 <rtems_rfs_dir_add_entry+0x310> <== NEVER TAKEN
2037da0: 01 00 00 00 nop
2037da4: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
2037da8: 80 a4 40 03 cmp %l1, %g3
2037dac: 28 80 00 18 bleu,a 2037e0c <rtems_rfs_dir_add_entry+0x364><== ALWAYS TAKEN
2037db0: a8 05 00 15 add %l4, %l5, %l4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
2037db4: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037db8: 7f ff ae 3c call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037dbc: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2037dc0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037dc4: 02 80 00 0a be 2037dec <rtems_rfs_dir_add_entry+0x344> <== NOT EXECUTED
2037dc8: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
2037dcc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037dd0: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037dd4: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2037dd8: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
2037ddc: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
2037de0: 40 00 39 e9 call 2046584 <printf> <== NOT EXECUTED
2037de4: 98 10 00 18 mov %i0, %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);
2037de8: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2037dec: 7f ff fd ed call 20375a0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2037df0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
2037df4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037df8: 92 07 bf 94 add %fp, -108, %o1 <== NOT EXECUTED
2037dfc: 7f ff f8 a1 call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
2037e00: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
return EIO;
2037e04: 81 c7 e0 08 ret <== NOT EXECUTED
2037e08: 81 e8 00 00 restore <== NOT EXECUTED
}
entry += elength;
offset += elength;
2037e0c: b0 06 00 15 add %i0, %l5, %i0
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))
2037e10: 80 a6 00 02 cmp %i0, %g2
2037e14: 2a bf ff a1 bcs,a 2037c98 <rtems_rfs_dir_add_entry+0x1f0><== ALWAYS TAKEN
2037e18: c6 0d 20 09 ldub [ %l4 + 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);
2037e1c: 10 bf ff 4c b 2037b4c <rtems_rfs_dir_add_entry+0xa4> <== NOT EXECUTED
2037e20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2037e24: 7f ff fd df call 20375a0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2037e28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
2037e2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037e30: 7f ff f8 94 call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
2037e34: 92 07 bf 94 add %fp, -108, %o1 <== NOT EXECUTED
return rc;
}
2037e38: 81 c7 e0 08 ret <== NOT EXECUTED
2037e3c: 81 e8 00 00 restore <== NOT EXECUTED
02037e40 <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)
{
2037e40: 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))
2037e44: 90 10 20 00 clr %o0
2037e48: 13 10 00 00 sethi %hi(0x40000000), %o1
2037e4c: 7f ff ae 17 call 20236a8 <rtems_rfs_trace>
2037e50: ba 10 00 18 mov %i0, %i5
2037e54: 80 8a 20 ff btst 0xff, %o0
2037e58: 02 80 00 09 be 2037e7c <rtems_rfs_dir_del_entry+0x3c> <== ALWAYS TAKEN
2037e5c: a6 07 bf a0 add %fp, -96, %l3
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
2037e60: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037e64: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037e68: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2037e6c: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
2037e70: 40 00 39 c5 call 2046584 <printf> <== NOT EXECUTED
2037e74: 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);
2037e78: a6 07 bf a0 add %fp, -96, %l3 <== NOT EXECUTED
2037e7c: 90 10 00 1d mov %i5, %o0
2037e80: 92 10 00 19 mov %i1, %o1
2037e84: 7f ff f8 1d call 2035ef8 <rtems_rfs_block_map_open>
2037e88: 94 10 00 13 mov %l3, %o2
if (rc > 0)
2037e8c: b0 92 20 00 orcc %o0, 0, %i0
2037e90: 14 80 00 c6 bg 20381a8 <rtems_rfs_dir_del_entry+0x368> <== NEVER TAKEN
2037e94: a4 07 bf fc add %fp, -4, %l2
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
2037e98: 90 10 00 1d mov %i5, %o0
2037e9c: 92 10 00 13 mov %l3, %o1
2037ea0: 94 10 20 00 clr %o2
2037ea4: 96 10 00 1b mov %i3, %o3
2037ea8: 7f ff f9 47 call 20363c4 <rtems_rfs_block_map_seek>
2037eac: 98 10 00 12 mov %l2, %o4
if (rc > 0)
2037eb0: b0 92 20 00 orcc %o0, 0, %i0
2037eb4: 04 80 00 06 ble 2037ecc <rtems_rfs_dir_del_entry+0x8c> <== ALWAYS TAKEN
2037eb8: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
2037ebc: 22 80 00 b8 be,a 203819c <rtems_rfs_dir_del_entry+0x35c> <== NOT EXECUTED
2037ec0: 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);
2037ec4: 10 80 00 b7 b 20381a0 <rtems_rfs_dir_del_entry+0x360> <== NOT EXECUTED
2037ec8: 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)
2037ecc: 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)
2037ed0: 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: "
2037ed4: 23 00 81 9d sethi %hi(0x2067400), %l1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2037ed8: c0 2f bf f0 clrb [ %fp + -16 ]
handle->bnum = 0;
2037edc: c0 27 bf f4 clr [ %fp + -12 ]
handle->buffer = NULL;
2037ee0: c0 27 bf f8 clr [ %fp + -8 ]
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
2037ee4: 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)
2037ee8: a0 60 3f ff subx %g0, -1, %l0
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2037eec: 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)
2037ef0: 10 80 00 c3 b 20381fc <rtems_rfs_dir_del_entry+0x3bc>
2037ef4: a2 14 63 b0 or %l1, 0x3b0, %l1
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
2037ef8: 90 10 00 1d mov %i5, %o0
2037efc: 92 07 bf f0 add %fp, -16, %o1
2037f00: 7f ff fb ed call 2036eb4 <rtems_rfs_buffer_handle_request>
2037f04: 96 10 20 01 mov 1, %o3
if (rc > 0)
2037f08: aa 92 20 00 orcc %o0, 0, %l5
2037f0c: 04 80 00 13 ble 2037f58 <rtems_rfs_dir_del_entry+0x118> <== ALWAYS TAKEN
2037f10: 80 a4 20 00 cmp %l0, 0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
2037f14: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037f18: 7f ff ad e4 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037f1c: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
2037f20: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037f24: 22 80 00 bb be,a 2038210 <rtems_rfs_dir_del_entry+0x3d0> <== NOT EXECUTED
2037f28: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
2037f2c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2037f30: 40 00 43 52 call 2048c78 <strerror> <== NOT EXECUTED
2037f34: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
2037f38: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2037f3c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2037f40: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2037f44: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037f48: 40 00 39 8f call 2046584 <printf> <== NOT EXECUTED
2037f4c: 90 12 23 68 or %o0, 0x368, %o0 ! 2067768 <__FUNCTION__.7646+0xae0><== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2037f50: 10 80 00 b0 b 2038210 <rtems_rfs_dir_del_entry+0x3d0> <== NOT EXECUTED
2037f54: 92 07 bf f0 add %fp, -16, %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)
2037f58: 12 80 00 06 bne 2037f70 <rtems_rfs_dir_del_entry+0x130> <== NEVER TAKEN
2037f5c: b8 10 20 00 clr %i4
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
2037f60: d2 07 60 08 ld [ %i5 + 8 ], %o1
2037f64: 40 00 8d e7 call 205b700 <.urem>
2037f68: 90 10 00 1b mov %i3, %o0
2037f6c: b8 10 00 08 mov %o0, %i4
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
2037f70: c2 07 bf f8 ld [ %fp + -8 ], %g1
2037f74: ec 00 60 1c ld [ %g1 + 0x1c ], %l6
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2037f78: 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;
2037f7c: ac 05 80 1c add %l6, %i4, %l6
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2037f80: 10 80 00 8f b 20381bc <rtems_rfs_dir_del_entry+0x37c>
2037f84: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
2037f88: ee 0d a0 08 ldub [ %l6 + 8 ], %l7
eino = rtems_rfs_dir_entry_ino (entry);
2037f8c: d6 0d 80 00 ldub [ %l6 ], %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);
2037f90: af 2d e0 08 sll %l7, 8, %l7
eino = rtems_rfs_dir_entry_ino (entry);
2037f94: de 0d a0 01 ldub [ %l6 + 1 ], %o7
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);
2037f98: ae 15 c0 03 or %l7, %g3, %l7
eino = rtems_rfs_dir_entry_ino (entry);
2037f9c: c8 0d a0 03 ldub [ %l6 + 3 ], %g4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2037fa0: 80 a5 c0 14 cmp %l7, %l4
2037fa4: 02 80 00 89 be 20381c8 <rtems_rfs_dir_del_entry+0x388> <== NEVER TAKEN
2037fa8: c6 0d a0 02 ldub [ %l6 + 2 ], %g3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
2037fac: 97 2a e0 18 sll %o3, 0x18, %o3
2037fb0: 9e 0b e0 ff and %o7, 0xff, %o7
2037fb4: 88 09 20 ff and %g4, 0xff, %g4
2037fb8: 9f 2b e0 10 sll %o7, 0x10, %o7
2037fbc: 86 08 e0 ff and %g3, 0xff, %g3
2037fc0: 96 12 c0 0f or %o3, %o7, %o3
2037fc4: 87 28 e0 08 sll %g3, 8, %g3
2037fc8: 96 12 c0 04 or %o3, %g4, %o3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
2037fcc: 80 a5 e0 0a cmp %l7, 0xa
2037fd0: 04 80 00 0d ble 2038004 <rtems_rfs_dir_del_entry+0x1c4> <== NEVER TAKEN
2037fd4: 96 12 c0 03 or %o3, %g3, %o3
2037fd8: 80 a2 e0 00 cmp %o3, 0
2037fdc: 22 80 00 0b be,a 2038008 <rtems_rfs_dir_del_entry+0x1c8> <== NEVER TAKEN
2037fe0: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
2037fe4: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
2037fe8: 80 a5 c0 03 cmp %l7, %g3
2037fec: 3a 80 00 07 bcc,a 2038008 <rtems_rfs_dir_del_entry+0x1c8><== NEVER TAKEN
2037ff0: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
2037ff4: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
2037ff8: 80 a2 c0 03 cmp %o3, %g3
2037ffc: 08 80 00 11 bleu 2038040 <rtems_rfs_dir_del_entry+0x200> <== ALWAYS TAKEN
2038000: 80 a6 80 0b cmp %i2, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
2038004: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
2038008: 90 10 20 00 clr %o0 <== NOT EXECUTED
203800c: 7f ff ad a7 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2038010: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
2038014: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038018: 02 80 00 86 be 2038230 <rtems_rfs_dir_del_entry+0x3f0> <== NOT EXECUTED
203801c: d6 07 bf 9c ld [ %fp + -100 ], %o3 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
2038020: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038024: d8 07 bf fc ld [ %fp + -4 ], %o4 <== NOT EXECUTED
2038028: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
203802c: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
2038030: 40 00 39 55 call 2046584 <printf> <== NOT EXECUTED
2038034: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
2038038: 10 80 00 70 b 20381f8 <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
203803c: aa 10 20 05 mov 5, %l5 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
2038040: 12 80 00 5c bne 20381b0 <rtems_rfs_dir_del_entry+0x370> <== NEVER TAKEN
2038044: 80 a4 20 00 cmp %l0, 0
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
2038048: 92 05 80 17 add %l6, %l7, %o1
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
203804c: b6 07 00 17 add %i4, %l7, %i3
memmove (entry, entry + elength, remaining);
2038050: 90 10 00 16 mov %l6, %o0
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
2038054: b6 20 40 1b sub %g1, %i3, %i3
memmove (entry, entry + elength, remaining);
2038058: 40 00 34 8f call 2045294 <memmove>
203805c: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
2038060: 90 05 80 1b add %l6, %i3, %o0
2038064: 92 10 20 ff mov 0xff, %o1
2038068: 40 00 34 db call 20453d4 <memset>
203806c: 94 10 00 17 mov %l7, %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);
2038070: c2 0d a0 09 ldub [ %l6 + 9 ], %g1
2038074: f6 0d a0 08 ldub [ %l6 + 8 ], %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
2038078: 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);
203807c: b7 2e e0 08 sll %i3, 8, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
2038080: 13 10 00 00 sethi %hi(0x40000000), %o1
2038084: 7f ff ad 89 call 20236a8 <rtems_rfs_trace>
2038088: b6 16 c0 01 or %i3, %g1, %i3
203808c: 80 8a 20 ff btst 0xff, %o0
2038090: 02 80 00 19 be 20380f4 <rtems_rfs_dir_del_entry+0x2b4> <== ALWAYS TAKEN
2038094: 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");
2038098: c2 07 bf b0 ld [ %fp + -80 ], %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: "
203809c: d6 07 bf fc ld [ %fp + -4 ], %o3 <== NOT EXECUTED
20380a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20380a4: 12 80 00 06 bne 20380bc <rtems_rfs_dir_del_entry+0x27c> <== NOT EXECUTED
20380a8: c4 07 bf a8 ld [ %fp + -88 ], %g2 <== NOT EXECUTED
20380ac: 1b 00 81 9d sethi %hi(0x2067400), %o5 <== 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");
20380b0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20380b4: 02 80 00 09 be 20380d8 <rtems_rfs_dir_del_entry+0x298> <== NOT EXECUTED
20380b8: 9a 13 63 18 or %o5, 0x318, %o5 <== NOT EXECUTED
20380bc: 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: "
20380c0: 1b 00 81 9d sethi %hi(0x2067400), %o5 <== 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");
20380c4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20380c8: 12 80 00 04 bne 20380d8 <rtems_rfs_dir_del_entry+0x298> <== NOT EXECUTED
20380cc: 9a 13 63 20 or %o5, 0x320, %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: "
20380d0: 1b 00 81 9d sethi %hi(0x2067400), %o5 <== NOT EXECUTED
20380d4: 9a 13 63 18 or %o5, 0x318, %o5 ! 2067718 <__FUNCTION__.7646+0xa90><== NOT EXECUTED
20380d8: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
20380dc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
20380e0: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
20380e4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
20380e8: 40 00 39 27 call 2046584 <printf> <== NOT EXECUTED
20380ec: 98 10 00 1c mov %i4, %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) &&
20380f0: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
20380f4: b6 38 40 1b xnor %g1, %i3, %i3
20380f8: 80 a6 e0 00 cmp %i3, 0
20380fc: 12 80 00 23 bne 2038188 <rtems_rfs_dir_del_entry+0x348>
2038100: 80 a7 20 00 cmp %i4, 0
2038104: 12 80 00 21 bne 2038188 <rtems_rfs_dir_del_entry+0x348> <== ALWAYS TAKEN
2038108: c2 07 bf b0 ld [ %fp + -80 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
203810c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2038110: 12 80 00 05 bne 2038124 <rtems_rfs_dir_del_entry+0x2e4> <== NOT EXECUTED
2038114: c4 07 bf a8 ld [ %fp + -88 ], %g2 <== NOT EXECUTED
2038118: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
203811c: 02 80 00 07 be 2038138 <rtems_rfs_dir_del_entry+0x2f8> <== NOT EXECUTED
2038120: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2038124: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
2038128: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203812c: 12 80 00 18 bne 203818c <rtems_rfs_dir_del_entry+0x34c> <== NOT EXECUTED
2038130: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
2038134: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2038138: 92 07 bf a0 add %fp, -96, %o1 <== NOT EXECUTED
203813c: 7f ff f9 b9 call 2036820 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
2038140: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
2038144: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2038148: 04 80 00 10 ble 2038188 <rtems_rfs_dir_del_entry+0x348> <== NOT EXECUTED
203814c: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
2038150: 7f ff ad 56 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2038154: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
2038158: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203815c: 02 80 00 0c be 203818c <rtems_rfs_dir_del_entry+0x34c> <== NOT EXECUTED
2038160: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
2038164: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2038168: 40 00 42 c4 call 2048c78 <strerror> <== NOT EXECUTED
203816c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2038170: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2038174: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2038178: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203817c: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038180: 40 00 39 01 call 2046584 <printf> <== NOT EXECUTED
2038184: 90 12 20 60 or %o0, 0x60, %o0 ! 2067860 <__FUNCTION__.7646+0xbd8><== 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);
2038188: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
203818c: 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);
2038190: c2 2f bf f0 stb %g1, [ %fp + -16 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
2038194: 7f ff fd 03 call 20375a0 <rtems_rfs_buffer_handle_close>
2038198: 92 07 bf f0 add %fp, -16, %o1
rtems_rfs_block_map_close (fs, &map);
203819c: 90 10 00 1d mov %i5, %o0
20381a0: 7f ff f7 b8 call 2036080 <rtems_rfs_block_map_close>
20381a4: 92 07 bf a0 add %fp, -96, %o1
return 0;
20381a8: 81 c7 e0 08 ret
20381ac: 81 e8 00 00 restore
}
if (!search)
20381b0: 02 80 00 20 be 2038230 <rtems_rfs_dir_del_entry+0x3f0> <== NOT EXECUTED
20381b4: ac 05 80 17 add %l6, %l7, %l6 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
20381b8: b8 07 00 17 add %i4, %l7, %i4 <== 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))
20381bc: 80 a7 00 02 cmp %i4, %g2
20381c0: 2a bf ff 72 bcs,a 2037f88 <rtems_rfs_dir_del_entry+0x148><== ALWAYS TAKEN
20381c4: c6 0d a0 09 ldub [ %l6 + 9 ], %g3
entry += elength;
eoffset += elength;
}
if (rc == 0)
20381c8: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
20381cc: 32 80 00 0c bne,a 20381fc <rtems_rfs_dir_del_entry+0x3bc><== NOT EXECUTED
20381d0: b0 10 00 15 mov %l5, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
20381d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20381d8: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
20381dc: 7f ff f8 97 call 2036438 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
20381e0: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
if (rc == ENXIO)
20381e4: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
20381e8: 12 80 00 05 bne 20381fc <rtems_rfs_dir_del_entry+0x3bc> <== NOT EXECUTED
20381ec: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = ENOENT;
20381f0: 10 80 00 06 b 2038208 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
20381f4: 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);
20381f8: b0 10 00 15 mov %l5, %i0 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
20381fc: 80 a6 20 00 cmp %i0, 0
2038200: 02 bf ff 3e be 2037ef8 <rtems_rfs_dir_del_entry+0xb8> <== ALWAYS TAKEN
2038204: d4 07 bf fc ld [ %fp + -4 ], %o2
2038208: aa 10 00 18 mov %i0, %l5 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
203820c: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2038210: 7f ff fc e4 call 20375a0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2038214: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
2038218: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203821c: 92 07 bf a0 add %fp, -96, %o1 <== NOT EXECUTED
2038220: 7f ff f7 98 call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
2038224: b0 10 00 15 mov %l5, %i0 <== NOT EXECUTED
return rc;
}
2038228: 81 c7 e0 08 ret <== NOT EXECUTED
203822c: 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);
2038230: 10 bf ff f2 b 20381f8 <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
2038234: aa 10 20 05 mov 5, %l5 <== NOT EXECUTED
020385c0 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
20385c0: 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))
20385c4: 90 10 20 00 clr %o0
20385c8: 13 20 00 00 sethi %hi(0x80000000), %o1
20385cc: 7f ff ac 37 call 20236a8 <rtems_rfs_trace>
20385d0: ba 10 00 18 mov %i0, %i5
20385d4: 80 8a 20 ff btst 0xff, %o0
20385d8: 02 80 00 07 be 20385f4 <rtems_rfs_dir_empty+0x34> <== ALWAYS TAKEN
20385dc: b8 07 bf a0 add %fp, -96, %i4
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
20385e0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
20385e4: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
20385e8: 40 00 37 e7 call 2046584 <printf> <== NOT EXECUTED
20385ec: 90 12 21 90 or %o0, 0x190, %o0 ! 2067990 <__FUNCTION__.7646+0xd08><== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
20385f0: b8 07 bf a0 add %fp, -96, %i4 <== NOT EXECUTED
20385f4: 90 10 00 1d mov %i5, %o0
20385f8: 92 10 00 19 mov %i1, %o1
20385fc: 7f ff f6 3f call 2035ef8 <rtems_rfs_block_map_open>
2038600: 94 10 00 1c mov %i4, %o2
if (rc > 0)
2038604: b0 92 20 00 orcc %o0, 0, %i0
2038608: 14 80 00 0e bg 2038640 <rtems_rfs_dir_empty+0x80> <== NEVER TAKEN
203860c: b6 07 bf fc add %fp, -4, %i3
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
2038610: 90 10 00 1d mov %i5, %o0
2038614: 92 10 00 1c mov %i4, %o1
2038618: 94 10 20 00 clr %o2
203861c: 96 10 20 00 clr %o3
2038620: 7f ff f7 69 call 20363c4 <rtems_rfs_block_map_seek>
2038624: 98 10 00 1b mov %i3, %o4
if (rc > 0)
2038628: b0 92 20 00 orcc %o0, 0, %i0
203862c: 04 80 00 07 ble 2038648 <rtems_rfs_dir_empty+0x88> <== ALWAYS TAKEN
2038630: 21 00 00 3f sethi %hi(0xfc00), %l0
{
rtems_rfs_block_map_close (fs, &map);
2038634: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2038638: 7f ff f6 92 call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
203863c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
return rc;
2038640: 81 c7 e0 08 ret <== NOT EXECUTED
2038644: 81 e8 00 00 restore <== 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: "
2038648: 35 00 81 9e sethi %hi(0x2067800), %i2
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203864c: c0 2f bf f0 clrb [ %fp + -16 ]
handle->bnum = 0;
2038650: c0 27 bf f4 clr [ %fp + -12 ]
handle->buffer = NULL;
2038654: c0 27 bf f8 clr [ %fp + -8 ]
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038658: a0 14 23 ff or %l0, 0x3ff, %l0
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
203865c: b4 16 a1 b0 or %i2, 0x1b0, %i2
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
2038660: d4 07 bf fc ld [ %fp + -4 ], %o2
2038664: 90 10 00 1d mov %i5, %o0
2038668: 92 07 bf f0 add %fp, -16, %o1
203866c: 7f ff fa 12 call 2036eb4 <rtems_rfs_buffer_handle_request>
2038670: 96 10 20 01 mov 1, %o3
if (rc > 0)
2038674: b0 92 20 00 orcc %o0, 0, %i0
2038678: 14 80 00 55 bg 20387cc <rtems_rfs_dir_empty+0x20c> <== NEVER TAKEN
203867c: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038680: c4 07 60 08 ld [ %i5 + 8 ], %g2
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
2038684: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038688: 84 00 bf f6 add %g2, -10, %g2
203868c: 10 80 00 3e b 2038784 <rtems_rfs_dir_empty+0x1c4>
2038690: a2 10 20 00 clr %l1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
2038694: e6 08 60 08 ldub [ %g1 + 8 ], %l3
eino = rtems_rfs_dir_entry_ino (entry);
2038698: e4 08 40 00 ldub [ %g1 ], %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);
203869c: a7 2c e0 08 sll %l3, 8, %l3
eino = rtems_rfs_dir_entry_ino (entry);
20386a0: de 08 60 01 ldub [ %g1 + 1 ], %o7
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);
20386a4: a6 14 c0 03 or %l3, %g3, %l3
eino = rtems_rfs_dir_entry_ino (entry);
20386a8: c8 08 60 03 ldub [ %g1 + 3 ], %g4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
20386ac: 80 a4 c0 10 cmp %l3, %l0
20386b0: 02 80 00 38 be 2038790 <rtems_rfs_dir_empty+0x1d0>
20386b4: c6 08 60 02 ldub [ %g1 + 2 ], %g3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
20386b8: a5 2c a0 18 sll %l2, 0x18, %l2
20386bc: 9e 0b e0 ff and %o7, 0xff, %o7
20386c0: 88 09 20 ff and %g4, 0xff, %g4
20386c4: 9f 2b e0 10 sll %o7, 0x10, %o7
20386c8: 86 08 e0 ff and %g3, 0xff, %g3
20386cc: a4 14 80 0f or %l2, %o7, %l2
20386d0: 87 28 e0 08 sll %g3, 8, %g3
20386d4: a4 14 80 04 or %l2, %g4, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
20386d8: 80 a4 e0 0a cmp %l3, 0xa
20386dc: 04 80 00 0d ble 2038710 <rtems_rfs_dir_empty+0x150> <== NEVER TAKEN
20386e0: a4 14 80 03 or %l2, %g3, %l2
20386e4: 80 a4 a0 00 cmp %l2, 0
20386e8: 02 80 00 0b be 2038714 <rtems_rfs_dir_empty+0x154> <== NEVER TAKEN
20386ec: 90 10 20 01 mov 1, %o0
20386f0: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
20386f4: 80 a4 c0 03 cmp %l3, %g3
20386f8: 1a 80 00 07 bcc 2038714 <rtems_rfs_dir_empty+0x154> <== NEVER TAKEN
20386fc: 01 00 00 00 nop
2038700: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
2038704: 80 a4 80 03 cmp %l2, %g3
2038708: 08 80 00 10 bleu 2038748 <rtems_rfs_dir_empty+0x188> <== ALWAYS TAKEN
203870c: 80 a4 e0 0b cmp %l3, 0xb
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
2038710: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
2038714: 7f ff ab e5 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2038718: 92 10 20 00 clr %o1 <== NOT EXECUTED
203871c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038720: 22 80 00 1d be,a 2038794 <rtems_rfs_dir_empty+0x1d4> <== NOT EXECUTED
2038724: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
2038728: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203872c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2038730: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
2038734: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
2038738: 40 00 37 93 call 2046584 <printf> <== NOT EXECUTED
203873c: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038740: 10 80 00 15 b 2038794 <rtems_rfs_dir_empty+0x1d4> <== NOT EXECUTED
2038744: 90 10 00 1d mov %i5, %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)) ||
2038748: 12 80 00 04 bne 2038758 <rtems_rfs_dir_empty+0x198>
203874c: 80 a4 e0 0c cmp %l3, 0xc
2038750: 10 80 00 09 b 2038774 <rtems_rfs_dir_empty+0x1b4>
2038754: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
2038758: 12 80 00 1b bne 20387c4 <rtems_rfs_dir_empty+0x204>
203875c: 80 a6 20 00 cmp %i0, 0
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
2038760: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
2038764: 80 a0 e0 2e cmp %g3, 0x2e
2038768: 12 80 00 17 bne 20387c4 <rtems_rfs_dir_empty+0x204> <== NEVER TAKEN
203876c: 80 a6 20 00 cmp %i0, 0
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
2038770: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
2038774: 80 a0 e0 2e cmp %g3, 0x2e
2038778: 12 80 00 12 bne 20387c0 <rtems_rfs_dir_empty+0x200> <== NEVER TAKEN
203877c: 82 00 40 13 add %g1, %l3, %g1
empty = false;
break;
}
entry += elength;
offset += elength;
2038780: a2 04 40 13 add %l1, %l3, %l1
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038784: 80 a4 40 02 cmp %l1, %g2
2038788: 2a bf ff c3 bcs,a 2038694 <rtems_rfs_dir_empty+0xd4> <== ALWAYS TAKEN
203878c: c6 08 60 09 ldub [ %g1 + 9 ], %g3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038790: 90 10 00 1d mov %i5, %o0
2038794: 92 10 00 1c mov %i4, %o1
2038798: 7f ff f7 28 call 2036438 <rtems_rfs_block_map_next_block>
203879c: 94 10 00 1b mov %i3, %o2
if (rc > 0)
20387a0: b0 92 20 00 orcc %o0, 0, %i0
20387a4: 04 bf ff b0 ble 2038664 <rtems_rfs_dir_empty+0xa4> <== NEVER TAKEN
20387a8: d4 07 bf fc ld [ %fp + -4 ], %o2
{
if (rc == ENXIO)
20387ac: 82 1e 20 06 xor %i0, 6, %g1
20387b0: 80 a0 00 01 cmp %g0, %g1
20387b4: 82 60 20 00 subx %g0, 0, %g1
20387b8: 10 80 00 05 b 20387cc <rtems_rfs_dir_empty+0x20c>
20387bc: b0 0e 00 01 and %i0, %g1, %i0
break;
}
}
}
if ((rc == 0) && !empty)
20387c0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
20387c4: 22 80 00 02 be,a 20387cc <rtems_rfs_dir_empty+0x20c> <== ALWAYS TAKEN
20387c8: b0 10 20 5a mov 0x5a, %i0
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
20387cc: 92 07 bf f0 add %fp, -16, %o1
20387d0: 7f ff fb 74 call 20375a0 <rtems_rfs_buffer_handle_close>
20387d4: 90 10 00 1d mov %i5, %o0
rtems_rfs_block_map_close (fs, &map);
20387d8: 90 10 00 1d mov %i5, %o0
20387dc: 7f ff f6 29 call 2036080 <rtems_rfs_block_map_close>
20387e0: 92 07 bf a0 add %fp, -96, %o1
return rc;
}
20387e4: 81 c7 e0 08 ret
20387e8: 81 e8 00 00 restore
02041684 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
2041684: 9d e3 bf a0 save %sp, -96, %sp
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;
2041688: 03 37 f7 c5 sethi %hi(0xdfdf1400), %g1
204168c: 82 10 62 9f or %g1, 0x29f, %g1 ! dfdf169f <RAM_END+0xdd9f169f>
2041690: 82 06 40 01 add %i1, %g1, %g1
2041694: 84 10 00 01 mov %g1, %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)
2041698: 10 80 00 48 b 20417b8 <rtems_rfs_dir_hash+0x134>
204169c: 86 10 00 01 mov %g1, %g3
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
20416a0: de 0e 20 02 ldub [ %i0 + 2 ], %o7
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];
20416a4: 86 01 00 03 add %g4, %g3, %g3
a += ((uint32_t)k[1])<<8;
20416a8: c8 0e 20 01 ldub [ %i0 + 1 ], %g4
a += ((uint32_t)k[2])<<16;
20416ac: 9f 2b e0 10 sll %o7, 0x10, %o7
/*--------------- 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;
20416b0: 89 29 20 08 sll %g4, 8, %g4
20416b4: 88 00 c0 04 add %g3, %g4, %g4
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
20416b8: c6 0e 20 04 ldub [ %i0 + 4 ], %g3
/*--------------- 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;
20416bc: 88 01 00 0f add %g4, %o7, %g4
a += ((uint32_t)k[3])<<24;
b += k[4];
20416c0: 84 00 c0 02 add %g3, %g2, %g2
b += ((uint32_t)k[5])<<8;
20416c4: c6 0e 20 05 ldub [ %i0 + 5 ], %g3
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
20416c8: de 0e 20 03 ldub [ %i0 + 3 ], %o7
b += k[4];
b += ((uint32_t)k[5])<<8;
20416cc: 87 28 e0 08 sll %g3, 8, %g3
20416d0: 84 00 80 03 add %g2, %g3, %g2
b += ((uint32_t)k[6])<<16;
20416d4: c6 0e 20 06 ldub [ %i0 + 6 ], %g3
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
20416d8: 9f 2b e0 18 sll %o7, 0x18, %o7
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
20416dc: 87 28 e0 10 sll %g3, 0x10, %g3
20416e0: 84 00 80 03 add %g2, %g3, %g2
b += ((uint32_t)k[7])<<24;
20416e4: c6 0e 20 07 ldub [ %i0 + 7 ], %g3
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
20416e8: 88 01 00 0f add %g4, %o7, %g4
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
20416ec: 87 28 e0 18 sll %g3, 0x18, %g3
20416f0: 84 00 80 03 add %g2, %g3, %g2
c += k[8];
20416f4: c6 0e 20 08 ldub [ %i0 + 8 ], %g3
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
length -= 12;
20416f8: b2 06 7f f4 add %i1, -12, %i1
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];
20416fc: 82 00 c0 01 add %g3, %g1, %g1
c += ((uint32_t)k[9])<<8;
2041700: c6 0e 20 09 ldub [ %i0 + 9 ], %g3
2041704: 87 28 e0 08 sll %g3, 8, %g3
2041708: 82 00 40 03 add %g1, %g3, %g1
c += ((uint32_t)k[10])<<16;
204170c: c6 0e 20 0a ldub [ %i0 + 0xa ], %g3
2041710: 87 28 e0 10 sll %g3, 0x10, %g3
2041714: 82 00 40 03 add %g1, %g3, %g1
c += ((uint32_t)k[11])<<24;
2041718: c6 0e 20 0b ldub [ %i0 + 0xb ], %g3
mix(a,b,c);
length -= 12;
k += 12;
204171c: b0 06 20 0c add %i0, 0xc, %i0
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;
2041720: 87 28 e0 18 sll %g3, 0x18, %g3
2041724: 82 00 40 03 add %g1, %g3, %g1
mix(a,b,c);
2041728: 88 21 00 01 sub %g4, %g1, %g4
204172c: 9f 28 60 04 sll %g1, 4, %o7
2041730: 87 30 60 1c srl %g1, 0x1c, %g3
2041734: 86 13 c0 03 or %o7, %g3, %g3
2041738: 86 19 00 03 xor %g4, %g3, %g3
204173c: 9f 28 e0 06 sll %g3, 6, %o7
2041740: 89 30 e0 1a srl %g3, 0x1a, %g4
2041744: 88 13 c0 04 or %o7, %g4, %g4
2041748: 82 00 40 02 add %g1, %g2, %g1
204174c: 84 20 80 03 sub %g2, %g3, %g2
2041750: 84 19 00 02 xor %g4, %g2, %g2
2041754: 9f 28 a0 08 sll %g2, 8, %o7
2041758: 89 30 a0 18 srl %g2, 0x18, %g4
204175c: 88 13 c0 04 or %o7, %g4, %g4
2041760: 86 00 c0 01 add %g3, %g1, %g3
2041764: 82 20 40 02 sub %g1, %g2, %g1
2041768: 82 19 00 01 xor %g4, %g1, %g1
204176c: 9f 28 60 10 sll %g1, 0x10, %o7
2041770: 89 30 60 10 srl %g1, 0x10, %g4
2041774: 88 13 c0 04 or %o7, %g4, %g4
2041778: 84 00 80 03 add %g2, %g3, %g2
204177c: 86 20 c0 01 sub %g3, %g1, %g3
2041780: 86 19 00 03 xor %g4, %g3, %g3
2041784: 9f 28 e0 13 sll %g3, 0x13, %o7
2041788: 89 30 e0 0d srl %g3, 0xd, %g4
204178c: 88 13 c0 04 or %o7, %g4, %g4
2041790: 82 00 40 02 add %g1, %g2, %g1
2041794: 84 20 80 03 sub %g2, %g3, %g2
2041798: 86 00 c0 01 add %g3, %g1, %g3
204179c: 84 19 00 02 xor %g4, %g2, %g2
20417a0: 82 20 40 02 sub %g1, %g2, %g1
20417a4: 9f 28 a0 04 sll %g2, 4, %o7
20417a8: 89 30 a0 1c srl %g2, 0x1c, %g4
20417ac: 84 00 80 03 add %g2, %g3, %g2
20417b0: 88 13 c0 04 or %o7, %g4, %g4
20417b4: 82 19 00 01 xor %g4, %g1, %g1
} 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)
20417b8: 80 a6 60 0c cmp %i1, 0xc
20417bc: 38 bf ff b9 bgu,a 20416a0 <rtems_rfs_dir_hash+0x1c>
20417c0: c8 0e 00 00 ldub [ %i0 ], %g4
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
20417c4: b2 06 7f ff add %i1, -1, %i1
20417c8: 80 a6 60 0b cmp %i1, 0xb
20417cc: 18 80 00 4b bgu 20418f8 <rtems_rfs_dir_hash+0x274> <== NEVER TAKEN
20417d0: b3 2e 60 02 sll %i1, 2, %i1
20417d4: 09 00 81 05 sethi %hi(0x2041400), %g4
20417d8: 88 11 22 54 or %g4, 0x254, %g4 ! 2041654 <rtems_rfs_buffer_bdbuf_release+0x7c>
20417dc: c8 01 00 19 ld [ %g4 + %i1 ], %g4
20417e0: 81 c1 00 00 jmp %g4
20417e4: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
20417e8: c8 0e 20 0b ldub [ %i0 + 0xb ], %g4
20417ec: 89 29 20 18 sll %g4, 0x18, %g4
20417f0: 82 01 00 01 add %g4, %g1, %g1
case 11: c+=((uint32_t)k[10])<<16;
20417f4: c8 0e 20 0a ldub [ %i0 + 0xa ], %g4
20417f8: 89 29 20 10 sll %g4, 0x10, %g4
20417fc: 82 00 40 04 add %g1, %g4, %g1
case 10: c+=((uint32_t)k[9])<<8;
2041800: c8 0e 20 09 ldub [ %i0 + 9 ], %g4
2041804: 89 29 20 08 sll %g4, 8, %g4
2041808: 82 00 40 04 add %g1, %g4, %g1
case 9 : c+=k[8];
204180c: c8 0e 20 08 ldub [ %i0 + 8 ], %g4
2041810: 82 00 40 04 add %g1, %g4, %g1
case 8 : b+=((uint32_t)k[7])<<24;
2041814: c8 0e 20 07 ldub [ %i0 + 7 ], %g4
2041818: 89 29 20 18 sll %g4, 0x18, %g4
204181c: 84 01 00 02 add %g4, %g2, %g2
case 7 : b+=((uint32_t)k[6])<<16;
2041820: c8 0e 20 06 ldub [ %i0 + 6 ], %g4
2041824: 89 29 20 10 sll %g4, 0x10, %g4
2041828: 84 00 80 04 add %g2, %g4, %g2
case 6 : b+=((uint32_t)k[5])<<8;
204182c: c8 0e 20 05 ldub [ %i0 + 5 ], %g4
2041830: 89 29 20 08 sll %g4, 8, %g4
2041834: 84 00 80 04 add %g2, %g4, %g2
case 5 : b+=k[4];
2041838: c8 0e 20 04 ldub [ %i0 + 4 ], %g4
204183c: 84 00 80 04 add %g2, %g4, %g2
case 4 : a+=((uint32_t)k[3])<<24;
2041840: c8 0e 20 03 ldub [ %i0 + 3 ], %g4
2041844: 89 29 20 18 sll %g4, 0x18, %g4
2041848: 86 01 00 03 add %g4, %g3, %g3
case 3 : a+=((uint32_t)k[2])<<16;
204184c: c8 0e 20 02 ldub [ %i0 + 2 ], %g4
2041850: 89 29 20 10 sll %g4, 0x10, %g4
2041854: 86 00 c0 04 add %g3, %g4, %g3
case 2 : a+=((uint32_t)k[1])<<8;
2041858: c8 0e 20 01 ldub [ %i0 + 1 ], %g4
204185c: 89 29 20 08 sll %g4, 8, %g4
2041860: 86 00 c0 04 add %g3, %g4, %g3
case 1 : a+=k[0];
2041864: c8 0e 00 00 ldub [ %i0 ], %g4
break;
case 0 : return c;
}
}
final(a,b,c);
2041868: b3 30 a0 12 srl %g2, 0x12, %i1
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];
204186c: 86 00 c0 04 add %g3, %g4, %g3
break;
case 0 : return c;
}
}
final(a,b,c);
2041870: 89 28 a0 0e sll %g2, 0xe, %g4
2041874: 88 16 40 04 or %i1, %g4, %g4
2041878: 82 18 40 02 xor %g1, %g2, %g1
204187c: 82 20 40 04 sub %g1, %g4, %g1
2041880: b3 28 60 0b sll %g1, 0xb, %i1
2041884: 89 30 60 15 srl %g1, 0x15, %g4
2041888: 88 16 40 04 or %i1, %g4, %g4
204188c: 86 18 40 03 xor %g1, %g3, %g3
2041890: 86 20 c0 04 sub %g3, %g4, %g3
2041894: b3 28 e0 19 sll %g3, 0x19, %i1
2041898: 89 30 e0 07 srl %g3, 7, %g4
204189c: 88 16 40 04 or %i1, %g4, %g4
20418a0: 84 18 c0 02 xor %g3, %g2, %g2
20418a4: 84 20 80 04 sub %g2, %g4, %g2
20418a8: b3 28 a0 10 sll %g2, 0x10, %i1
20418ac: 89 30 a0 10 srl %g2, 0x10, %g4
20418b0: 88 16 40 04 or %i1, %g4, %g4
20418b4: 82 18 80 01 xor %g2, %g1, %g1
20418b8: 82 20 40 04 sub %g1, %g4, %g1
20418bc: b3 28 60 04 sll %g1, 4, %i1
20418c0: 89 30 60 1c srl %g1, 0x1c, %g4
20418c4: 88 16 40 04 or %i1, %g4, %g4
20418c8: 86 18 40 03 xor %g1, %g3, %g3
20418cc: 86 20 c0 04 sub %g3, %g4, %g3
20418d0: 84 18 c0 02 xor %g3, %g2, %g2
20418d4: 89 28 e0 0e sll %g3, 0xe, %g4
20418d8: 87 30 e0 12 srl %g3, 0x12, %g3
20418dc: 86 11 00 03 or %g4, %g3, %g3
20418e0: 84 20 80 03 sub %g2, %g3, %g2
20418e4: 82 18 80 01 xor %g2, %g1, %g1
20418e8: 87 28 a0 18 sll %g2, 0x18, %g3
20418ec: 85 30 a0 08 srl %g2, 8, %g2
20418f0: 84 10 c0 02 or %g3, %g2, %g2
20418f4: 82 20 40 02 sub %g1, %g2, %g1
return c;
}
20418f8: 81 c7 e0 08 ret
20418fc: 91 e8 00 01 restore %g0, %g1, %o0
020375c8 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
20375c8: 9d e3 bf 40 save %sp, -192, %sp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
20375cc: 90 10 20 00 clr %o0
20375d0: 7f ff b0 36 call 20236a8 <rtems_rfs_trace>
20375d4: 13 01 00 00 sethi %hi(0x4000000), %o1
20375d8: 80 8a 20 ff btst 0xff, %o0
20375dc: 22 80 00 13 be,a 2037628 <rtems_rfs_dir_lookup_ino+0x60> <== ALWAYS TAKEN
20375e0: c0 27 00 00 clr [ %i4 ]
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
20375e4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
20375e8: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
20375ec: a0 10 20 00 clr %l0 <== 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=",
20375f0: 40 00 3b e5 call 2046584 <printf> <== NOT EXECUTED
20375f4: 90 12 22 e8 or %o0, 0x2e8, %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
20375f8: 10 80 00 05 b 203760c <rtems_rfs_dir_lookup_ino+0x44> <== NOT EXECUTED
20375fc: 80 a4 00 1b cmp %l0, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
2037600: 40 00 3c 4e call 2046738 <putchar> <== NOT EXECUTED
2037604: a0 04 20 01 inc %l0 <== 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++)
2037608: 80 a4 00 1b cmp %l0, %i3 <== NOT EXECUTED
203760c: 26 bf ff fd bl,a 2037600 <rtems_rfs_dir_lookup_ino+0x38> <== NOT EXECUTED
2037610: d0 4e 80 10 ldsb [ %i2 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
2037614: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037618: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203761c: 40 00 3b da call 2046584 <printf> <== NOT EXECUTED
2037620: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
2037624: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
2037628: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
203762c: 90 10 00 18 mov %i0, %o0
2037630: 92 10 00 19 mov %i1, %o1
2037634: 7f ff fa 31 call 2035ef8 <rtems_rfs_block_map_open>
2037638: 94 07 bf a0 add %fp, -96, %o2
if (rc > 0)
203763c: a0 92 20 00 orcc %o0, 0, %l0
2037640: 04 80 00 12 ble 2037688 <rtems_rfs_dir_lookup_ino+0xc0> <== ALWAYS TAKEN
2037644: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037648: 7f ff b0 18 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203764c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2037650: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037654: 22 80 01 0c be,a 2037a84 <rtems_rfs_dir_lookup_ino+0x4bc><== NOT EXECUTED
2037658: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
203765c: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
2037660: 40 00 45 86 call 2048c78 <strerror> <== NOT EXECUTED
2037664: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2037668: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203766c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2037670: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2037674: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037678: 40 00 3b c3 call 2046584 <printf> <== NOT EXECUTED
203767c: 90 12 23 30 or %o0, 0x330, %o0 ! 2067330 <__FUNCTION__.7646+0x6a8><== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
2037680: 81 c7 e0 08 ret <== NOT EXECUTED
2037684: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
2037688: 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;
203768c: c0 2f bf f0 clrb [ %fp + -16 ]
handle->bnum = 0;
2037690: c0 27 bf f4 clr [ %fp + -12 ]
handle->buffer = NULL;
2037694: c0 27 bf f8 clr [ %fp + -8 ]
2037698: 40 00 27 fb call 2041684 <rtems_rfs_dir_hash>
203769c: 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);
20376a0: 92 07 bf a0 add %fp, -96, %o1
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
20376a4: a8 10 00 08 mov %o0, %l4
/*
* 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);
20376a8: 94 10 20 00 clr %o2
20376ac: 90 10 00 18 mov %i0, %o0
20376b0: 96 10 20 00 clr %o3
20376b4: 7f ff fb 44 call 20363c4 <rtems_rfs_block_map_seek>
20376b8: 98 07 bf fc add %fp, -4, %o4
if (rc > 0)
20376bc: a0 92 20 00 orcc %o0, 0, %l0
20376c0: 04 80 00 d1 ble 2037a04 <rtems_rfs_dir_lookup_ino+0x43c> <== ALWAYS TAKEN
20376c4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
20376c8: 7f ff af f8 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20376cc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
20376d0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20376d4: 02 80 00 0a be 20376fc <rtems_rfs_dir_lookup_ino+0x134> <== NOT EXECUTED
20376d8: 80 a4 20 06 cmp %l0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
20376dc: 40 00 45 67 call 2048c78 <strerror> <== NOT EXECUTED
20376e0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20376e4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20376e8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20376ec: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20376f0: 40 00 3b a5 call 2046584 <printf> <== NOT EXECUTED
20376f4: 90 12 23 70 or %o0, 0x370, %o0 ! 2067370 <__FUNCTION__.7646+0x6e8><== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
20376f8: 80 a4 20 06 cmp %l0, 6 <== NOT EXECUTED
20376fc: 22 80 00 db be,a 2037a68 <rtems_rfs_dir_lookup_ino+0x4a0><== NOT EXECUTED
2037700: a0 10 20 02 mov 2, %l0 <== 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);
2037704: 10 80 00 da b 2037a6c <rtems_rfs_dir_lookup_ino+0x4a4> <== NOT EXECUTED
2037708: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
203770c: 7f ff af e7 call 20236a8 <rtems_rfs_trace>
2037710: 13 01 00 00 sethi %hi(0x4000000), %o1
2037714: 80 8a 20 ff btst 0xff, %o0
2037718: 02 80 00 07 be 2037734 <rtems_rfs_dir_lookup_ino+0x16c> <== ALWAYS TAKEN
203771c: d4 07 bf fc ld [ %fp + -4 ], %o2
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
2037720: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037724: d4 07 bf b0 ld [ %fp + -80 ], %o2 <== NOT EXECUTED
2037728: 40 00 3b 97 call 2046584 <printf> <== NOT EXECUTED
203772c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
2037730: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2037734: 90 10 00 18 mov %i0, %o0
2037738: 92 07 bf f0 add %fp, -16, %o1
203773c: 7f ff fd de call 2036eb4 <rtems_rfs_buffer_handle_request>
2037740: 96 10 20 01 mov 1, %o3
if (rc > 0)
2037744: a4 92 20 00 orcc %o0, 0, %l2
2037748: 04 80 00 15 ble 203779c <rtems_rfs_dir_lookup_ino+0x1d4> <== ALWAYS TAKEN
203774c: c2 07 bf f8 ld [ %fp + -8 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037750: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037754: 7f ff af d5 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037758: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
203775c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037760: 22 80 00 c2 be,a 2037a68 <rtems_rfs_dir_lookup_ino+0x4a0><== NOT EXECUTED
2037764: a0 10 00 12 mov %l2, %l0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
2037768: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
203776c: fa 07 bf fc ld [ %fp + -4 ], %i5 <== NOT EXECUTED
2037770: 40 00 45 42 call 2048c78 <strerror> <== NOT EXECUTED
2037774: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
2037778: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203777c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
2037780: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2037784: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037788: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
203778c: 40 00 3b 7e call 2046584 <printf> <== NOT EXECUTED
2037790: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
2037794: 10 80 00 b5 b 2037a68 <rtems_rfs_dir_lookup_ino+0x4a0> <== NOT EXECUTED
2037798: a0 10 00 12 mov %l2, %l0 <== NOT EXECUTED
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
203779c: c0 27 bf b4 clr [ %fp + -76 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
20377a0: 10 80 00 6e b 2037958 <rtems_rfs_dir_lookup_ino+0x390>
20377a4: e2 00 60 1c ld [ %g1 + 0x1c ], %l1
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
20377a8: e6 0c 60 08 ldub [ %l1 + 8 ], %l3
*ino = rtems_rfs_dir_entry_ino (entry);
20377ac: da 0c 40 00 ldub [ %l1 ], %o5
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
20377b0: a7 2c e0 08 sll %l3, 8, %l3
20377b4: a6 14 c0 01 or %l3, %g1, %l3
*ino = rtems_rfs_dir_entry_ino (entry);
20377b8: c2 0c 60 01 ldub [ %l1 + 1 ], %g1
20377bc: 9b 2b 60 18 sll %o5, 0x18, %o5
20377c0: 83 28 60 10 sll %g1, 0x10, %g1
20377c4: 82 13 40 01 or %o5, %g1, %g1
20377c8: da 0c 60 03 ldub [ %l1 + 3 ], %o5
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);
20377cc: c8 0c 60 04 ldub [ %l1 + 4 ], %g4
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
20377d0: 82 10 40 0d or %g1, %o5, %g1
20377d4: da 0c 60 02 ldub [ %l1 + 2 ], %o5
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);
20377d8: de 0c 60 05 ldub [ %l1 + 5 ], %o7
20377dc: c4 0c 60 06 ldub [ %l1 + 6 ], %g2
20377e0: c6 0c 60 07 ldub [ %l1 + 7 ], %g3
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
20377e4: 9b 2b 60 08 sll %o5, 8, %o5
20377e8: 82 10 40 0d or %g1, %o5, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
20377ec: 80 a4 c0 16 cmp %l3, %l6
20377f0: 02 80 00 60 be 2037970 <rtems_rfs_dir_lookup_ino+0x3a8>
20377f4: c2 27 00 00 st %g1, [ %i4 ]
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
20377f8: 80 a4 e0 0a cmp %l3, 0xa
20377fc: 04 80 00 0d ble 2037830 <rtems_rfs_dir_lookup_ino+0x268> <== NEVER TAKEN
2037800: 90 10 20 00 clr %o0
2037804: da 06 20 1c ld [ %i0 + 0x1c ], %o5
2037808: 80 a4 c0 0d cmp %l3, %o5
203780c: 1a 80 00 09 bcc 2037830 <rtems_rfs_dir_lookup_ino+0x268> <== NEVER TAKEN
2037810: 80 a0 60 00 cmp %g1, 0
2037814: 02 80 00 07 be 2037830 <rtems_rfs_dir_lookup_ino+0x268> <== NEVER TAKEN
2037818: 01 00 00 00 nop
203781c: da 06 20 14 ld [ %i0 + 0x14 ], %o5
2037820: 80 a0 40 0d cmp %g1, %o5
2037824: 08 80 00 11 bleu 2037868 <rtems_rfs_dir_lookup_ino+0x2a0> <== ALWAYS TAKEN
2037828: 89 29 20 18 sll %g4, 0x18, %g4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
203782c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037830: 7f ff af 9e call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037834: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2037838: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203783c: 22 80 00 70 be,a 20379fc <rtems_rfs_dir_lookup_ino+0x434><== NOT EXECUTED
2037840: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
2037844: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037848: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
203784c: d8 07 bf b4 ld [ %fp + -76 ], %o4 <== NOT EXECUTED
2037850: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037854: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
2037858: 40 00 3b 4b call 2046584 <printf> <== NOT EXECUTED
203785c: 90 12 20 30 or %o0, 0x30, %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;
2037860: 10 80 00 67 b 20379fc <rtems_rfs_dir_lookup_ino+0x434> <== NOT EXECUTED
2037864: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
2037868: 82 0b e0 ff and %o7, 0xff, %g1
203786c: 86 08 e0 ff and %g3, 0xff, %g3
2037870: 83 28 60 10 sll %g1, 0x10, %g1
2037874: 84 08 a0 ff and %g2, 0xff, %g2
2037878: 82 11 00 01 or %g4, %g1, %g1
203787c: 85 28 a0 08 sll %g2, 8, %g2
2037880: 82 10 40 03 or %g1, %g3, %g1
2037884: 82 10 40 02 or %g1, %g2, %g1
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
2037888: 80 a0 40 14 cmp %g1, %l4
203788c: 12 80 00 30 bne 203794c <rtems_rfs_dir_lookup_ino+0x384>
2037890: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
2037894: 90 10 20 00 clr %o0
2037898: 7f ff af 84 call 20236a8 <rtems_rfs_trace>
203789c: 13 02 00 00 sethi %hi(0x8000000), %o1
20378a0: 80 8a 20 ff btst 0xff, %o0
20378a4: 02 80 00 12 be 20378ec <rtems_rfs_dir_lookup_ino+0x324> <== ALWAYS TAKEN
20378a8: 90 04 60 0a add %l1, 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));
20378ac: c2 0c 60 01 ldub [ %l1 + 1 ], %g1 <== NOT EXECUTED
20378b0: da 0c 40 00 ldub [ %l1 ], %o5 <== NOT EXECUTED
20378b4: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
20378b8: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
20378bc: 9a 13 40 01 or %o5, %g1, %o5 <== NOT EXECUTED
20378c0: c2 0c 60 03 ldub [ %l1 + 3 ], %g1 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
20378c4: 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));
20378c8: 9a 13 40 01 or %o5, %g1, %o5 <== NOT EXECUTED
20378cc: c2 0c 60 02 ldub [ %l1 + 2 ], %g1 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
20378d0: d4 1f bf b0 ldd [ %fp + -80 ], %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));
20378d4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
20378d8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
20378dc: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED
20378e0: 40 00 3b 29 call 2046584 <printf> <== NOT EXECUTED
20378e4: 9a 13 40 01 or %o5, %g1, %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)
20378e8: 90 04 60 0a add %l1, 0xa, %o0 <== NOT EXECUTED
20378ec: 92 10 00 1a mov %i2, %o1
20378f0: 40 00 35 ff call 20450ec <memcmp>
20378f4: 94 10 00 1b mov %i3, %o2
20378f8: 80 a2 20 00 cmp %o0, 0
20378fc: 12 80 00 14 bne 203794c <rtems_rfs_dir_lookup_ino+0x384> <== NEVER TAKEN
2037900: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
*offset = rtems_rfs_block_map_pos (fs, &map);
2037904: 90 10 00 18 mov %i0, %o0
2037908: 7f ff f9 47 call 2035e24 <rtems_rfs_block_get_pos>
203790c: 92 07 bf b0 add %fp, -80, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
2037910: 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);
2037914: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
2037918: 7f ff af 64 call 20236a8 <rtems_rfs_trace>
203791c: 13 04 00 00 sethi %hi(0x10000000), %o1
2037920: 80 8a 20 ff btst 0xff, %o0
2037924: 22 80 00 52 be,a 2037a6c <rtems_rfs_dir_lookup_ino+0x4a4><== ALWAYS TAKEN
2037928: 92 07 bf f0 add %fp, -16, %o1
printf ("rtems-rfs: dir-lookup-ino: "
203792c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037930: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
2037934: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
2037938: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
203793c: 40 00 3b 12 call 2046584 <printf> <== NOT EXECUTED
2037940: 90 12 20 e0 or %o0, 0xe0, %o0 ! 20674e0 <__FUNCTION__.7646+0x858><== 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);
2037944: 10 80 00 4a b 2037a6c <rtems_rfs_dir_lookup_ino+0x4a4> <== NOT EXECUTED
2037948: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
203794c: a2 04 40 13 add %l1, %l3, %l1
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
2037950: 82 00 40 13 add %g1, %l3, %g1
2037954: c2 27 bf b4 st %g1, [ %fp + -76 ]
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))
2037958: c2 06 20 08 ld [ %i0 + 8 ], %g1
203795c: c4 07 bf b4 ld [ %fp + -76 ], %g2
2037960: 82 00 7f f6 add %g1, -10, %g1
2037964: 80 a0 80 01 cmp %g2, %g1
2037968: 2a bf ff 90 bcs,a 20377a8 <rtems_rfs_dir_lookup_ino+0x1e0><== ALWAYS TAKEN
203796c: c2 0c 60 09 ldub [ %l1 + 9 ], %g1
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
2037970: 80 a4 a0 00 cmp %l2, 0
2037974: 12 80 00 2a bne 2037a1c <rtems_rfs_dir_lookup_ino+0x454> <== NEVER TAKEN
2037978: a0 10 00 12 mov %l2, %l0
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
203797c: 90 10 00 18 mov %i0, %o0
2037980: 92 07 bf a0 add %fp, -96, %o1
2037984: 7f ff fa ad call 2036438 <rtems_rfs_block_map_next_block>
2037988: 94 07 bf fc add %fp, -4, %o2
if ((rc > 0) && (rc != ENXIO))
203798c: 80 a2 20 06 cmp %o0, 6
2037990: 02 80 00 16 be 20379e8 <rtems_rfs_dir_lookup_ino+0x420> <== ALWAYS TAKEN
2037994: a0 10 00 08 mov %o0, %l0
2037998: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
203799c: 04 80 00 14 ble 20379ec <rtems_rfs_dir_lookup_ino+0x424> <== NOT EXECUTED
20379a0: 80 a4 20 06 cmp %l0, 6 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
20379a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20379a8: 7f ff af 40 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20379ac: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
20379b0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20379b4: 22 80 00 1b be,a 2037a20 <rtems_rfs_dir_lookup_ino+0x458><== NOT EXECUTED
20379b8: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
20379bc: e2 06 60 08 ld [ %i1 + 8 ], %l1 <== NOT EXECUTED
20379c0: 40 00 44 ae call 2048c78 <strerror> <== NOT EXECUTED
20379c4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20379c8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
20379cc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20379d0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
20379d4: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
20379d8: 40 00 3a eb call 2046584 <printf> <== NOT EXECUTED
20379dc: 90 12 21 28 or %o0, 0x128, %o0 ! 2067528 <__FUNCTION__.7646+0x8a0><== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
20379e0: 10 80 00 10 b 2037a20 <rtems_rfs_dir_lookup_ino+0x458> <== NOT EXECUTED
20379e4: 80 a4 20 00 cmp %l0, 0 <== 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)
20379e8: 80 a4 20 06 cmp %l0, 6
20379ec: 12 80 00 0d bne 2037a20 <rtems_rfs_dir_lookup_ino+0x458> <== NEVER TAKEN
20379f0: 80 a4 20 00 cmp %l0, 0
rc = ENOENT;
20379f4: 10 80 00 11 b 2037a38 <rtems_rfs_dir_lookup_ino+0x470>
20379f8: a0 10 20 02 mov 2, %l0
20379fc: 10 80 00 08 b 2037a1c <rtems_rfs_dir_lookup_ino+0x454> <== NOT EXECUTED
2037a00: a0 10 00 12 mov %l2, %l0 <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
2037a04: 2b 00 81 9c sethi %hi(0x2067000), %l5
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)
2037a08: 2d 00 00 3f sethi %hi(0xfc00), %l6
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
2037a0c: 2f 00 81 9d sethi %hi(0x2067400), %l7
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
2037a10: aa 15 63 b0 or %l5, 0x3b0, %l5
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)
2037a14: ac 15 a3 ff or %l6, 0x3ff, %l6
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
2037a18: ae 15 e0 80 or %l7, 0x80, %l7
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
2037a1c: 80 a4 20 00 cmp %l0, 0
2037a20: 12 80 00 06 bne 2037a38 <rtems_rfs_dir_lookup_ino+0x470> <== NEVER TAKEN
2037a24: c2 07 bf fc ld [ %fp + -4 ], %g1
2037a28: 80 a0 60 00 cmp %g1, 0
2037a2c: 12 bf ff 38 bne 203770c <rtems_rfs_dir_lookup_ino+0x144> <== ALWAYS TAKEN
2037a30: 90 10 20 00 clr %o0
2037a34: 30 80 00 16 b,a 2037a8c <rtems_rfs_dir_lookup_ino+0x4c4> <== NOT EXECUTED
2037a38: a4 10 00 10 mov %l0, %l2
2037a3c: 10 80 00 0b b 2037a68 <rtems_rfs_dir_lookup_ino+0x4a0>
2037a40: a0 10 00 12 mov %l2, %l0
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",
2037a44: 40 00 44 8d call 2048c78 <strerror> <== NOT EXECUTED
2037a48: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
2037a4c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037a50: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2037a54: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
2037a58: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037a5c: 40 00 3a ca call 2046584 <printf> <== NOT EXECUTED
2037a60: 90 12 21 78 or %o0, 0x178, %o0 ! 2067578 <__FUNCTION__.7646+0x8f0><== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
2037a64: a0 10 20 05 mov 5, %l0 <== 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);
2037a68: 92 07 bf f0 add %fp, -16, %o1
2037a6c: 7f ff fe cd call 20375a0 <rtems_rfs_buffer_handle_close>
2037a70: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
2037a74: 90 10 00 18 mov %i0, %o0
2037a78: 7f ff f9 82 call 2036080 <rtems_rfs_block_map_close>
2037a7c: 92 07 bf a0 add %fp, -96, %o1
return rc;
}
2037a80: b0 10 00 10 mov %l0, %i0
2037a84: 81 c7 e0 08 ret
2037a88: 81 e8 00 00 restore
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037a8c: 7f ff af 07 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2037a90: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2037a94: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037a98: 02 bf ff f4 be 2037a68 <rtems_rfs_dir_lookup_ino+0x4a0> <== NOT EXECUTED
2037a9c: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
2037aa0: 10 bf ff e9 b 2037a44 <rtems_rfs_dir_lookup_ino+0x47c> <== NOT EXECUTED
2037aa4: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
02038238 <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)
{
2038238: 9d e3 bf 38 save %sp, -200, %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))
203823c: 90 10 20 00 clr %o0
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)
{
2038240: a2 10 00 19 mov %i1, %l1
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))
2038244: 13 20 00 00 sethi %hi(0x80000000), %o1
2038248: 7f ff ad 18 call 20236a8 <rtems_rfs_trace>
203824c: a0 10 00 1a mov %i2, %l0
2038250: 80 8a 20 ff btst 0xff, %o0
2038254: 02 80 00 08 be 2038274 <rtems_rfs_dir_read+0x3c> <== ALWAYS TAKEN
2038258: b2 10 00 1b mov %i3, %i1
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
203825c: d2 04 60 08 ld [ %l1 + 8 ], %o1 <== NOT EXECUTED
2038260: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038264: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2038268: 90 12 20 a8 or %o0, 0xa8, %o0 <== NOT EXECUTED
203826c: 40 00 38 c6 call 2046584 <printf> <== NOT EXECUTED
2038270: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
2038274: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, dir, &map);
2038278: 90 10 00 18 mov %i0, %o0
203827c: 92 10 00 11 mov %l1, %o1
2038280: 7f ff f7 1e call 2035ef8 <rtems_rfs_block_map_open>
2038284: 94 07 bf a0 add %fp, -96, %o2
if (rc > 0)
2038288: b4 92 20 00 orcc %o0, 0, %i2
203828c: 14 80 00 cb bg 20385b8 <rtems_rfs_dir_read+0x380> <== NEVER TAKEN
2038290: 90 10 00 10 mov %l0, %o0
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
2038294: f4 06 20 08 ld [ %i0 + 8 ], %i2
2038298: b6 10 00 1a mov %i2, %i3
203829c: 92 10 00 19 mov %i1, %o1
20382a0: b4 10 20 00 clr %i2
20382a4: 96 10 00 1b mov %i3, %o3
20382a8: 40 00 8f 31 call 205bf6c <__moddi3>
20382ac: 94 10 00 1a mov %i2, %o2
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
20382b0: 86 a6 c0 09 subcc %i3, %o1, %g3
20382b4: 84 66 80 08 subx %i2, %o0, %g2
20382b8: 80 a0 a0 00 cmp %g2, 0
20382bc: 34 80 00 15 bg,a 2038310 <rtems_rfs_dir_read+0xd8> <== NEVER TAKEN
20382c0: b6 07 bf a0 add %fp, -96, %i3 <== NOT EXECUTED
20382c4: 80 a0 a0 00 cmp %g2, 0
20382c8: 32 80 00 06 bne,a 20382e0 <rtems_rfs_dir_read+0xa8> <== NEVER TAKEN
20382cc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20382d0: 80 a0 e0 0a cmp %g3, 0xa
20382d4: 38 80 00 0f bgu,a 2038310 <rtems_rfs_dir_read+0xd8> <== ALWAYS TAKEN
20382d8: b6 07 bf a0 add %fp, -96, %i3
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
20382dc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20382e0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20382e4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20382e8: 40 00 8e 3b call 205bbd4 <__divdi3> <== NOT EXECUTED
20382ec: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
20382f0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20382f4: 92 82 60 01 inccc %o1 <== NOT EXECUTED
20382f8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
20382fc: 40 00 8d ad call 205b9b0 <__muldi3> <== NOT EXECUTED
2038300: 90 42 20 00 addx %o0, 0, %o0 <== NOT EXECUTED
2038304: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
2038308: b2 10 00 09 mov %o1, %i1 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
203830c: b6 07 bf a0 add %fp, -96, %i3 <== NOT EXECUTED
2038310: a4 07 bf fc add %fp, -4, %l2
2038314: 90 10 00 18 mov %i0, %o0
2038318: 92 10 00 1b mov %i3, %o1
203831c: 94 10 00 10 mov %l0, %o2
2038320: 96 10 00 19 mov %i1, %o3
2038324: 7f ff f8 28 call 20363c4 <rtems_rfs_block_map_seek>
2038328: 98 10 00 12 mov %l2, %o4
if (rc > 0)
203832c: b4 92 20 00 orcc %o0, 0, %i2
2038330: 04 80 00 07 ble 203834c <rtems_rfs_dir_read+0x114> <== ALWAYS TAKEN
2038334: 80 a6 a0 06 cmp %i2, 6
{
if (rc == ENXIO)
2038338: 22 80 00 02 be,a 2038340 <rtems_rfs_dir_read+0x108> <== NOT EXECUTED
203833c: b4 10 20 02 mov 2, %i2 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
2038340: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2038344: 10 80 00 9b b 20385b0 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
2038348: 92 10 00 1b mov %i3, %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)
203834c: 29 00 00 3f sethi %hi(0xfc00), %l4
}
*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",
2038350: 27 00 81 9e sethi %hi(0x2067800), %l3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2038354: c0 2f bf f0 clrb [ %fp + -16 ]
handle->bnum = 0;
2038358: c0 27 bf f4 clr [ %fp + -12 ]
handle->buffer = NULL;
203835c: c0 27 bf f8 clr [ %fp + -8 ]
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)
2038360: a8 15 23 ff or %l4, 0x3ff, %l4
}
*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",
2038364: a6 14 e1 58 or %l3, 0x158, %l3
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
2038368: d4 07 bf fc ld [ %fp + -4 ], %o2
203836c: 90 10 00 18 mov %i0, %o0
2038370: 92 07 bf f0 add %fp, -16, %o1
2038374: 7f ff fa d0 call 2036eb4 <rtems_rfs_buffer_handle_request>
2038378: 96 10 20 01 mov 1, %o3
if (rc > 0)
203837c: b4 92 20 00 orcc %o0, 0, %i2
2038380: 14 80 00 88 bg 20385a0 <rtems_rfs_dir_read+0x368> <== NEVER TAKEN
2038384: 92 07 bf f0 add %fp, -16, %o1
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
2038388: c2 07 bf f8 ld [ %fp + -8 ], %g1
entry += map.bpos.boff;
203838c: ee 07 bf b4 ld [ %fp + -76 ], %l7
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
2038390: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
entry += map.bpos.boff;
2038394: aa 00 40 17 add %g1, %l7, %l5
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
2038398: d6 08 40 17 ldub [ %g1 + %l7 ], %o3
203839c: c2 0d 60 01 ldub [ %l5 + 1 ], %g1
20383a0: 97 2a e0 18 sll %o3, 0x18, %o3
20383a4: 83 28 60 10 sll %g1, 0x10, %g1
20383a8: 96 12 c0 01 or %o3, %g1, %o3
20383ac: c2 0d 60 03 ldub [ %l5 + 3 ], %g1
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
20383b0: ec 0d 60 08 ldub [ %l5 + 8 ], %l6
eino = rtems_rfs_dir_entry_ino (entry);
20383b4: 96 12 c0 01 or %o3, %g1, %o3
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
20383b8: c4 0d 60 09 ldub [ %l5 + 9 ], %g2
eino = rtems_rfs_dir_entry_ino (entry);
20383bc: c2 0d 60 02 ldub [ %l5 + 2 ], %g1
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
20383c0: ad 2d a0 08 sll %l6, 8, %l6
eino = rtems_rfs_dir_entry_ino (entry);
20383c4: 83 28 60 08 sll %g1, 8, %g1
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
20383c8: ac 15 80 02 or %l6, %g2, %l6
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
20383cc: 80 a5 80 14 cmp %l6, %l4
20383d0: 02 80 00 56 be 2038528 <rtems_rfs_dir_read+0x2f0>
20383d4: 96 12 c0 01 or %o3, %g1, %o3
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
20383d8: 80 a5 a0 0a cmp %l6, 0xa
20383dc: 24 80 00 0e ble,a 2038414 <rtems_rfs_dir_read+0x1dc> <== NEVER TAKEN
20383e0: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
20383e4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
20383e8: 80 a5 80 01 cmp %l6, %g1
20383ec: 3a 80 00 0a bcc,a 2038414 <rtems_rfs_dir_read+0x1dc> <== NEVER TAKEN
20383f0: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
20383f4: 80 a2 e0 00 cmp %o3, 0
20383f8: 22 80 00 07 be,a 2038414 <rtems_rfs_dir_read+0x1dc> <== NEVER TAKEN
20383fc: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
2038400: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2038404: 80 a2 c0 01 cmp %o3, %g1
2038408: 08 80 00 12 bleu 2038450 <rtems_rfs_dir_read+0x218> <== ALWAYS TAKEN
203840c: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038410: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
2038414: 90 10 20 00 clr %o0 <== NOT EXECUTED
2038418: 7f ff ac a4 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203841c: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04" PRIx32 "\n",
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
2038420: b4 10 20 05 mov 5, %i2 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038424: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038428: 02 80 00 5d be 203859c <rtems_rfs_dir_read+0x364> <== NOT EXECUTED
203842c: d6 07 bf 9c ld [ %fp + -100 ], %o3 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
2038430: d2 04 60 08 ld [ %l1 + 8 ], %o1 <== NOT EXECUTED
2038434: d8 07 bf b4 ld [ %fp + -76 ], %o4 <== NOT EXECUTED
2038438: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
203843c: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
2038440: 40 00 38 51 call 2046584 <printf> <== NOT EXECUTED
2038444: 90 12 20 d8 or %o0, 0xd8, %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);
2038448: 10 80 00 56 b 20385a0 <rtems_rfs_dir_read+0x368> <== NOT EXECUTED
203844c: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
2038450: 92 10 20 00 clr %o1
2038454: 40 00 33 e0 call 20453d4 <memset>
2038458: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
203845c: 82 10 21 18 mov 0x118, %g1
2038460: c2 37 20 10 sth %g1, [ %i4 + 0x10 ]
*length += elength;
2038464: c2 07 40 00 ld [ %i5 ], %g1
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
2038468: e0 27 20 08 st %l0, [ %i4 + 8 ]
203846c: f2 27 20 0c st %i1, [ %i4 + 0xc ]
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
2038470: 82 05 80 01 add %l6, %g1, %g1
2038474: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
2038478: c4 06 20 08 ld [ %i0 + 8 ], %g2
203847c: ae 20 80 17 sub %g2, %l7, %l7
2038480: ae 25 c0 16 sub %l7, %l6, %l7
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
2038484: 80 a5 e0 0a cmp %l7, 0xa
2038488: 14 80 00 04 bg 2038498 <rtems_rfs_dir_read+0x260> <== ALWAYS TAKEN
203848c: ac 05 bf f6 add %l6, -10, %l6
*length += remaining;
2038490: 82 05 c0 01 add %l7, %g1, %g1 <== NOT EXECUTED
2038494: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
2038498: 80 a5 a0 ff cmp %l6, 0xff
203849c: 34 80 00 02 bg,a 20384a4 <rtems_rfs_dir_read+0x26c> <== NEVER TAKEN
20384a0: ac 10 20 ff mov 0xff, %l6 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
20384a4: 92 05 60 0a add %l5, 0xa, %o1
20384a8: 94 10 00 16 mov %l6, %o2
20384ac: ba 07 20 14 add %i4, 0x14, %i5
20384b0: 40 00 33 3d call 20451a4 <memcpy>
20384b4: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
20384b8: c4 0d 40 00 ldub [ %l5 ], %g2
20384bc: c2 0d 60 01 ldub [ %l5 + 1 ], %g1
20384c0: 85 28 a0 18 sll %g2, 0x18, %g2
20384c4: 83 28 60 10 sll %g1, 0x10, %g1
20384c8: 82 10 80 01 or %g2, %g1, %g1
20384cc: c4 0d 60 03 ldub [ %l5 + 3 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
20384d0: 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);
20384d4: 82 10 40 02 or %g1, %g2, %g1
20384d8: c4 0d 60 02 ldub [ %l5 + 2 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
20384dc: 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);
20384e0: 85 28 a0 08 sll %g2, 8, %g2
20384e4: 82 10 40 02 or %g1, %g2, %g1
dirent->d_namlen = elength;
20384e8: ec 37 20 12 sth %l6, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
20384ec: 7f ff ac 6f call 20236a8 <rtems_rfs_trace>
20384f0: c2 27 00 00 st %g1, [ %i4 ]
20384f4: 80 8a 20 ff btst 0xff, %o0
20384f8: 22 80 00 2a be,a 20385a0 <rtems_rfs_dir_read+0x368> <== ALWAYS TAKEN
20384fc: 92 07 bf f0 add %fp, -16, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
2038500: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
2038504: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
2038508: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
203850c: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2038510: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2038514: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
2038518: 40 00 38 1b call 2046584 <printf> <== NOT EXECUTED
203851c: 90 12 21 20 or %o0, 0x120, %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);
2038520: 10 80 00 20 b 20385a0 <rtems_rfs_dir_read+0x368> <== NOT EXECUTED
2038524: 92 07 bf f0 add %fp, -16, %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;
2038528: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
203852c: 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;
2038530: ae 20 40 17 sub %g1, %l7, %l7
2038534: c2 07 40 00 ld [ %i5 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038538: 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;
203853c: ae 00 40 17 add %g1, %l7, %l7
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038540: 7f ff ac 5a call 20236a8 <rtems_rfs_trace>
2038544: ee 27 40 00 st %l7, [ %i5 ]
2038548: 80 8a 20 ff btst 0xff, %o0
203854c: 02 80 00 08 be 203856c <rtems_rfs_dir_read+0x334> <== ALWAYS TAKEN
2038550: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
2038554: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
2038558: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
203855c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2038560: 40 00 38 09 call 2046584 <printf> <== NOT EXECUTED
2038564: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038568: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203856c: 92 10 00 1b mov %i3, %o1
2038570: 7f ff f7 b2 call 2036438 <rtems_rfs_block_map_next_block>
2038574: 94 10 00 12 mov %l2, %o2
if (rc == ENXIO)
2038578: 80 a2 20 06 cmp %o0, 6
203857c: 02 80 00 07 be 2038598 <rtems_rfs_dir_read+0x360> <== ALWAYS TAKEN
2038580: b4 10 00 08 mov %o0, %i2
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
2038584: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2038588: 02 bf ff 79 be 203836c <rtems_rfs_dir_read+0x134> <== NOT EXECUTED
203858c: d4 07 bf fc ld [ %fp + -4 ], %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);
2038590: 10 80 00 04 b 20385a0 <rtems_rfs_dir_read+0x368> <== NOT EXECUTED
2038594: 92 07 bf f0 add %fp, -16, %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;
2038598: b4 10 20 02 mov 2, %i2
}
rtems_rfs_buffer_handle_close (fs, &buffer);
203859c: 92 07 bf f0 add %fp, -16, %o1
20385a0: 7f ff fc 00 call 20375a0 <rtems_rfs_buffer_handle_close>
20385a4: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
20385a8: 90 10 00 18 mov %i0, %o0
20385ac: 92 07 bf a0 add %fp, -96, %o1
20385b0: 7f ff f6 b4 call 2036080 <rtems_rfs_block_map_close>
20385b4: 01 00 00 00 nop
return rc;
}
20385b8: 81 c7 e0 08 ret
20385bc: 91 e8 00 1a restore %g0, %i2, %o0
020387ec <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
20387ec: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
20387f0: 90 10 20 10 mov 0x10, %o0
20387f4: 92 10 20 00 clr %o1
20387f8: 7f ff ab ac call 20236a8 <rtems_rfs_trace>
20387fc: ba 10 00 18 mov %i0, %i5
2038800: 80 8a 20 ff btst 0xff, %o0
2038804: 22 80 00 08 be,a 2038824 <rtems_rfs_file_close+0x38> <== ALWAYS TAKEN
2038808: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
203880c: 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",
2038810: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038814: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
2038818: 40 00 37 5b call 2046584 <printf> <== NOT EXECUTED
203881c: 90 12 21 f8 or %o0, 0x1f8, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
2038820: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
2038824: c2 02 60 08 ld [ %o1 + 8 ], %g1
2038828: 80 a0 60 00 cmp %g1, 0
203882c: 04 80 00 03 ble 2038838 <rtems_rfs_file_close+0x4c> <== NEVER TAKEN
2038830: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
2038834: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
2038838: c2 02 60 08 ld [ %o1 + 8 ], %g1
203883c: 80 a0 60 00 cmp %g1, 0
2038840: 12 80 00 7e bne 2038a38 <rtems_rfs_file_close+0x24c> <== NEVER TAKEN
2038844: b0 10 20 00 clr %i0
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
2038848: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
203884c: 80 a0 60 00 cmp %g1, 0
2038850: 32 80 00 09 bne,a 2038874 <rtems_rfs_file_close+0x88> <== NEVER TAKEN
2038854: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
2038858: 90 10 00 1d mov %i5, %o0
203885c: 40 00 0a ce call 203b394 <rtems_rfs_inode_load>
2038860: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
2038864: b0 92 20 00 orcc %o0, 0, %i0
2038868: 32 80 00 3f bne,a 2038964 <rtems_rfs_file_close+0x178> <== NEVER TAKEN
203886c: 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,
2038870: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2038874: 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);
2038878: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
203887c: 89 30 a0 18 srl %g2, 0x18, %g4
2038880: c8 28 e0 10 stb %g4, [ %g3 + 0x10 ]
2038884: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2038888: 89 30 a0 10 srl %g2, 0x10, %g4
203888c: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
2038890: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2038894: 89 30 a0 08 srl %g2, 8, %g4
2038898: c8 28 e0 12 stb %g4, [ %g3 + 0x12 ]
203889c: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
20388a0: c4 28 e0 13 stb %g2, [ %g3 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20388a4: 86 10 20 01 mov 1, %g3
20388a8: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
20388ac: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
20388b0: 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);
20388b4: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
20388b8: b9 30 a0 18 srl %g2, 0x18, %i4
20388bc: f8 29 20 14 stb %i4, [ %g4 + 0x14 ]
20388c0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
20388c4: b9 30 a0 10 srl %g2, 0x10, %i4
20388c8: f8 29 20 15 stb %i4, [ %g4 + 0x15 ]
20388cc: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
20388d0: b9 30 a0 08 srl %g2, 8, %i4
20388d4: f8 29 20 16 stb %i4, [ %g4 + 0x16 ]
20388d8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
20388dc: c4 29 20 17 stb %g2, [ %g4 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20388e0: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
20388e4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
20388e8: 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);
20388ec: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
20388f0: b9 30 a0 18 srl %g2, 0x18, %i4
20388f4: f8 29 20 18 stb %i4, [ %g4 + 0x18 ]
20388f8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
20388fc: b9 30 a0 10 srl %g2, 0x10, %i4
2038900: f8 29 20 19 stb %i4, [ %g4 + 0x19 ]
2038904: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038908: b9 30 a0 08 srl %g2, 8, %i4
203890c: f8 29 20 1a stb %i4, [ %g4 + 0x1a ]
2038910: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038914: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2038918: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
203891c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2038920: c4 00 60 84 ld [ %g1 + 0x84 ], %g2
2038924: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
2038928: 80 a0 80 03 cmp %g2, %g3
203892c: 32 80 00 08 bne,a 203894c <rtems_rfs_file_close+0x160> <== NEVER TAKEN
2038930: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
2038934: c8 00 60 88 ld [ %g1 + 0x88 ], %g4
2038938: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
203893c: 80 a1 00 03 cmp %g4, %g3
2038940: 02 80 00 08 be 2038960 <rtems_rfs_file_close+0x174> <== ALWAYS TAKEN
2038944: b0 10 20 00 clr %i0
*/
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);
2038948: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
203894c: c4 00 60 88 ld [ %g1 + 0x88 ], %g2 <== NOT EXECUTED
map->dirty = true;
2038950: b0 10 20 00 clr %i0 <== 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);
2038954: c4 20 60 40 st %g2, [ %g1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
2038958: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
203895c: 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);
2038960: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
2038964: 90 10 00 1d mov %i5, %o0
2038968: 7f ff f5 c6 call 2036080 <rtems_rfs_block_map_close>
203896c: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
2038970: b8 92 20 00 orcc %o0, 0, %i4
2038974: 04 80 00 14 ble 20389c4 <rtems_rfs_file_close+0x1d8> <== ALWAYS TAKEN
2038978: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
203897c: 7f ff ab 4b call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2038980: 92 10 20 00 clr %o1 <== NOT EXECUTED
2038984: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038988: 02 80 00 0d be 20389bc <rtems_rfs_file_close+0x1d0> <== NOT EXECUTED
203898c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
2038990: 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",
2038994: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2038998: 40 00 40 b8 call 2048c78 <strerror> <== NOT EXECUTED
203899c: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
20389a0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20389a4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20389a8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
20389ac: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
20389b0: 40 00 36 f5 call 2046584 <printf> <== NOT EXECUTED
20389b4: 90 12 22 20 or %o0, 0x220, %o0 ! 2067a20 <__FUNCTION__.7646+0xd98><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
20389b8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
20389bc: 22 80 00 02 be,a 20389c4 <rtems_rfs_file_close+0x1d8> <== NOT EXECUTED
20389c0: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
20389c4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
20389c8: 90 10 00 1d mov %i5, %o0
20389cc: 40 00 0b 10 call 203b60c <rtems_rfs_inode_close>
20389d0: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
20389d4: b8 92 20 00 orcc %o0, 0, %i4
20389d8: 04 80 00 14 ble 2038a28 <rtems_rfs_file_close+0x23c> <== ALWAYS TAKEN
20389dc: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
20389e0: 7f ff ab 32 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20389e4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20389e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20389ec: 02 80 00 0d be 2038a20 <rtems_rfs_file_close+0x234> <== NOT EXECUTED
20389f0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
20389f4: 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",
20389f8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20389fc: 40 00 40 9f call 2048c78 <strerror> <== NOT EXECUTED
2038a00: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
2038a04: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2038a08: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2038a0c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2038a10: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038a14: 40 00 36 dc call 2046584 <printf> <== NOT EXECUTED
2038a18: 90 12 22 60 or %o0, 0x260, %o0 ! 2067a60 <__FUNCTION__.7646+0xdd8><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
2038a1c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
2038a20: 22 80 00 02 be,a 2038a28 <rtems_rfs_file_close+0x23c> <== NOT EXECUTED
2038a24: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2038a28: 7f ff 55 16 call 200de80 <_Chain_Extract>
2038a2c: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
2038a30: 7f ff 3f 52 call 2008778 <free>
2038a34: 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);
2038a38: 90 10 00 1d mov %i5, %o0
2038a3c: 7f ff f8 ac call 2036cec <rtems_rfs_buffer_handle_release>
2038a40: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
2038a44: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
2038a48: 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)
2038a4c: 80 a6 20 00 cmp %i0, 0
2038a50: 04 80 00 0f ble 2038a8c <rtems_rfs_file_close+0x2a0> <== ALWAYS TAKEN
2038a54: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
2038a58: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
2038a5c: 7f ff ab 13 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2038a60: 92 10 20 00 clr %o1 <== NOT EXECUTED
2038a64: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038a68: 02 80 00 09 be 2038a8c <rtems_rfs_file_close+0x2a0> <== NOT EXECUTED
2038a6c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
2038a70: 40 00 40 82 call 2048c78 <strerror> <== NOT EXECUTED
2038a74: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2038a78: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2038a7c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2038a80: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038a84: 40 00 36 c0 call 2046584 <printf> <== NOT EXECUTED
2038a88: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 2067aa0 <__FUNCTION__.7646+0xe18><== NOT EXECUTED
}
free (handle);
2038a8c: 7f ff 3f 3b call 2008778 <free>
2038a90: 90 10 00 19 mov %i1, %o0
return rrc;
}
2038a94: 81 c7 e0 08 ret
2038a98: 81 e8 00 00 restore
02038cb0 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
2038cb0: 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))
2038cb4: 90 10 20 20 mov 0x20, %o0
2038cb8: 92 10 20 00 clr %o1
2038cbc: 7f ff aa 7b call 20236a8 <rtems_rfs_trace>
2038cc0: ba 10 00 18 mov %i0, %i5
2038cc4: 80 8a 20 ff btst 0xff, %o0
2038cc8: 22 80 00 0d be,a 2038cfc <rtems_rfs_file_io_end+0x4c> <== ALWAYS TAKEN
2038ccc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
2038cd0: 13 00 81 7e sethi %hi(0x205f800), %o1 <== NOT EXECUTED
2038cd4: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2038cd8: 02 80 00 04 be 2038ce8 <rtems_rfs_file_io_end+0x38> <== NOT EXECUTED
2038cdc: 92 12 60 70 or %o1, 0x70, %o1 <== NOT EXECUTED
2038ce0: 13 00 81 8d sethi %hi(0x2063400), %o1 <== NOT EXECUTED
2038ce4: 92 12 62 c8 or %o1, 0x2c8, %o1 ! 20636c8 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
2038ce8: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038cec: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2038cf0: 40 00 36 25 call 2046584 <printf> <== NOT EXECUTED
2038cf4: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
2038cf8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2038cfc: 80 a0 60 00 cmp %g1, 0
2038d00: 02 80 00 1d be 2038d74 <rtems_rfs_file_io_end+0xc4> <== NEVER TAKEN
2038d04: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
2038d08: 32 80 00 05 bne,a 2038d1c <rtems_rfs_file_io_end+0x6c>
2038d0c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
2038d10: 82 10 20 01 mov 1, %g1
2038d14: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
2038d18: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2038d1c: 92 07 60 04 add %i5, 4, %o1
2038d20: 7f ff f7 f3 call 2036cec <rtems_rfs_buffer_handle_release>
2038d24: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rtems_rfs_file_buffer (handle));
if (rc > 0)
2038d28: b0 92 20 00 orcc %o0, 0, %i0
2038d2c: 04 80 00 13 ble 2038d78 <rtems_rfs_file_io_end+0xc8> <== ALWAYS TAKEN
2038d30: 80 a6 a0 00 cmp %i2, 0
{
printf (
2038d34: 3b 00 81 7e sethi %hi(0x205f800), %i5 <== NOT EXECUTED
2038d38: 02 80 00 04 be 2038d48 <rtems_rfs_file_io_end+0x98> <== NOT EXECUTED
2038d3c: ba 17 60 70 or %i5, 0x70, %i5 ! 205f870 <_CPU_Trap_slot_template+0x60><== NOT EXECUTED
2038d40: 3b 00 81 8d sethi %hi(0x2063400), %i5 <== NOT EXECUTED
2038d44: ba 17 62 c8 or %i5, 0x2c8, %i5 ! 20636c8 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
2038d48: 40 00 3f cc call 2048c78 <strerror> <== NOT EXECUTED
2038d4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2038d50: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2038d54: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
2038d58: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2038d5c: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038d60: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
2038d64: 40 00 36 08 call 2046584 <printf> <== NOT EXECUTED
2038d68: 90 12 23 a8 or %o0, 0x3a8, %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;
2038d6c: 81 c7 e0 08 ret <== NOT EXECUTED
2038d70: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
2038d74: 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;
2038d78: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2038d7c: b2 06 40 01 add %i1, %g1, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
2038d80: 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;
2038d84: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
2038d88: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
2038d8c: 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 >=
2038d90: 80 a6 40 02 cmp %i1, %g2
2038d94: 0a 80 00 07 bcs 2038db0 <rtems_rfs_file_io_end+0x100>
2038d98: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
2038d9c: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
2038da0: 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++;
2038da4: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
2038da8: 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++;
2038dac: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
2038db0: 12 80 00 19 bne 2038e14 <rtems_rfs_file_io_end+0x164>
2038db4: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
2038db8: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
}
length = false;
mtime = false;
if (!read &&
2038dbc: 80 a0 e0 00 cmp %g3, 0
2038dc0: 02 80 00 05 be 2038dd4 <rtems_rfs_file_io_end+0x124>
2038dc4: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
2038dc8: 80 a0 a0 00 cmp %g2, 0
2038dcc: 22 80 00 0f be,a 2038e08 <rtems_rfs_file_io_end+0x158> <== NEVER TAKEN
2038dd0: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
2038dd4: 80 a0 c0 02 cmp %g3, %g2
2038dd8: 3a 80 00 0c bcc,a 2038e08 <rtems_rfs_file_io_end+0x158>
2038ddc: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
2038de0: 88 00 bf ff add %g2, -1, %g4
2038de4: 80 a0 c0 04 cmp %g3, %g4
2038de8: 12 80 00 0b bne 2038e14 <rtems_rfs_file_io_end+0x164> <== NEVER TAKEN
2038dec: 84 10 20 00 clr %g2
2038df0: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
2038df4: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
2038df8: 80 a1 00 03 cmp %g4, %g3
2038dfc: 28 80 00 07 bleu,a 2038e18 <rtems_rfs_file_io_end+0x168>
2038e00: 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;
2038e04: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
2038e08: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
map->dirty = true;
2038e0c: 84 10 20 01 mov 1, %g2
2038e10: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
2038e14: c2 07 40 00 ld [ %i5 ], %g1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
2038e18: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
2038e1c: b6 08 60 01 and %g1, 1, %i3
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
2038e20: 80 88 60 02 btst 2, %g1
2038e24: 12 80 00 03 bne 2038e30 <rtems_rfs_file_io_end+0x180> <== NEVER TAKEN
2038e28: b6 1e e0 01 xor %i3, 1, %i3
2038e2c: b8 08 a0 ff and %g2, 0xff, %i4
length = rtems_rfs_file_update_length (handle) && length;
2038e30: 80 88 60 04 btst 4, %g1
2038e34: 12 80 00 03 bne 2038e40 <rtems_rfs_file_io_end+0x190> <== NEVER TAKEN
2038e38: b2 10 20 00 clr %i1
2038e3c: b2 08 a0 ff and %g2, 0xff, %i1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038e40: 90 10 20 20 mov 0x20, %o0
2038e44: 7f ff aa 19 call 20236a8 <rtems_rfs_trace>
2038e48: 92 10 20 00 clr %o1
2038e4c: 80 8a 20 ff btst 0xff, %o0
2038e50: 02 80 00 17 be 2038eac <rtems_rfs_file_io_end+0x1fc> <== ALWAYS TAKEN
2038e54: 80 8e e0 ff btst 0xff, %i3
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
2038e58: 82 0e e0 ff and %i3, 0xff, %g1 <== NOT EXECUTED
2038e5c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2038e60: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
2038e64: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
2038e68: 82 0f 20 ff and %i4, 0xff, %g1 <== NOT EXECUTED
2038e6c: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
2038e70: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2038e74: 82 0e 60 ff and %i1, 0xff, %g1 <== NOT EXECUTED
2038e78: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
2038e7c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2038e80: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
2038e84: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
2038e88: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
2038e8c: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038e90: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
2038e94: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED
2038e98: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
2038e9c: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
2038ea0: 40 00 35 b9 call 2046584 <printf> <== NOT EXECUTED
2038ea4: 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)
2038ea8: 80 8e e0 ff btst 0xff, %i3 <== NOT EXECUTED
2038eac: 12 80 00 04 bne 2038ebc <rtems_rfs_file_io_end+0x20c> <== ALWAYS TAKEN
2038eb0: 80 8f 20 ff btst 0xff, %i4
2038eb4: 02 80 00 11 be 2038ef8 <rtems_rfs_file_io_end+0x248> <== NOT EXECUTED
2038eb8: 80 8e 60 ff btst 0xff, %i1 <== NOT EXECUTED
{
time_t now = time (NULL);
2038ebc: 40 00 56 8b call 204e8e8 <time>
2038ec0: 90 10 20 00 clr %o0
if (read && atime)
2038ec4: 80 a6 a0 00 cmp %i2, 0
2038ec8: 02 80 00 08 be 2038ee8 <rtems_rfs_file_io_end+0x238>
2038ecc: 80 8f 20 ff btst 0xff, %i4
2038ed0: 80 8e e0 ff btst 0xff, %i3
2038ed4: 02 80 00 09 be 2038ef8 <rtems_rfs_file_io_end+0x248> <== NEVER TAKEN
2038ed8: 80 8e 60 ff btst 0xff, %i1
handle->shared->atime = now;
2038edc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2038ee0: 10 80 00 06 b 2038ef8 <rtems_rfs_file_io_end+0x248>
2038ee4: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (!read && mtime)
2038ee8: 02 80 00 04 be 2038ef8 <rtems_rfs_file_io_end+0x248>
2038eec: 80 8e 60 ff btst 0xff, %i1
handle->shared->mtime = now;
2038ef0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2038ef4: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
}
if (length)
2038ef8: 02 80 00 07 be 2038f14 <rtems_rfs_file_io_end+0x264>
2038efc: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
2038f00: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
2038f04: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
2038f08: c4 20 60 84 st %g2, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
2038f0c: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
2038f10: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
2038f14: 81 c7 e0 08 ret
2038f18: 81 e8 00 00 restore
02038f1c <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))
2038f1c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2038f20: 80 a0 60 00 cmp %g1, 0
2038f24: 02 80 00 08 be 2038f44 <rtems_rfs_file_io_release+0x28> <== ALWAYS TAKEN
2038f28: 92 10 00 08 mov %o0, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
2038f2c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
2038f30: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
2038f34: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
2038f38: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2038f3c: 7f ff f7 6c call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2038f40: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
2038f44: 81 c3 e0 08 retl
2038f48: 90 10 20 00 clr %o0
02038a9c <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
2038a9c: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038aa0: 90 10 20 20 mov 0x20, %o0
2038aa4: 92 10 20 00 clr %o1
2038aa8: 7f ff ab 00 call 20236a8 <rtems_rfs_trace>
2038aac: ba 10 00 18 mov %i0, %i5
2038ab0: 80 8a 20 ff btst 0xff, %o0
2038ab4: 22 80 00 0e be,a 2038aec <rtems_rfs_file_io_start+0x50> <== ALWAYS TAKEN
2038ab8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
2038abc: 13 00 81 7e sethi %hi(0x205f800), %o1 <== NOT EXECUTED
2038ac0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2038ac4: 02 80 00 04 be 2038ad4 <rtems_rfs_file_io_start+0x38> <== NOT EXECUTED
2038ac8: 92 12 60 70 or %o1, 0x70, %o1 <== NOT EXECUTED
2038acc: 13 00 81 8d sethi %hi(0x2063400), %o1 <== NOT EXECUTED
2038ad0: 92 12 62 c8 or %o1, 0x2c8, %o1 ! 20636c8 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
2038ad4: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
2038ad8: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
2038adc: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038ae0: 40 00 36 a9 call 2046584 <printf> <== NOT EXECUTED
2038ae4: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 2067ac8 <__FUNCTION__.7646+0xe40><== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
2038ae8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2038aec: 80 a0 60 00 cmp %g1, 0
2038af0: 12 80 00 4c bne 2038c20 <rtems_rfs_file_io_start+0x184> <== NEVER TAKEN
2038af4: 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),
2038af8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
2038afc: 94 07 60 10 add %i5, 0x10, %o2
2038b00: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
2038b04: 96 07 bf fc add %fp, -4, %o3
2038b08: 7f ff f5 d3 call 2036254 <rtems_rfs_block_map_find>
2038b0c: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
2038b10: b0 92 20 00 orcc %o0, 0, %i0
2038b14: 04 80 00 1e ble 2038b8c <rtems_rfs_file_io_start+0xf0>
2038b18: 80 a6 a0 00 cmp %i2, 0
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
2038b1c: 02 80 00 07 be 2038b38 <rtems_rfs_file_io_start+0x9c> <== ALWAYS TAKEN
2038b20: 80 a6 20 06 cmp %i0, 6
2038b24: 12 80 00 61 bne 2038ca8 <rtems_rfs_file_io_start+0x20c> <== NOT EXECUTED
2038b28: 01 00 00 00 nop <== NOT EXECUTED
{
*available = 0;
2038b2c: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
2038b30: 81 c7 e0 08 ret <== NOT EXECUTED
2038b34: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if (rc != ENXIO)
2038b38: 12 80 00 5c bne 2038ca8 <rtems_rfs_file_io_start+0x20c> <== NEVER TAKEN
2038b3c: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038b40: 7f ff aa da call 20236a8 <rtems_rfs_trace>
2038b44: 92 10 20 00 clr %o1
2038b48: 80 8a 20 ff btst 0xff, %o0
2038b4c: 22 80 00 06 be,a 2038b64 <rtems_rfs_file_io_start+0xc8> <== ALWAYS TAKEN
2038b50: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
printf ("rtems-rfs: file-io: start: grow\n");
2038b54: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038b58: 40 00 37 26 call 20467f0 <puts> <== NOT EXECUTED
2038b5c: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 2067af8 <__FUNCTION__.7646+0xe70><== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
2038b60: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
2038b64: 94 10 20 01 mov 1, %o2
2038b68: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
2038b6c: 96 07 bf fc add %fp, -4, %o3
2038b70: 7f ff f6 3f call 203646c <rtems_rfs_block_map_grow>
2038b74: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
2038b78: b0 92 20 00 orcc %o0, 0, %i0
2038b7c: 14 80 00 4b bg 2038ca8 <rtems_rfs_file_io_start+0x20c>
2038b80: 01 00 00 00 nop
return rc;
request_read = false;
2038b84: 10 80 00 0e b 2038bbc <rtems_rfs_file_io_start+0x120>
2038b88: b0 10 20 00 clr %i0 ! 0 <PROM_START>
/*
* 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 &&
2038b8c: 12 80 00 0c bne 2038bbc <rtems_rfs_file_io_start+0x120>
2038b90: b0 10 00 1a mov %i2, %i0
2038b94: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2038b98: 80 a0 60 00 cmp %g1, 0
2038b9c: 12 80 00 08 bne 2038bbc <rtems_rfs_file_io_start+0x120>
2038ba0: b0 10 20 01 mov 1, %i0
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
2038ba4: 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) ||
2038ba8: c4 06 40 00 ld [ %i1 ], %g2
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
2038bac: 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) ||
2038bb0: c2 00 60 08 ld [ %g1 + 8 ], %g1
2038bb4: 80 a0 80 01 cmp %g2, %g1
2038bb8: b0 40 20 00 addx %g0, 0, %i0
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038bbc: 90 10 20 20 mov 0x20, %o0
2038bc0: 7f ff aa ba call 20236a8 <rtems_rfs_trace>
2038bc4: 92 10 20 00 clr %o1
2038bc8: 80 8a 20 ff btst 0xff, %o0
2038bcc: 22 80 00 0d be,a 2038c00 <rtems_rfs_file_io_start+0x164> <== ALWAYS TAKEN
2038bd0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
2038bd4: 15 00 81 9d sethi %hi(0x2067400), %o2 <== NOT EXECUTED
2038bd8: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
2038bdc: 80 8e 20 ff btst 0xff, %i0 <== NOT EXECUTED
2038be0: 02 80 00 04 be 2038bf0 <rtems_rfs_file_io_start+0x154> <== NOT EXECUTED
2038be4: 94 12 a3 20 or %o2, 0x320, %o2 <== NOT EXECUTED
2038be8: 15 00 81 9d sethi %hi(0x2067400), %o2 <== NOT EXECUTED
2038bec: 94 12 a3 18 or %o2, 0x318, %o2 ! 2067718 <__FUNCTION__.7646+0xa90><== NOT EXECUTED
2038bf0: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038bf4: 40 00 36 64 call 2046584 <printf> <== NOT EXECUTED
2038bf8: 90 12 23 18 or %o0, 0x318, %o0 ! 2067b18 <__FUNCTION__.7646+0xe90><== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
2038bfc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2038c00: d4 07 bf fc ld [ %fp + -4 ], %o2
2038c04: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
2038c08: 96 0e 20 ff and %i0, 0xff, %o3
2038c0c: 7f ff f8 aa call 2036eb4 <rtems_rfs_buffer_handle_request>
2038c10: 92 07 60 04 add %i5, 4, %o1
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
2038c14: b0 92 20 00 orcc %o0, 0, %i0
2038c18: 14 80 00 24 bg 2038ca8 <rtems_rfs_file_io_start+0x20c> <== NEVER TAKEN
2038c1c: 80 a6 a0 00 cmp %i2, 0
return rc;
}
if (read
2038c20: 02 80 00 12 be 2038c68 <rtems_rfs_file_io_start+0x1cc>
2038c24: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
2038c28: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
2038c2c: 80 a0 a0 00 cmp %g2, 0
2038c30: 12 80 00 05 bne 2038c44 <rtems_rfs_file_io_start+0x1a8> <== NEVER TAKEN
2038c34: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
2038c38: 80 a0 e0 00 cmp %g3, 0
2038c3c: 22 80 00 07 be,a 2038c58 <rtems_rfs_file_io_start+0x1bc> <== NEVER TAKEN
2038c40: f4 00 60 40 ld [ %g1 + 0x40 ], %i2 <== NOT EXECUTED
2038c44: 86 00 ff ff add %g3, -1, %g3
2038c48: 80 a0 80 03 cmp %g2, %g3
2038c4c: 32 80 00 07 bne,a 2038c68 <rtems_rfs_file_io_start+0x1cc><== NEVER TAKEN
2038c50: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
2038c54: f4 00 60 40 ld [ %g1 + 0x40 ], %i2
2038c58: 80 a6 a0 00 cmp %i2, 0
2038c5c: 32 80 00 06 bne,a 2038c74 <rtems_rfs_file_io_start+0x1d8><== ALWAYS TAKEN
2038c60: 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));
2038c64: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2038c68: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
2038c6c: f4 00 60 08 ld [ %g1 + 8 ], %i2
*available = size - rtems_rfs_file_block_offset (handle);
2038c70: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038c74: 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);
2038c78: 82 26 80 01 sub %i2, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038c7c: 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);
2038c80: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038c84: 7f ff aa 89 call 20236a8 <rtems_rfs_trace>
2038c88: b0 10 20 00 clr %i0
2038c8c: 80 8a 20 ff btst 0xff, %o0
2038c90: 02 80 00 06 be 2038ca8 <rtems_rfs_file_io_start+0x20c> <== ALWAYS TAKEN
2038c94: 11 00 81 9e sethi %hi(0x2067800), %o0
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
2038c98: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2038c9c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2038ca0: 40 00 36 39 call 2046584 <printf> <== NOT EXECUTED
2038ca4: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
*available, size);
return 0;
}
2038ca8: 81 c7 e0 08 ret
2038cac: 81 e8 00 00 restore
02039378 <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)
{
2039378: 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))
203937c: 90 10 20 08 mov 8, %o0
2039380: 92 10 20 00 clr %o1
2039384: 7f ff a8 c9 call 20236a8 <rtems_rfs_trace>
2039388: ba 10 00 18 mov %i0, %i5
203938c: 80 8a 20 ff btst 0xff, %o0
2039390: 22 80 00 07 be,a 20393ac <rtems_rfs_file_open+0x34> <== ALWAYS TAKEN
2039394: c0 26 c0 00 clr [ %i3 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
2039398: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
203939c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20393a0: 40 00 34 79 call 2046584 <printf> <== NOT EXECUTED
20393a4: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
*file = NULL;
20393a8: 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));
20393ac: 90 10 20 20 mov 0x20, %o0
20393b0: 7f ff 3e 72 call 2008d78 <malloc>
20393b4: b0 10 20 0c mov 0xc, %i0
if (!handle)
20393b8: 80 a2 20 00 cmp %o0, 0
20393bc: 02 80 00 58 be 203951c <rtems_rfs_file_open+0x1a4> <== NEVER TAKEN
20393c0: b8 10 00 08 mov %o0, %i4
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
20393c4: 92 10 20 00 clr %o1
20393c8: 40 00 30 03 call 20453d4 <memset>
20393cc: 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);
20393d0: 90 10 00 1d mov %i5, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20393d4: c0 2f 20 04 clrb [ %i4 + 4 ]
handle->bnum = 0;
20393d8: c0 27 20 08 clr [ %i4 + 8 ]
handle->buffer = NULL;
20393dc: c0 27 20 0c clr [ %i4 + 0xc ]
20393e0: 7f ff ff d8 call 2039340 <rtems_rfs_file_get_shared>
20393e4: 92 10 00 19 mov %i1, %o1
if (shared)
20393e8: a0 92 20 00 orcc %o0, 0, %l0
20393ec: 02 80 00 0d be 2039420 <rtems_rfs_file_open+0xa8> <== ALWAYS TAKEN
20393f0: 90 10 20 08 mov 8, %o0
{
shared->references++;
20393f4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
20393f8: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
20393fc: 92 10 20 00 clr %o1 <== NOT EXECUTED
2039400: 7f ff a8 aa call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039404: c2 24 20 08 st %g1, [ %l0 + 8 ] <== NOT EXECUTED
2039408: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203940c: 22 80 00 8c be,a 203963c <rtems_rfs_file_open+0x2c4> <== NOT EXECUTED
2039410: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
2039414: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039418: 10 80 00 86 b 2039630 <rtems_rfs_file_open+0x2b8> <== NOT EXECUTED
203941c: 90 12 20 90 or %o0, 0x90, %o0 ! 2067c90 <__FUNCTION__.7646+0x1008><== 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));
2039420: 7f ff 3e 56 call 2008d78 <malloc>
2039424: 90 10 20 9c mov 0x9c, %o0
if (!shared)
2039428: a0 92 20 00 orcc %o0, 0, %l0
203942c: 22 80 00 35 be,a 2039500 <rtems_rfs_file_open+0x188> <== NEVER TAKEN
2039430: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
2039434: 92 10 20 00 clr %o1
2039438: 40 00 2f e7 call 20453d4 <memset>
203943c: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
2039440: a2 04 20 0c add %l0, 0xc, %l1
2039444: 90 10 00 1d mov %i5, %o0
2039448: 92 10 00 19 mov %i1, %o1
203944c: 94 10 00 11 mov %l1, %o2
2039450: 40 00 07 fd call 203b444 <rtems_rfs_inode_open>
2039454: 96 10 20 01 mov 1, %o3
if (rc > 0)
2039458: b0 92 20 00 orcc %o0, 0, %i0
203945c: 04 80 00 0f ble 2039498 <rtems_rfs_file_open+0x120> <== ALWAYS TAKEN
2039460: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
2039464: 7f ff a8 91 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039468: 92 10 20 00 clr %o1 <== NOT EXECUTED
203946c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039470: 02 80 00 21 be 20394f4 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
2039474: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
2039478: 40 00 3e 00 call 2048c78 <strerror> <== NOT EXECUTED
203947c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2039480: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2039484: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039488: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
203948c: 40 00 34 3e call 2046584 <printf> <== NOT EXECUTED
2039490: 90 12 20 b8 or %o0, 0xb8, %o0 ! 2067cb8 <__FUNCTION__.7646+0x1030><== NOT EXECUTED
2039494: 30 80 00 18 b,a 20394f4 <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);
2039498: 90 10 00 1d mov %i5, %o0
203949c: 92 10 00 11 mov %l1, %o1
20394a0: 7f ff f2 96 call 2035ef8 <rtems_rfs_block_map_open>
20394a4: 94 04 20 34 add %l0, 0x34, %o2
if (rc > 0)
20394a8: b0 92 20 00 orcc %o0, 0, %i0
20394ac: 04 80 00 1e ble 2039524 <rtems_rfs_file_open+0x1ac> <== ALWAYS TAKEN
20394b0: 82 10 20 01 mov 1, %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
20394b4: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
20394b8: 7f ff a8 7c call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20394bc: 92 10 20 00 clr %o1 <== NOT EXECUTED
20394c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20394c4: 22 80 00 0a be,a 20394ec <rtems_rfs_file_open+0x174> <== NOT EXECUTED
20394c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
20394cc: 40 00 3d eb call 2048c78 <strerror> <== NOT EXECUTED
20394d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20394d4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20394d8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20394dc: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
20394e0: 40 00 34 29 call 2046584 <printf> <== NOT EXECUTED
20394e4: 90 12 20 f0 or %o0, 0xf0, %o0 ! 2067cf0 <__FUNCTION__.7646+0x1068><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
20394e8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20394ec: 40 00 08 48 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
20394f0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
free (shared);
20394f4: 7f ff 3c a1 call 2008778 <free> <== NOT EXECUTED
20394f8: 90 10 00 10 mov %l0, %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);
20394fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2039500: 7f ff f5 fb call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039504: 92 07 20 04 add %i4, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
2039508: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
handle->dirty = false;
203950c: c0 2f 20 04 clrb [ %i4 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
2039510: c0 27 20 08 clr [ %i4 + 8 ] <== NOT EXECUTED
2039514: 7f ff 3c 99 call 2008778 <free> <== NOT EXECUTED
2039518: c0 27 20 0c clr [ %i4 + 0xc ] <== NOT EXECUTED
return rc;
203951c: 81 c7 e0 08 ret <== NOT EXECUTED
2039520: 81 e8 00 00 restore <== NOT EXECUTED
}
shared->references = 1;
2039524: c2 24 20 08 st %g1, [ %l0 + 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);
2039528: c2 04 20 18 ld [ %l0 + 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 );
203952c: 90 07 60 74 add %i5, 0x74, %o0
2039530: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2039534: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
2039538: 87 28 e0 18 sll %g3, 0x18, %g3
203953c: 85 28 a0 10 sll %g2, 0x10, %g2
2039540: 84 10 c0 02 or %g3, %g2, %g2
2039544: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
2039548: 92 10 00 10 mov %l0, %o1
203954c: 84 10 80 03 or %g2, %g3, %g2
2039550: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
2039554: 87 28 e0 08 sll %g3, 8, %g3
2039558: 84 10 80 03 or %g2, %g3, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
203955c: c4 24 20 84 st %g2, [ %l0 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
2039560: 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);
2039564: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
2039568: 85 28 a0 08 sll %g2, 8, %g2
203956c: 84 10 c0 02 or %g3, %g2, %g2
2039570: c4 24 20 88 st %g2, [ %l0 + 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);
2039574: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
2039578: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
203957c: 87 28 e0 18 sll %g3, 0x18, %g3
2039580: 85 28 a0 10 sll %g2, 0x10, %g2
2039584: 84 10 c0 02 or %g3, %g2, %g2
2039588: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
203958c: 84 10 80 03 or %g2, %g3, %g2
2039590: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
2039594: 87 28 e0 08 sll %g3, 8, %g3
2039598: 84 10 80 03 or %g2, %g3, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
203959c: c4 24 20 8c st %g2, [ %l0 + 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);
20395a0: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
20395a4: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
20395a8: 87 28 e0 18 sll %g3, 0x18, %g3
20395ac: 85 28 a0 10 sll %g2, 0x10, %g2
20395b0: 84 10 c0 02 or %g3, %g2, %g2
20395b4: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
20395b8: 84 10 80 03 or %g2, %g3, %g2
20395bc: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
20395c0: 87 28 e0 08 sll %g3, 8, %g3
20395c4: 84 10 80 03 or %g2, %g3, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
20395c8: c4 24 20 90 st %g2, [ %l0 + 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);
20395cc: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
20395d0: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
20395d4: 85 28 a0 10 sll %g2, 0x10, %g2
20395d8: 87 28 e0 18 sll %g3, 0x18, %g3
20395dc: 86 10 c0 02 or %g3, %g2, %g3
20395e0: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
20395e4: 86 10 c0 02 or %g3, %g2, %g3
20395e8: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
20395ec: fa 24 20 98 st %i5, [ %l0 + 0x98 ]
20395f0: 85 28 a0 08 sll %g2, 8, %g2
20395f4: 82 10 c0 02 or %g3, %g2, %g1
20395f8: 7f ff 52 17 call 200de54 <_Chain_Append>
20395fc: c2 24 20 94 st %g1, [ %l0 + 0x94 ]
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
2039600: 92 10 00 11 mov %l1, %o1
2039604: 94 10 20 00 clr %o2
2039608: 40 00 07 c5 call 203b51c <rtems_rfs_inode_unload>
203960c: 90 10 00 1d mov %i5, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
2039610: 90 10 20 08 mov 8, %o0
2039614: 7f ff a8 25 call 20236a8 <rtems_rfs_trace>
2039618: 92 10 20 00 clr %o1
203961c: 80 8a 20 ff btst 0xff, %o0
2039620: 22 80 00 07 be,a 203963c <rtems_rfs_file_open+0x2c4> <== ALWAYS TAKEN
2039624: f4 27 00 00 st %i2, [ %i4 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
2039628: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
203962c: 90 12 21 28 or %o0, 0x128, %o0 ! 2067d28 <__FUNCTION__.7646+0x10a0><== NOT EXECUTED
2039630: 40 00 33 d5 call 2046584 <printf> <== NOT EXECUTED
2039634: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
handle->flags = oflag;
2039638: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
handle->shared = shared;
203963c: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
*file = handle;
2039640: f8 26 c0 00 st %i4, [ %i3 ]
return 0;
2039644: b0 10 20 00 clr %i0
}
2039648: 81 c7 e0 08 ret
203964c: 81 e8 00 00 restore
02038f4c <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
2038f4c: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2038f50: 90 10 20 20 mov 0x20, %o0
2038f54: 92 10 20 00 clr %o1
2038f58: 7f ff a9 d4 call 20236a8 <rtems_rfs_trace>
2038f5c: ba 10 00 18 mov %i0, %i5
2038f60: 80 8a 20 ff btst 0xff, %o0
2038f64: 22 80 00 08 be,a 2038f84 <rtems_rfs_file_seek+0x38> <== ALWAYS TAKEN
2038f68: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
2038f6c: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2038f70: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2038f74: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
2038f78: 40 00 35 83 call 2046584 <printf> <== NOT EXECUTED
2038f7c: 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),
2038f80: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
2038f84: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
2038f88: 7f ff f3 c6 call 2035ea0 <rtems_rfs_block_get_size>
2038f8c: 92 02 60 84 add %o1, 0x84, %o1
2038f90: 80 a2 00 19 cmp %o0, %i1
2038f94: 38 80 00 08 bgu,a 2038fb4 <rtems_rfs_file_seek+0x68> <== NEVER TAKEN
2038f98: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2038f9c: 80 a2 00 19 cmp %o0, %i1
2038fa0: 12 80 00 20 bne 2039020 <rtems_rfs_file_seek+0xd4> <== NEVER TAKEN
2038fa4: 80 a2 40 1a cmp %o1, %i2
2038fa8: 08 80 00 1e bleu 2039020 <rtems_rfs_file_seek+0xd4>
2038fac: 01 00 00 00 nop
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
2038fb0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2038fb4: b8 07 60 10 add %i5, 0x10, %i4
2038fb8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
2038fbc: 92 10 00 19 mov %i1, %o1
2038fc0: 94 10 00 1a mov %i2, %o2
2038fc4: 7f ff f3 87 call 2035de0 <rtems_rfs_block_get_bpos>
2038fc8: 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))
2038fcc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2038fd0: 80 a0 60 00 cmp %g1, 0
2038fd4: 02 80 00 18 be 2039034 <rtems_rfs_file_seek+0xe8> <== ALWAYS TAKEN
2038fd8: 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),
2038fdc: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
2038fe0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0 <== NOT EXECUTED
2038fe4: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
2038fe8: 7f ff f4 9b call 2036254 <rtems_rfs_block_map_find> <== NOT EXECUTED
2038fec: 92 02 60 34 add %o1, 0x34, %o1 <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
2038ff0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2038ff4: 14 80 00 13 bg 2039040 <rtems_rfs_file_seek+0xf4> <== NOT EXECUTED
2038ff8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
2038ffc: c4 07 60 08 ld [ %i5 + 8 ], %g2 <== NOT EXECUTED
2039000: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2039004: 02 80 00 0c be 2039034 <rtems_rfs_file_seek+0xe8> <== NOT EXECUTED
2039008: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
203900c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2039010: 7f ff f7 37 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039014: 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)
2039018: 10 80 00 05 b 203902c <rtems_rfs_file_seek+0xe0> <== NOT EXECUTED
203901c: 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);
2039020: 7f ff ff bf call 2038f1c <rtems_rfs_file_io_release>
2039024: 90 10 00 1d mov %i5, %o0
if (rc > 0)
2039028: 80 a2 20 00 cmp %o0, 0
203902c: 14 80 00 05 bg 2039040 <rtems_rfs_file_seek+0xf4> <== NEVER TAKEN
2039030: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
2039034: f2 26 c0 00 st %i1, [ %i3 ]
2039038: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
203903c: 90 10 20 00 clr %o0
}
2039040: 81 c7 e0 08 ret
2039044: 91 e8 00 08 restore %g0, %o0, %o0
02039048 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
2039048: 9d e3 bf 90 save %sp, -112, %sp
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))
203904c: 90 10 20 20 mov 0x20, %o0
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
2039050: ba 10 00 1a mov %i2, %i5
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))
2039054: 92 10 20 00 clr %o1
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
2039058: f4 06 20 1c ld [ %i0 + 0x1c ], %i2
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
203905c: 7f ff a9 93 call 20236a8 <rtems_rfs_trace>
2039060: b6 10 00 18 mov %i0, %i3
2039064: 80 8a 20 ff btst 0xff, %o0
2039068: 02 80 00 07 be 2039084 <rtems_rfs_file_set_size+0x3c> <== ALWAYS TAKEN
203906c: b8 10 00 19 mov %i1, %i4
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
2039070: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039074: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2039078: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
203907c: 40 00 35 42 call 2046584 <printf> <== NOT EXECUTED
2039080: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
size = rtems_rfs_file_size (handle);
2039084: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
2039088: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203908c: 7f ff f3 85 call 2035ea0 <rtems_rfs_block_get_size>
2039090: 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)
2039094: 80 a2 00 1c cmp %o0, %i4
2039098: 12 80 00 05 bne 20390ac <rtems_rfs_file_set_size+0x64> <== NEVER TAKEN
203909c: a0 06 a0 34 add %i2, 0x34, %l0
20390a0: 80 a2 40 1d cmp %o1, %i5
20390a4: 22 80 00 a3 be,a 2039330 <rtems_rfs_file_set_size+0x2e8>
20390a8: b0 10 20 00 clr %i0
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
20390ac: 80 97 00 1d orcc %i4, %i5, %g0
20390b0: 12 80 00 0a bne 20390d8 <rtems_rfs_file_set_size+0x90> <== ALWAYS TAKEN
20390b4: f2 06 e0 1c ld [ %i3 + 0x1c ], %i1
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
20390b8: d0 06 60 98 ld [ %i1 + 0x98 ], %o0 <== NOT EXECUTED
20390bc: 7f ff f6 a8 call 2036b5c <rtems_rfs_block_map_free_all> <== NOT EXECUTED
20390c0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (rc > 0)
20390c4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20390c8: 14 80 00 9c bg 2039338 <rtems_rfs_file_set_size+0x2f0> <== NOT EXECUTED
20390cc: 01 00 00 00 nop <== NOT EXECUTED
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);
20390d0: 10 80 00 8d b 2039304 <rtems_rfs_file_set_size+0x2bc> <== NOT EXECUTED
20390d4: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4 <== NOT EXECUTED
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
20390d8: 80 a7 00 08 cmp %i4, %o0
20390dc: 38 80 00 09 bgu,a 2039100 <rtems_rfs_file_set_size+0xb8> <== NEVER TAKEN
20390e0: c2 06 60 98 ld [ %i1 + 0x98 ], %g1 <== NOT EXECUTED
20390e4: 80 a7 00 08 cmp %i4, %o0
20390e8: 32 80 00 55 bne,a 203923c <rtems_rfs_file_set_size+0x1f4><== NEVER TAKEN
20390ec: e2 06 60 98 ld [ %i1 + 0x98 ], %l1 <== NOT EXECUTED
20390f0: 80 a7 40 09 cmp %i5, %o1
20390f4: 28 80 00 52 bleu,a 203923c <rtems_rfs_file_set_size+0x1f4><== NEVER TAKEN
20390f8: e2 06 60 98 ld [ %i1 + 0x98 ], %l1 <== NOT EXECUTED
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));
20390fc: c2 06 60 98 ld [ %i1 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
2039100: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
2039104: f2 00 60 08 ld [ %g1 + 8 ], %i1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
2039108: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
203910c: a6 10 20 00 clr %l3
2039110: a2 10 20 01 mov 1, %l1
while (count)
2039114: 10 80 00 45 b 2039228 <rtems_rfs_file_set_size+0x1e0>
2039118: 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);
203911c: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
2039120: c4 27 bf f4 st %g2, [ %fp + -12 ]
2039124: c2 27 bf f0 st %g1, [ %fp + -16 ]
2039128: 80 a0 a0 00 cmp %g2, 0
203912c: 02 80 00 04 be 203913c <rtems_rfs_file_set_size+0xf4>
2039130: c0 27 bf f8 clr [ %fp + -8 ]
2039134: 82 00 7f ff add %g1, -1, %g1
2039138: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
203913c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
2039140: 92 10 00 10 mov %l0, %o1
2039144: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
2039148: 94 07 bf f0 add %fp, -16, %o2
203914c: 7f ff f4 42 call 2036254 <rtems_rfs_block_map_find>
2039150: 96 07 bf fc add %fp, -4, %o3
map, &bpos, &block);
if (rc > 0)
2039154: b0 92 20 00 orcc %o0, 0, %i0
2039158: 04 80 00 0c ble 2039188 <rtems_rfs_file_set_size+0x140>
203915c: 80 a6 20 06 cmp %i0, 6
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
2039160: 12 80 00 74 bne 2039330 <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
2039164: 92 10 00 10 mov %l0, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
2039168: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
203916c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
2039170: 94 10 20 01 mov 1, %o2
2039174: 7f ff f4 be call 203646c <rtems_rfs_block_map_grow>
2039178: 96 07 bf fc add %fp, -4, %o3
map, 1, &block);
if (rc > 0)
203917c: b0 92 20 00 orcc %o0, 0, %i0
2039180: 14 80 00 6e bg 2039338 <rtems_rfs_file_set_size+0x2f0> <== NEVER TAKEN
2039184: 01 00 00 00 nop
return rc;
}
if (count < (length - bpos.boff))
2039188: c2 07 bf f4 ld [ %fp + -12 ], %g1
203918c: 80 a7 20 00 cmp %i4, 0
2039190: 12 80 00 0a bne 20391b8 <rtems_rfs_file_set_size+0x170> <== NEVER TAKEN
2039194: 84 26 40 01 sub %i1, %g1, %g2
2039198: 80 a0 80 1d cmp %g2, %i5
203919c: 28 80 00 08 bleu,a 20391bc <rtems_rfs_file_set_size+0x174><== NEVER TAKEN
20391a0: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED
{
length = count + bpos.boff;
20391a4: b2 00 40 1d add %g1, %i5, %i1
20391a8: e2 2e a0 34 stb %l1, [ %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;
20391ac: f2 26 a0 40 st %i1, [ %i2 + 0x40 ]
read_block = true;
20391b0: 10 80 00 04 b 20391c0 <rtems_rfs_file_set_size+0x178>
20391b4: a6 10 20 01 mov 1, %l3
20391b8: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
20391bc: e2 2e a0 34 stb %l1, [ %i2 + 0x34 ] <== NOT EXECUTED
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
20391c0: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
20391c4: d4 07 bf fc ld [ %fp + -4 ], %o2
20391c8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
20391cc: 92 10 00 12 mov %l2, %o1
20391d0: 7f ff f7 39 call 2036eb4 <rtems_rfs_buffer_handle_request>
20391d4: 96 0c e0 01 and %l3, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
20391d8: b0 92 20 00 orcc %o0, 0, %i0
20391dc: 14 80 00 55 bg 2039330 <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
20391e0: d4 07 bf f4 ld [ %fp + -12 ], %o2
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
20391e4: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
memset (dst + bpos.boff, 0, length - bpos.boff);
20391e8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20391ec: 92 10 20 00 clr %o1
20391f0: 90 02 00 0a add %o0, %o2, %o0
20391f4: 40 00 30 78 call 20453d4 <memset>
20391f8: 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),
20391fc: 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));
2039200: e2 2e e0 04 stb %l1, [ %i3 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
2039204: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
2039208: 7f ff f6 b9 call 2036cec <rtems_rfs_buffer_handle_release>
203920c: 92 10 00 12 mov %l2, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
2039210: b0 92 20 00 orcc %o0, 0, %i0
2039214: 14 80 00 47 bg 2039330 <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
2039218: c2 07 bf f4 ld [ %fp + -12 ], %g1
return rc;
count -= length - bpos.boff;
203921c: 82 26 40 01 sub %i1, %g1, %g1
2039220: ba a7 40 01 subcc %i5, %g1, %i5
2039224: 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)
2039228: 80 97 00 1d orcc %i4, %i5, %g0
203922c: 32 bf ff bc bne,a 203911c <rtems_rfs_file_set_size+0xd4>
2039230: 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);
2039234: 10 80 00 34 b 2039304 <rtems_rfs_file_set_size+0x2bc>
2039238: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
203923c: 92 87 7f ff addcc %i5, -1, %o1 <== NOT EXECUTED
2039240: e0 04 60 08 ld [ %l1 + 8 ], %l0 <== NOT EXECUTED
2039244: 90 47 3f ff addx %i4, -1, %o0 <== NOT EXECUTED
2039248: 94 10 20 00 clr %o2 <== NOT EXECUTED
203924c: 40 00 8c 3c call 205c33c <__udivdi3> <== NOT EXECUTED
2039250: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
2039254: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 <== NOT EXECUTED
2039258: 94 38 00 09 xnor %g0, %o1, %o2 <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
203925c: 94 82 80 01 addcc %o2, %g1, %o2 <== NOT EXECUTED
2039260: 02 80 00 08 be 2039280 <rtems_rfs_file_set_size+0x238> <== NOT EXECUTED
2039264: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
2039268: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
203926c: 7f ff f5 6d call 2036820 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
2039270: 92 06 60 34 add %i1, 0x34, %o1 <== NOT EXECUTED
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
2039274: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2039278: 14 80 00 2e bg 2039330 <rtems_rfs_file_set_size+0x2e8> <== NOT EXECUTED
203927c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
2039280: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2039284: 94 10 20 00 clr %o2 <== NOT EXECUTED
2039288: 40 00 8d 02 call 205c690 <__umoddi3> <== NOT EXECUTED
203928c: 96 10 00 10 mov %l0, %o3 <== 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),
2039290: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2 <== NOT EXECUTED
2039294: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
2039298: d2 26 a0 40 st %o1, [ %i2 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
203929c: c2 2e a0 34 stb %g1, [ %i2 + 0x34 ] <== NOT EXECUTED
20392a0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20392a4: 02 80 00 05 be 20392b8 <rtems_rfs_file_set_size+0x270> <== NOT EXECUTED
20392a8: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 <== NOT EXECUTED
20392ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20392b0: 22 80 00 0e be,a 20392e8 <rtems_rfs_file_set_size+0x2a0> <== NOT EXECUTED
20392b4: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
20392b8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20392bc: 3a 80 00 0b bcc,a 20392e8 <rtems_rfs_file_set_size+0x2a0><== NOT EXECUTED
20392c0: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
20392c4: 86 00 7f ff add %g1, -1, %g3 <== NOT EXECUTED
20392c8: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
20392cc: 32 80 00 0e bne,a 2039304 <rtems_rfs_file_set_size+0x2bc><== NOT EXECUTED
20392d0: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4 <== NOT EXECUTED
20392d4: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
20392d8: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED
20392dc: 28 80 00 0a bleu,a 2039304 <rtems_rfs_file_set_size+0x2bc><== NOT EXECUTED
20392e0: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4 <== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
20392e4: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
20392e8: d2 26 e0 14 st %o1, [ %i3 + 0x14 ] <== NOT EXECUTED
20392ec: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
20392f0: 02 80 00 04 be 2039300 <rtems_rfs_file_set_size+0x2b8> <== NOT EXECUTED
20392f4: c0 26 e0 18 clr [ %i3 + 0x18 ] <== NOT EXECUTED
20392f8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20392fc: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
2039300: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4 <== NOT EXECUTED
2039304: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
2039308: c2 27 20 84 st %g1, [ %i4 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
203930c: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
2039310: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
if (rtems_rfs_file_update_mtime (handle))
2039314: c2 06 c0 00 ld [ %i3 ], %g1
2039318: 80 88 60 02 btst 2, %g1
203931c: 12 80 00 05 bne 2039330 <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
2039320: b0 10 20 00 clr %i0
handle->shared->mtime = time (NULL);
2039324: 40 00 55 71 call 204e8e8 <time>
2039328: 90 10 20 00 clr %o0
203932c: d0 27 20 90 st %o0, [ %i4 + 0x90 ]
2039330: 81 c7 e0 08 ret
2039334: 81 e8 00 00 restore
}
return 0;
}
2039338: 81 c7 e0 08 ret <== NOT EXECUTED
203933c: 81 e8 00 00 restore <== NOT EXECUTED
02039ff8 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
2039ff8: 9d e3 be c8 save %sp, -312, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
2039ffc: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
203a000: 80 a0 60 00 cmp %g1, 0
203a004: 22 80 00 07 be,a 203a020 <rtems_rfs_format+0x28> <== ALWAYS TAKEN
203a008: 92 10 20 00 clr %o1
printf ("rtems-rfs: format: %s\n", name);
203a00c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a010: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
203a014: 40 00 31 5c call 2046584 <printf> <== NOT EXECUTED
203a018: 90 12 20 b0 or %o0, 0xb0, %o0 <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
203a01c: 92 10 20 00 clr %o1 <== NOT EXECUTED
203a020: 94 10 20 84 mov 0x84, %o2
203a024: 40 00 2c ec call 20453d4 <memset>
203a028: 90 07 bf 28 add %fp, -216, %o0
203a02c: 82 07 bf 70 add %fp, -144, %g1
203a030: c2 27 bf 6c st %g1, [ %fp + -148 ]
head->previous = NULL;
tail->previous = head;
203a034: 82 07 bf 6c add %fp, -148, %g1
203a038: c2 27 bf 74 st %g1, [ %fp + -140 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
203a03c: 82 07 bf 80 add %fp, -128, %g1
203a040: c2 27 bf 7c st %g1, [ %fp + -132 ]
head->previous = NULL;
tail->previous = head;
203a044: 82 07 bf 7c add %fp, -132, %g1
203a048: c2 27 bf 84 st %g1, [ %fp + -124 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
203a04c: 82 07 bf 90 add %fp, -112, %g1
203a050: c2 27 bf 8c st %g1, [ %fp + -116 ]
head->previous = NULL;
tail->previous = head;
203a054: 82 07 bf 8c add %fp, -116, %g1
203a058: c2 27 bf 94 st %g1, [ %fp + -108 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
203a05c: 82 07 bf a0 add %fp, -96, %g1
203a060: c2 27 bf 9c st %g1, [ %fp + -100 ]
head->previous = NULL;
tail->previous = head;
203a064: 82 07 bf 9c add %fp, -100, %g1
203a068: c2 27 bf a4 st %g1, [ %fp + -92 ]
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;
203a06c: 82 10 20 05 mov 5, %g1
203a070: c2 27 bf 68 st %g1, [ %fp + -152 ]
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
203a074: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
203a078: 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;
203a07c: c2 27 bf 28 st %g1, [ %fp + -216 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
203a080: 7f ff f4 33 call 203714c <rtems_rfs_buffer_open>
203a084: 92 07 bf 28 add %fp, -216, %o1
if (rc > 0)
203a088: ba 92 20 00 orcc %o0, 0, %i5
203a08c: 04 80 00 08 ble 203a0ac <rtems_rfs_format+0xb4> <== ALWAYS TAKEN
203a090: c2 07 bf 38 ld [ %fp + -200 ], %g1
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
203a094: 40 00 3a f9 call 2048c78 <strerror> <== NOT EXECUTED
203a098: 01 00 00 00 nop <== NOT EXECUTED
203a09c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a0a0: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a0a4: 10 80 00 de b 203a41c <rtems_rfs_format+0x424> <== NOT EXECUTED
203a0a8: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20680c8 <__FUNCTION__.7646+0x1440><== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
203a0ac: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
203a0b0: 80 a0 60 00 cmp %g1, 0
203a0b4: 32 80 00 06 bne,a 203a0cc <rtems_rfs_format+0xd4> <== ALWAYS TAKEN
203a0b8: c2 06 40 00 ld [ %i1 ], %g1
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
203a0bc: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a0c0: 92 10 20 00 clr %o1 <== NOT EXECUTED
203a0c4: 10 80 01 71 b 203a688 <rtems_rfs_format+0x690> <== NOT EXECUTED
203a0c8: 90 12 20 f8 or %o0, 0xf8, %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)
203a0cc: 80 a0 60 00 cmp %g1, 0
203a0d0: 12 80 00 2a bne 203a178 <rtems_rfs_format+0x180>
203a0d4: c2 27 bf 30 st %g1, [ %fp + -208 ]
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
203a0d8: 7f ff fd 67 call 2039674 <rtems_rfs_fs_media_size>
203a0dc: 90 07 bf 28 add %fp, -216, %o0
if (total_size >= GIGS (1))
203a0e0: 80 a2 20 00 cmp %o0, 0
203a0e4: 12 80 00 08 bne 203a104 <rtems_rfs_format+0x10c> <== NEVER TAKEN
203a0e8: 84 10 20 00 clr %g2
203a0ec: 03 00 03 ff sethi %hi(0xffc00), %g1
203a0f0: 82 10 63 ff or %g1, 0x3ff, %g1 ! fffff <PROM_START+0xfffff>
203a0f4: 80 a2 40 01 cmp %o1, %g1
203a0f8: 08 80 00 16 bleu 203a150 <rtems_rfs_format+0x158> <== ALWAYS TAKEN
203a0fc: c2 07 bf 30 ld [ %fp + -208 ], %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
203a100: 84 10 20 00 clr %g2 <== NOT EXECUTED
203a104: 07 00 04 00 sethi %hi(0x100000), %g3 <== NOT EXECUTED
203a108: 92 82 40 03 addcc %o1, %g3, %o1 <== NOT EXECUTED
203a10c: 83 32 60 14 srl %o1, 0x14, %g1 <== NOT EXECUTED
203a110: 90 42 00 02 addx %o0, %g2, %o0 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
203a114: 84 10 20 01 mov 1, %g2 <== 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);
203a118: 87 2a 20 0c sll %o0, 0xc, %g3 <== NOT EXECUTED
203a11c: 86 10 c0 01 or %g3, %g1, %g3 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
203a120: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
203a124: 89 28 80 01 sll %g2, %g1, %g4 <== NOT EXECUTED
203a128: 80 89 00 03 btst %g4, %g3 <== NOT EXECUTED
203a12c: 32 80 00 06 bne,a 203a144 <rtems_rfs_format+0x14c> <== NOT EXECUTED
203a130: 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--)
203a134: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
203a138: 12 bf ff fc bne 203a128 <rtems_rfs_format+0x130> <== NOT EXECUTED
203a13c: 89 28 80 01 sll %g2, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
203a140: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
203a144: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
203a148: c2 27 bf 30 st %g1, [ %fp + -208 ] <== NOT EXECUTED
}
if (fs->block_size < 512)
203a14c: c2 07 bf 30 ld [ %fp + -208 ], %g1 <== NOT EXECUTED
203a150: 80 a0 61 ff cmp %g1, 0x1ff
203a154: 18 80 00 05 bgu 203a168 <rtems_rfs_format+0x170> <== NEVER TAKEN
203a158: c4 07 bf 30 ld [ %fp + -208 ], %g2
fs->block_size = 512;
203a15c: 82 10 22 00 mov 0x200, %g1
203a160: c2 27 bf 30 st %g1, [ %fp + -208 ]
if (fs->block_size > (4 * 1024))
203a164: c4 07 bf 30 ld [ %fp + -208 ], %g2
203a168: 03 00 00 04 sethi %hi(0x1000), %g1
203a16c: 80 a0 80 01 cmp %g2, %g1
203a170: 38 80 00 02 bgu,a 203a178 <rtems_rfs_format+0x180> <== NEVER TAKEN
203a174: c2 27 bf 30 st %g1, [ %fp + -208 ] <== NOT EXECUTED
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
203a178: c2 07 bf 38 ld [ %fp + -200 ], %g1
203a17c: fa 07 bf 30 ld [ %fp + -208 ], %i5
203a180: f8 00 60 24 ld [ %g1 + 0x24 ], %i4
203a184: 90 10 00 1d mov %i5, %o0
203a188: 40 00 85 5e call 205b700 <.urem>
203a18c: 92 10 00 1c mov %i4, %o1
203a190: 80 a2 20 00 cmp %o0, 0
203a194: 22 80 00 07 be,a 203a1b0 <rtems_rfs_format+0x1b8> <== ALWAYS TAKEN
203a198: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
203a19c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a1a0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a1a4: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
203a1a8: 10 80 00 9e b 203a420 <rtems_rfs_format+0x428> <== NOT EXECUTED
203a1ac: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203a1b0: bb 2f 60 03 sll %i5, 3, %i5
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
if (!fs->group_blocks)
203a1b4: 80 a0 60 00 cmp %g1, 0
203a1b8: 12 80 00 03 bne 203a1c4 <rtems_rfs_format+0x1cc> <== NEVER TAKEN
203a1bc: c2 27 bf 50 st %g1, [ %fp + -176 ]
{
/*
* 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);
203a1c0: fa 27 bf 50 st %i5, [ %fp + -176 ]
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
203a1c4: c2 07 bf 50 ld [ %fp + -176 ], %g1
{
printf ("group block count is higher than bits in block\n");
203a1c8: 11 00 81 a0 sethi %hi(0x2068000), %o0
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
203a1cc: 80 a0 40 1d cmp %g1, %i5
203a1d0: 18 80 01 1e bgu 203a648 <rtems_rfs_format+0x650> <== NEVER TAKEN
203a1d4: 90 12 21 60 or %o0, 0x160, %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;
203a1d8: 7f ff fd 27 call 2039674 <rtems_rfs_fs_media_size>
203a1dc: 90 07 bf 28 add %fp, -216, %o0
203a1e0: fa 07 bf 30 ld [ %fp + -208 ], %i5
203a1e4: 94 10 20 00 clr %o2
203a1e8: 40 00 88 55 call 205c33c <__udivdi3>
203a1ec: 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));
203a1f0: 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;
203a1f4: d2 27 bf 2c st %o1, [ %fp + -212 ]
/*
* 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),
203a1f8: 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;
203a1fc: 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),
203a200: 7f ff ff 5c call 2039f70 <rtems_rfs_rup_quotient>
203a204: 92 10 00 1c mov %i4, %o1
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
203a208: 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),
203a20c: d0 27 bf 4c st %o0, [ %fp + -180 ]
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
203a210: c2 27 bf 54 st %g1, [ %fp + -172 ]
if (!fs->group_inodes)
203a214: 80 a0 60 00 cmp %g1, 0
203a218: 12 80 00 14 bne 203a268 <rtems_rfs_format+0x270> <== NEVER TAKEN
203a21c: 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)
203a220: d0 06 60 0c ld [ %i1 + 0xc ], %o0
203a224: 80 a2 20 00 cmp %o0, 0
203a228: 22 80 00 02 be,a 203a230 <rtems_rfs_format+0x238> <== ALWAYS TAKEN
203a22c: 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;
203a230: 7f ff 22 e3 call 2002dbc <.umul>
203a234: 92 06 ff ff add %i3, -1, %o1
203a238: 40 00 84 86 call 205b450 <.udiv>
203a23c: 92 10 20 64 mov 0x64, %o1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
203a240: 7f ff ff 4c call 2039f70 <rtems_rfs_rup_quotient>
203a244: 92 10 00 1a mov %i2, %o1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
203a248: 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);
203a24c: b6 10 00 08 mov %o0, %i3
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
203a250: 40 00 84 80 call 205b450 <.udiv>
203a254: 90 10 00 1d mov %i5, %o0
203a258: 92 10 00 08 mov %o0, %o1
203a25c: 7f ff 22 d8 call 2002dbc <.umul>
203a260: 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);
203a264: d0 27 bf 54 st %o0, [ %fp + -172 ]
}
/*
* 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;
203a268: 90 10 00 1d mov %i5, %o0
203a26c: 40 00 84 79 call 205b450 <.udiv>
203a270: 92 10 20 38 mov 0x38, %o1
203a274: ba 10 00 08 mov %o0, %i5
203a278: d0 27 bf 58 st %o0, [ %fp + -168 ]
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
203a27c: d0 07 bf 54 ld [ %fp + -172 ], %o0
203a280: 7f ff ff 3c call 2039f70 <rtems_rfs_rup_quotient>
203a284: 92 10 00 1d mov %i5, %o1
fs->inodes_per_block) * fs->inodes_per_block;
203a288: 7f ff 22 cd call 2002dbc <.umul>
203a28c: 92 10 00 1d mov %i5, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
203a290: 80 a2 00 1c cmp %o0, %i4
203a294: 08 80 00 03 bleu 203a2a0 <rtems_rfs_format+0x2a8> <== ALWAYS TAKEN
203a298: d0 27 bf 54 st %o0, [ %fp + -172 ]
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
203a29c: f8 27 bf 54 st %i4, [ %fp + -172 ] <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
203a2a0: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
203a2a4: 80 a0 60 00 cmp %g1, 0
203a2a8: 12 80 02 70 bne 203ac68 <rtems_rfs_format+0xc70> <== NEVER TAKEN
203a2ac: c2 27 bf 44 st %g1, [ %fp + -188 ]
{
fs->max_name_length = 512;
203a2b0: 82 10 22 00 mov 0x200, %g1
203a2b4: 10 80 02 6d b 203ac68 <rtems_rfs_format+0xc70>
203a2b8: c2 27 bf 44 st %g1, [ %fp + -188 ]
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
203a2bc: 7f ff fc ee call 2039674 <rtems_rfs_fs_media_size> <== NOT EXECUTED
203a2c0: 90 07 bf 28 add %fp, -216, %o0 <== NOT EXECUTED
203a2c4: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
203a2c8: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
203a2cc: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a2d0: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
203a2d4: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
203a2d8: 40 00 30 ab call 2046584 <printf> <== NOT EXECUTED
203a2dc: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
203a2e0: c2 07 bf 38 ld [ %fp + -200 ], %g1 <== NOT EXECUTED
203a2e4: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a2e8: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
203a2ec: 40 00 30 a6 call 2046584 <printf> <== NOT EXECUTED
203a2f0: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
203a2f4: c2 07 bf 38 ld [ %fp + -200 ], %g1 <== NOT EXECUTED
203a2f8: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a2fc: d2 00 60 24 ld [ %g1 + 0x24 ], %o1 <== NOT EXECUTED
203a300: 40 00 30 a1 call 2046584 <printf> <== NOT EXECUTED
203a304: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
203a308: 7f ff fc d2 call 2039650 <rtems_rfs_fs_size> <== NOT EXECUTED
203a30c: 90 07 bf 28 add %fp, -216, %o0 <== NOT EXECUTED
203a310: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
203a314: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
203a318: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a31c: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
203a320: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
203a324: 40 00 30 98 call 2046584 <printf> <== NOT EXECUTED
203a328: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
203a32c: d2 07 bf 2c ld [ %fp + -212 ], %o1 <== NOT EXECUTED
203a330: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a334: 40 00 30 94 call 2046584 <printf> <== NOT EXECUTED
203a338: 90 12 22 30 or %o0, 0x230, %o0 ! 2068230 <__FUNCTION__.7646+0x15a8><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
203a33c: d2 07 bf 30 ld [ %fp + -208 ], %o1 <== NOT EXECUTED
203a340: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a344: 40 00 30 90 call 2046584 <printf> <== NOT EXECUTED
203a348: 90 12 22 58 or %o0, 0x258, %o0 ! 2068258 <__FUNCTION__.7646+0x15d0><== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
203a34c: d2 07 bf 30 ld [ %fp + -208 ], %o1 <== NOT EXECUTED
203a350: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a354: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
203a358: 40 00 30 8b call 2046584 <printf> <== NOT EXECUTED
203a35c: 90 12 22 80 or %o0, 0x280, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
203a360: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
203a364: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a368: 40 00 30 87 call 2046584 <printf> <== NOT EXECUTED
203a36c: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 20682a8 <__FUNCTION__.7646+0x1620><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
203a370: d2 07 bf 54 ld [ %fp + -172 ], %o1 <== NOT EXECUTED
203a374: 7f ff 22 92 call 2002dbc <.umul> <== NOT EXECUTED
203a378: d0 07 bf 4c ld [ %fp + -180 ], %o0 <== NOT EXECUTED
203a37c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
203a380: 7f ff ff 07 call 2039f9c <rtems_rfs_inode_overhead> <== NOT EXECUTED
203a384: 90 07 bf 28 add %fp, -216, %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",
203a388: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
203a38c: 40 00 84 33 call 205b458 <.div> <== NOT EXECUTED
203a390: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
203a394: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
203a398: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
203a39c: 40 00 84 db call 205b708 <.rem> <== NOT EXECUTED
203a3a0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
203a3a4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
203a3a8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203a3ac: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203a3b0: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a3b4: 40 00 30 74 call 2046584 <printf> <== NOT EXECUTED
203a3b8: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 20682d0 <__FUNCTION__.7646+0x1648><== 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);
203a3bc: d2 07 bf 4c ld [ %fp + -180 ], %o1 <== NOT EXECUTED
203a3c0: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a3c4: 40 00 30 70 call 2046584 <printf> <== NOT EXECUTED
203a3c8: 90 12 23 00 or %o0, 0x300, %o0 ! 2068300 <__FUNCTION__.7646+0x1678><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
203a3cc: d2 07 bf 50 ld [ %fp + -176 ], %o1 <== NOT EXECUTED
203a3d0: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a3d4: 40 00 30 6c call 2046584 <printf> <== NOT EXECUTED
203a3d8: 90 12 23 20 or %o0, 0x320, %o0 ! 2068320 <__FUNCTION__.7646+0x1698><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
203a3dc: d2 07 bf 54 ld [ %fp + -172 ], %o1 <== NOT EXECUTED
203a3e0: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a3e4: 40 00 30 68 call 2046584 <printf> <== NOT EXECUTED
203a3e8: 90 12 23 48 or %o0, 0x348, %o0 ! 2068348 <__FUNCTION__.7646+0x16c0><== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
203a3ec: d2 07 bf 30 ld [ %fp + -208 ], %o1 <== NOT EXECUTED
203a3f0: b6 07 bf 28 add %fp, -216, %i3
203a3f4: 7f ff f3 fc call 20373e4 <rtems_rfs_buffer_setblksize>
203a3f8: 90 10 00 1b mov %i3, %o0
if (rc > 0)
203a3fc: ba 92 20 00 orcc %o0, 0, %i5
203a400: 24 80 00 0b ble,a 203a42c <rtems_rfs_format+0x434> <== ALWAYS TAKEN
203a404: c0 2f bf ec clrb [ %fp + -20 ]
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
203a408: 40 00 3a 1c call 2048c78 <strerror> <== NOT EXECUTED
203a40c: 01 00 00 00 nop <== NOT EXECUTED
203a410: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a414: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a418: 90 12 23 70 or %o0, 0x370, %o0 ! 2068370 <__FUNCTION__.7646+0x16e8><== NOT EXECUTED
203a41c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a420: 40 00 30 59 call 2046584 <printf> <== NOT EXECUTED
203a424: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203a428: 30 80 02 0e b,a 203ac60 <rtems_rfs_format+0xc68> <== 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;
203a42c: c0 27 bf f0 clr [ %fp + -16 ]
handle->buffer = NULL;
203a430: c0 27 bf f4 clr [ %fp + -12 ]
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);
203a434: b8 07 bf ec add %fp, -20, %i4
203a438: 90 10 00 1b mov %i3, %o0
203a43c: 92 10 00 1c mov %i4, %o1
203a440: 94 10 20 00 clr %o2
203a444: 7f ff f2 9c call 2036eb4 <rtems_rfs_buffer_handle_request>
203a448: 96 10 20 00 clr %o3
if (rc > 0)
203a44c: ba 92 20 00 orcc %o0, 0, %i5
203a450: 04 80 00 0a ble 203a478 <rtems_rfs_format+0x480> <== ALWAYS TAKEN
203a454: 92 10 00 1c mov %i4, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a458: 7f ff fe bc call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a45c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
203a460: 40 00 3a 06 call 2048c78 <strerror> <== NOT EXECUTED
203a464: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203a468: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a46c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a470: 10 80 00 72 b 203a638 <rtems_rfs_format+0x640> <== NOT EXECUTED
203a474: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 20683a8 <__FUNCTION__.7646+0x1720><== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
203a478: c2 07 bf f4 ld [ %fp + -12 ], %g1
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
203a47c: d4 07 bf 30 ld [ %fp + -208 ], %o2
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
203a480: 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));
203a484: 92 10 20 ff mov 0xff, %o1
203a488: 40 00 2b d3 call 20453d4 <memset>
203a48c: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
203a490: 82 10 20 28 mov 0x28, %g1
203a494: c2 2f 40 00 stb %g1, [ %i5 ]
203a498: 82 10 20 09 mov 9, %g1
203a49c: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
203a4a0: 82 10 20 20 mov 0x20, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
203a4a4: 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);
203a4a8: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
203a4ac: c0 2f 60 05 clrb [ %i5 + 5 ]
203a4b0: c0 2f 60 06 clrb [ %i5 + 6 ]
203a4b4: 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);
203a4b8: 84 10 20 01 mov 1, %g2
203a4bc: 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));
203a4c0: c2 07 bf 2c ld [ %fp + -212 ], %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);
203a4c4: 92 10 00 1c mov %i4, %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));
203a4c8: 87 30 60 18 srl %g1, 0x18, %g3
203a4cc: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
203a4d0: 87 30 60 10 srl %g1, 0x10, %g3
203a4d4: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
203a4d8: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
203a4dc: 87 30 60 08 srl %g1, 8, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
203a4e0: c2 0f bf 30 ldub [ %fp + -208 ], %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));
203a4e4: c6 2f 60 0e stb %g3, [ %i5 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
203a4e8: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
203a4ec: c2 17 bf 30 lduh [ %fp + -208 ], %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);
203a4f0: 90 10 00 1b mov %i3, %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));
203a4f4: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
203a4f8: c2 07 bf 30 ld [ %fp + -208 ], %g1
203a4fc: 83 30 60 08 srl %g1, 8, %g1
203a500: c2 2f 60 0a stb %g1, [ %i5 + 0xa ]
203a504: c2 07 bf 30 ld [ %fp + -208 ], %g1
203a508: c2 2f 60 0b stb %g1, [ %i5 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
203a50c: c2 0f bf 40 ldub [ %fp + -192 ], %g1
203a510: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
203a514: c2 17 bf 40 lduh [ %fp + -192 ], %g1
203a518: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
203a51c: c2 07 bf 40 ld [ %fp + -192 ], %g1
203a520: 83 30 60 08 srl %g1, 8, %g1
203a524: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
203a528: c2 07 bf 40 ld [ %fp + -192 ], %g1
203a52c: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
203a530: c2 0f bf 44 ldub [ %fp + -188 ], %g1
203a534: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
203a538: c2 17 bf 44 lduh [ %fp + -188 ], %g1
203a53c: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
203a540: c2 07 bf 44 ld [ %fp + -188 ], %g1
203a544: 83 30 60 08 srl %g1, 8, %g1
203a548: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
203a54c: c2 07 bf 44 ld [ %fp + -188 ], %g1
203a550: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
203a554: c2 0f bf 4c ldub [ %fp + -180 ], %g1
203a558: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
203a55c: c2 17 bf 4c lduh [ %fp + -180 ], %g1
203a560: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
203a564: c2 07 bf 4c ld [ %fp + -180 ], %g1
203a568: 83 30 60 08 srl %g1, 8, %g1
203a56c: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
203a570: c2 07 bf 4c ld [ %fp + -180 ], %g1
203a574: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
203a578: c2 0f bf 50 ldub [ %fp + -176 ], %g1
203a57c: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
203a580: c2 17 bf 50 lduh [ %fp + -176 ], %g1
203a584: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
203a588: c2 07 bf 50 ld [ %fp + -176 ], %g1
203a58c: 83 30 60 08 srl %g1, 8, %g1
203a590: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
203a594: c2 07 bf 50 ld [ %fp + -176 ], %g1
203a598: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
203a59c: c2 0f bf 54 ldub [ %fp + -172 ], %g1
203a5a0: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
203a5a4: c2 17 bf 54 lduh [ %fp + -172 ], %g1
203a5a8: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
203a5ac: c2 07 bf 54 ld [ %fp + -172 ], %g1
203a5b0: 83 30 60 08 srl %g1, 8, %g1
203a5b4: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
203a5b8: c2 07 bf 54 ld [ %fp + -172 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
203a5bc: 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);
203a5c0: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
203a5c4: c0 2f 60 25 clrb [ %i5 + 0x25 ]
203a5c8: c0 2f 60 26 clrb [ %i5 + 0x26 ]
203a5cc: 82 10 20 38 mov 0x38, %g1
203a5d0: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
203a5d4: 7f ff f1 c6 call 2036cec <rtems_rfs_buffer_handle_release>
203a5d8: c4 2f bf ec stb %g2, [ %fp + -20 ]
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a5dc: 92 10 00 1c mov %i4, %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);
203a5e0: ba 10 00 08 mov %o0, %i5
if (rc > 0)
203a5e4: 80 a7 60 00 cmp %i5, 0
203a5e8: 04 80 00 0a ble 203a610 <rtems_rfs_format+0x618> <== ALWAYS TAKEN
203a5ec: 90 10 00 1b mov %i3, %o0
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a5f0: 7f ff fe 56 call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a5f4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
203a5f8: 40 00 39 a0 call 2048c78 <strerror> <== NOT EXECUTED
203a5fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203a600: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a604: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a608: 10 80 00 0c b 203a638 <rtems_rfs_format+0x640> <== NOT EXECUTED
203a60c: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 20683e0 <__FUNCTION__.7646+0x1758><== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
203a610: 7f ff fe 4e call 2039f48 <rtems_rfs_buffer_handle_close>
203a614: 01 00 00 00 nop
if (rc > 0)
203a618: ba 92 20 00 orcc %o0, 0, %i5
203a61c: 04 80 00 ee ble 203a9d4 <rtems_rfs_format+0x9dc> <== ALWAYS TAKEN
203a620: 2b 00 81 a1 sethi %hi(0x2068400), %l5
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
203a624: 40 00 39 95 call 2048c78 <strerror> <== NOT EXECUTED
203a628: 01 00 00 00 nop <== NOT EXECUTED
203a62c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a630: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a634: 90 12 20 20 or %o0, 0x20, %o0 ! 2068420 <__FUNCTION__.7646+0x1798><== NOT EXECUTED
203a638: 40 00 2f d3 call 2046584 <printf> <== NOT EXECUTED
203a63c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
203a640: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a644: 90 12 20 68 or %o0, 0x68, %o0 ! 2068468 <__FUNCTION__.7646+0x17e0><== NOT EXECUTED
203a648: 40 00 30 6a call 20467f0 <puts> <== NOT EXECUTED
203a64c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203a650: 30 80 01 84 b,a 203ac60 <rtems_rfs_format+0xc68> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
203a654: f4 07 bf 50 ld [ %fp + -176 ], %i2
203a658: 90 10 00 1d mov %i5, %o0
203a65c: 7f ff 21 d8 call 2002dbc <.umul>
203a660: 92 10 00 1a mov %i2, %o1
if (group_base > rtems_rfs_fs_blocks (fs))
203a664: c2 07 bf 2c ld [ %fp + -212 ], %g1
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
203a668: a4 02 20 01 add %o0, 1, %l2
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,
203a66c: 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))
203a670: 80 a4 80 01 cmp %l2, %g1
203a674: 08 80 00 08 bleu 203a694 <rtems_rfs_format+0x69c> <== ALWAYS TAKEN
203a678: a2 10 00 08 mov %o0, %l1
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
203a67c: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a680: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a684: 90 12 20 98 or %o0, 0x98, %o0 <== NOT EXECUTED
203a688: 40 00 2f bf call 2046584 <printf> <== NOT EXECUTED
203a68c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203a690: 30 80 01 74 b,a 203ac60 <rtems_rfs_format+0xc68> <== 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))
203a694: 84 04 80 1a add %l2, %i2, %g2
203a698: 80 a0 80 01 cmp %g2, %g1
203a69c: 38 80 00 02 bgu,a 203a6a4 <rtems_rfs_format+0x6ac> <== ALWAYS TAKEN
203a6a0: b4 20 40 12 sub %g1, %l2, %i2
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
203a6a4: 80 8c 20 ff btst 0xff, %l0
203a6a8: 22 80 00 08 be,a 203a6c8 <rtems_rfs_format+0x6d0> <== ALWAYS TAKEN
203a6ac: c0 2f bf ec clrb [ %fp + -20 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
203a6b0: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
203a6b4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a6b8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
203a6bc: 40 00 2f b2 call 2046584 <printf> <== NOT EXECUTED
203a6c0: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203a6c4: c0 2f bf ec clrb [ %fp + -20 ] <== NOT EXECUTED
handle->bnum = 0;
203a6c8: c0 27 bf f0 clr [ %fp + -16 ]
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
203a6cc: 80 8c 20 ff btst 0xff, %l0
203a6d0: 02 80 00 04 be 203a6e0 <rtems_rfs_format+0x6e8> <== ALWAYS TAKEN
203a6d4: c0 27 bf f4 clr [ %fp + -12 ]
printf (", blocks");
203a6d8: 40 00 2f ab call 2046584 <printf> <== NOT EXECUTED
203a6dc: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
203a6e0: 98 10 00 12 mov %l2, %o4
203a6e4: 90 07 bf d4 add %fp, -44, %o0
203a6e8: 92 10 00 1b mov %i3, %o1
203a6ec: 94 10 00 1c mov %i4, %o2
203a6f0: 40 00 1b 92 call 2041538 <rtems_rfs_bitmap_open>
203a6f4: 96 10 00 1a mov %i2, %o3
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
203a6f8: a4 92 20 00 orcc %o0, 0, %l2
203a6fc: 04 80 00 0f ble 203a738 <rtems_rfs_format+0x740> <== ALWAYS TAKEN
203a700: 92 10 00 1c mov %i4, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a704: 7f ff fe 11 call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a708: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
203a70c: 40 00 39 5b call 2048c78 <strerror> <== NOT EXECUTED
203a710: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
203a714: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203a718: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a71c: 90 12 21 20 or %o0, 0x120, %o0 ! 2068520 <__FUNCTION__.7646+0x1898><== NOT EXECUTED
203a720: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a724: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
203a728: 40 00 2f 97 call 2046584 <printf> <== NOT EXECUTED
203a72c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203a730: 81 c7 e0 08 ret
203a734: 81 e8 00 00 restore
/*
* 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));
203a738: c2 07 bf f4 ld [ %fp + -12 ], %g1
203a73c: d4 07 bf 30 ld [ %fp + -208 ], %o2
203a740: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
203a744: 40 00 2b 24 call 20453d4 <memset>
203a748: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
203a74c: 40 00 1a de call 20412c4 <rtems_rfs_bitmap_map_clear_all>
203a750: 90 07 bf d4 add %fp, -44, %o0
203a754: a4 10 00 08 mov %o0, %l2
if (rc > 0)
203a758: 80 a4 a0 00 cmp %l2, 0
203a75c: 04 80 00 0d ble 203a790 <rtems_rfs_format+0x798> <== ALWAYS TAKEN
203a760: 90 07 bf d4 add %fp, -44, %o0
{
rtems_rfs_bitmap_close (&bitmap);
203a764: 40 00 1b 86 call 204157c <rtems_rfs_bitmap_close> <== NOT EXECUTED
203a768: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
203a76c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203a770: 7f ff fd f6 call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a774: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
203a778: 40 00 39 40 call 2048c78 <strerror> <== NOT EXECUTED
203a77c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
203a780: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203a784: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a788: 10 bf ff e6 b 203a720 <rtems_rfs_format+0x728> <== NOT EXECUTED
203a78c: 90 12 21 68 or %o0, 0x168, %o0 ! 2068568 <__FUNCTION__.7646+0x18e0><== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
203a790: 40 00 1a 4b call 20410bc <rtems_rfs_bitmap_map_set>
203a794: 92 10 20 00 clr %o1
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
203a798: 92 10 20 01 mov 1, %o1
203a79c: 40 00 1a 48 call 20410bc <rtems_rfs_bitmap_map_set>
203a7a0: 90 07 bf d4 add %fp, -44, %o0
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
203a7a4: d0 07 bf 54 ld [ %fp + -172 ], %o0
203a7a8: d2 07 bf 58 ld [ %fp + -168 ], %o1
203a7ac: 7f ff fd f1 call 2039f70 <rtems_rfs_rup_quotient>
203a7b0: ae 10 20 00 clr %l7
203a7b4: 10 80 00 05 b 203a7c8 <rtems_rfs_format+0x7d0>
203a7b8: a4 10 00 08 mov %o0, %l2
/*
* 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);
203a7bc: 92 05 e0 02 add %l7, 2, %o1
203a7c0: 40 00 1a 3f call 20410bc <rtems_rfs_bitmap_map_set>
203a7c4: ae 05 e0 01 inc %l7
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++)
203a7c8: 80 a5 c0 12 cmp %l7, %l2
203a7cc: 06 bf ff fc bl 203a7bc <rtems_rfs_format+0x7c4>
203a7d0: 90 07 bf d4 add %fp, -44, %o0
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
203a7d4: 40 00 1b 6a call 204157c <rtems_rfs_bitmap_close>
203a7d8: 01 00 00 00 nop
if (rc > 0)
203a7dc: ae 92 20 00 orcc %o0, 0, %l7
203a7e0: 04 80 00 0d ble 203a814 <rtems_rfs_format+0x81c> <== ALWAYS TAKEN
203a7e4: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a7e8: 92 07 bf ec add %fp, -20, %o1 <== NOT EXECUTED
203a7ec: 7f ff fd d7 call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a7f0: 90 07 bf 28 add %fp, -216, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
203a7f4: 40 00 39 21 call 2048c78 <strerror> <== NOT EXECUTED
203a7f8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
203a7fc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a800: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203a804: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
203a808: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a80c: 10 bf ff c7 b 203a728 <rtems_rfs_format+0x730> <== NOT EXECUTED
203a810: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 20685b8 <__FUNCTION__.7646+0x1930><== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
203a814: 80 8c 20 ff btst 0xff, %l0
203a818: 02 80 00 04 be 203a828 <rtems_rfs_format+0x830> <== ALWAYS TAKEN
203a81c: c2 2f bf ec stb %g1, [ %fp + -20 ]
printf (", inodes");
203a820: 40 00 2f 59 call 2046584 <printf> <== NOT EXECUTED
203a824: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
203a828: 96 10 00 1a mov %i2, %o3
203a82c: 90 07 bf d4 add %fp, -44, %o0
203a830: 92 10 00 1b mov %i3, %o1
203a834: 94 10 00 1c mov %i4, %o2
203a838: 40 00 1b 40 call 2041538 <rtems_rfs_bitmap_open>
203a83c: 98 04 60 02 add %l1, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
203a840: b4 92 20 00 orcc %o0, 0, %i2
203a844: 04 80 00 0a ble 203a86c <rtems_rfs_format+0x874> <== ALWAYS TAKEN
203a848: 92 10 00 1c mov %i4, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a84c: 7f ff fd bf call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a850: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
203a854: 40 00 39 09 call 2048c78 <strerror> <== NOT EXECUTED
203a858: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203a85c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203a860: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a864: 10 80 00 17 b 203a8c0 <rtems_rfs_format+0x8c8> <== NOT EXECUTED
203a868: 90 12 22 10 or %o0, 0x210, %o0 ! 2068610 <__FUNCTION__.7646+0x1988><== 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));
203a86c: c2 07 bf f4 ld [ %fp + -12 ], %g1
203a870: d4 07 bf 30 ld [ %fp + -208 ], %o2
203a874: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
203a878: 40 00 2a d7 call 20453d4 <memset>
203a87c: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
203a880: 40 00 1a 91 call 20412c4 <rtems_rfs_bitmap_map_clear_all>
203a884: 90 07 bf d4 add %fp, -44, %o0
203a888: b4 10 00 08 mov %o0, %i2
if (rc > 0)
203a88c: 80 a6 a0 00 cmp %i2, 0
203a890: 04 80 00 0f ble 203a8cc <rtems_rfs_format+0x8d4> <== ALWAYS TAKEN
203a894: 90 07 bf d4 add %fp, -44, %o0
{
rtems_rfs_bitmap_close (&bitmap);
203a898: 40 00 1b 39 call 204157c <rtems_rfs_bitmap_close> <== NOT EXECUTED
203a89c: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
203a8a0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203a8a4: 7f ff fd a9 call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a8a8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
203a8ac: 40 00 38 f3 call 2048c78 <strerror> <== NOT EXECUTED
203a8b0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203a8b4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203a8b8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a8bc: 90 12 22 58 or %o0, 0x258, %o0 ! 2068658 <__FUNCTION__.7646+0x19d0><== NOT EXECUTED
203a8c0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a8c4: 10 bf ff 99 b 203a728 <rtems_rfs_format+0x730> <== NOT EXECUTED
203a8c8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
203a8cc: 40 00 1b 2c call 204157c <rtems_rfs_bitmap_close>
203a8d0: 01 00 00 00 nop
if (rc > 0)
203a8d4: b4 92 20 00 orcc %o0, 0, %i2
203a8d8: 04 80 00 0b ble 203a904 <rtems_rfs_format+0x90c> <== ALWAYS TAKEN
203a8dc: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a8e0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203a8e4: 7f ff fd 99 call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a8e8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
203a8ec: 40 00 38 e3 call 2048c78 <strerror> <== NOT EXECUTED
203a8f0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203a8f4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203a8f8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a8fc: 10 bf ff f1 b 203a8c0 <rtems_rfs_format+0x8c8> <== NOT EXECUTED
203a900: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 20686a8 <__FUNCTION__.7646+0x1a20><== NOT EXECUTED
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
203a904: c2 2f bf ec stb %g1, [ %fp + -20 ]
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
203a908: b4 10 20 00 clr %i2
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
203a90c: a2 04 60 03 add %l1, 3, %l1
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
203a910: 80 8d a0 ff btst 0xff, %l6
203a914: 12 80 00 20 bne 203a994 <rtems_rfs_format+0x99c> <== NEVER TAKEN
203a918: ae 10 20 01 mov 1, %l7
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
203a91c: 10 80 00 22 b 203a9a4 <rtems_rfs_format+0x9ac>
203a920: 90 10 00 1b mov %i3, %o0
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
203a924: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
203a928: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203a92c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
203a930: 7f ff f1 61 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
203a934: 96 10 20 00 clr %o3 <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
203a938: ac 92 20 00 orcc %o0, 0, %l6 <== NOT EXECUTED
203a93c: 04 80 00 10 ble 203a97c <rtems_rfs_format+0x984> <== NOT EXECUTED
203a940: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a944: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203a948: 7f ff fd 80 call 2039f48 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a94c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
203a950: 40 00 38 ca call 2048c78 <strerror> <== NOT EXECUTED
203a954: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
203a958: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a95c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
203a960: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
203a964: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a968: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
203a96c: 40 00 2f 06 call 2046584 <printf> <== NOT EXECUTED
203a970: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
203a974: 81 c7 e0 08 ret <== NOT EXECUTED
203a978: 91 e8 3f ff restore %g0, -1, %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), 0xff, rtems_rfs_fs_block_size (fs));
203a97c: d4 07 bf 30 ld [ %fp + -208 ], %o2 <== NOT EXECUTED
203a980: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 <== NOT EXECUTED
203a984: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
203a988: 40 00 2a 93 call 20453d4 <memset> <== NOT EXECUTED
203a98c: b4 06 a0 01 inc %i2 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
203a990: ee 2f bf ec stb %l7, [ %fp + -20 ] <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
203a994: 80 a6 80 12 cmp %i2, %l2 <== NOT EXECUTED
203a998: 06 bf ff e3 bl 203a924 <rtems_rfs_format+0x92c> <== NOT EXECUTED
203a99c: a0 04 40 1a add %l1, %i2, %l0 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
203a9a0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
203a9a4: 7f ff fd 69 call 2039f48 <rtems_rfs_buffer_handle_close>
203a9a8: 92 10 00 1c mov %i4, %o1
if (rc > 0)
203a9ac: b4 92 20 00 orcc %o0, 0, %i2
203a9b0: 24 80 00 0f ble,a 203a9ec <rtems_rfs_format+0x9f4> <== ALWAYS TAKEN
203a9b4: ba 07 60 01 inc %i5
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
203a9b8: 40 00 38 b0 call 2048c78 <strerror> <== NOT EXECUTED
203a9bc: 01 00 00 00 nop <== NOT EXECUTED
203a9c0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
203a9c4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a9c8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a9cc: 10 bf fe 95 b 203a420 <rtems_rfs_format+0x428> <== NOT EXECUTED
203a9d0: 90 12 23 38 or %o0, 0x338, %o0 ! 2068738 <__FUNCTION__.7646+0x1ab0><== NOT EXECUTED
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
203a9d4: 29 00 81 a1 sethi %hi(0x2068400), %l4
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
203a9d8: 27 00 81 a1 sethi %hi(0x2068400), %l3
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
203a9dc: ba 10 20 00 clr %i5
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
203a9e0: aa 15 60 d8 or %l5, 0xd8, %l5
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
203a9e4: a8 15 21 10 or %l4, 0x110, %l4
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
203a9e8: a6 14 e2 00 or %l3, 0x200, %l3
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
203a9ec: c2 07 bf 4c ld [ %fp + -180 ], %g1
203a9f0: 80 a7 40 01 cmp %i5, %g1
203a9f4: 06 bf ff 18 bl 203a654 <rtems_rfs_format+0x65c>
203a9f8: e0 0e 60 15 ldub [ %i1 + 0x15 ], %l0
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
203a9fc: 80 8c 20 ff btst 0xff, %l0
203aa00: 02 80 00 04 be 203aa10 <rtems_rfs_format+0xa18> <== ALWAYS TAKEN
203aa04: 01 00 00 00 nop
printf ("\n");
203aa08: 40 00 2f 4c call 2046738 <putchar> <== NOT EXECUTED
203aa0c: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
203aa10: 7f ff f2 b0 call 20374d0 <rtems_rfs_buffer_close>
203aa14: 90 07 bf 28 add %fp, -216, %o0
if (rc > 0)
203aa18: ba 92 20 00 orcc %o0, 0, %i5
203aa1c: 24 80 00 08 ble,a 203aa3c <rtems_rfs_format+0xa44> <== ALWAYS TAKEN
203aa20: 90 10 00 18 mov %i0, %o0
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
203aa24: 40 00 38 95 call 2048c78 <strerror> <== NOT EXECUTED
203aa28: 01 00 00 00 nop <== NOT EXECUTED
203aa2c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203aa30: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aa34: 10 bf fe 7a b 203a41c <rtems_rfs_format+0x424> <== NOT EXECUTED
203aa38: 90 12 23 78 or %o0, 0x378, %o0 ! 2068778 <__FUNCTION__.7646+0x1af0><== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
203aa3c: 92 10 20 00 clr %o1
203aa40: 94 10 20 06 mov 6, %o2
203aa44: 96 10 20 00 clr %o3
203aa48: 7f ff fb 15 call 203969c <rtems_rfs_fs_open>
203aa4c: 98 07 bf f8 add %fp, -8, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
203aa50: 80 a2 20 00 cmp %o0, 0
203aa54: 36 80 00 0c bge,a 203aa84 <rtems_rfs_format+0xa8c> <== ALWAYS TAKEN
203aa58: d0 07 bf f8 ld [ %fp + -8 ], %o0
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
203aa5c: 40 00 1c 91 call 2041ca0 <__errno> <== NOT EXECUTED
203aa60: 01 00 00 00 nop <== NOT EXECUTED
203aa64: 40 00 1c 8f call 2041ca0 <__errno> <== NOT EXECUTED
203aa68: 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",
203aa6c: 40 00 38 83 call 2048c78 <strerror> <== NOT EXECUTED
203aa70: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
203aa74: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203aa78: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aa7c: 10 80 00 6b b 203ac28 <rtems_rfs_format+0xc30> <== NOT EXECUTED
203aa80: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 20687a8 <__FUNCTION__.7646+0x1b20><== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
203aa84: 92 10 20 01 mov 1, %o1
203aa88: 40 00 02 34 call 203b358 <rtems_rfs_inode_alloc>
203aa8c: 94 07 bf fc add %fp, -4, %o2
if (rc > 0)
203aa90: ba 92 20 00 orcc %o0, 0, %i5
203aa94: 04 80 00 0a ble 203aabc <rtems_rfs_format+0xac4> <== ALWAYS TAKEN
203aa98: d2 07 bf fc ld [ %fp + -4 ], %o1
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
203aa9c: 40 00 38 77 call 2048c78 <strerror> <== NOT EXECUTED
203aaa0: 01 00 00 00 nop <== NOT EXECUTED
203aaa4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203aaa8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203aaac: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aab0: 40 00 2e b5 call 2046584 <printf> <== NOT EXECUTED
203aab4: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 20687e0 <__FUNCTION__.7646+0x1b58><== NOT EXECUTED
203aab8: 30 80 00 1d b,a 203ab2c <rtems_rfs_format+0xb34> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
203aabc: 80 a2 60 01 cmp %o1, 1
203aac0: 02 80 00 08 be 203aae0 <rtems_rfs_format+0xae8> <== ALWAYS TAKEN
203aac4: 11 00 81 a2 sethi %hi(0x2068800), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
203aac8: 40 00 2e af call 2046584 <printf> <== NOT EXECUTED
203aacc: 90 12 20 18 or %o0, 0x18, %o0 ! 2068818 <__FUNCTION__.7646+0x1b90><== NOT EXECUTED
rtems_rfs_fs_close (fs);
203aad0: 7f ff fd 01 call 2039ed4 <rtems_rfs_fs_close> <== NOT EXECUTED
203aad4: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
203aad8: 81 c7 e0 08 ret <== NOT EXECUTED
203aadc: 91 e8 20 00 restore %g0, 0, %o0 <== 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);
203aae0: d0 07 bf f8 ld [ %fp + -8 ], %o0
203aae4: 92 10 20 01 mov 1, %o1
203aae8: 94 07 bf ac add %fp, -84, %o2
203aaec: 40 00 02 56 call 203b444 <rtems_rfs_inode_open>
203aaf0: 96 10 20 01 mov 1, %o3
if (rc > 0)
203aaf4: ba 92 20 00 orcc %o0, 0, %i5
203aaf8: 24 80 00 10 ble,a 203ab38 <rtems_rfs_format+0xb40> <== ALWAYS TAKEN
203aafc: 90 07 bf ac add %fp, -84, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
203ab00: 40 00 38 5e call 2048c78 <strerror> <== NOT EXECUTED
203ab04: 01 00 00 00 nop <== NOT EXECUTED
203ab08: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203ab0c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ab10: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ab14: 40 00 2e 9c call 2046584 <printf> <== NOT EXECUTED
203ab18: 90 12 20 50 or %o0, 0x50, %o0 ! 2068850 <__FUNCTION__.7646+0x1bc8><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
203ab1c: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
203ab20: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
203ab24: 40 00 01 79 call 203b108 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
203ab28: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
rtems_rfs_fs_close (fs);
203ab2c: 7f ff fc ea call 2039ed4 <rtems_rfs_fs_close> <== NOT EXECUTED
203ab30: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
203ab34: 30 80 00 43 b,a 203ac40 <rtems_rfs_format+0xc48> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
203ab38: 92 10 20 00 clr %o1
203ab3c: 15 00 00 10 sethi %hi(0x4000), %o2
203ab40: 96 10 20 00 clr %o3
203ab44: 94 12 a1 c9 or %o2, 0x1c9, %o2
203ab48: 40 00 03 31 call 203b80c <rtems_rfs_inode_initialise>
203ab4c: 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)
203ab50: ba 92 20 00 orcc %o0, 0, %i5
203ab54: 24 80 00 0a ble,a 203ab7c <rtems_rfs_format+0xb84> <== ALWAYS TAKEN
203ab58: d0 07 bf f8 ld [ %fp + -8 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
203ab5c: 40 00 38 47 call 2048c78 <strerror> <== NOT EXECUTED
203ab60: 01 00 00 00 nop <== NOT EXECUTED
203ab64: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203ab68: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ab6c: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ab70: 40 00 2e 85 call 2046584 <printf> <== NOT EXECUTED
203ab74: 90 12 20 80 or %o0, 0x80, %o0 ! 2068880 <__FUNCTION__.7646+0x1bf8><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
203ab78: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
203ab7c: d8 07 bf fc ld [ %fp + -4 ], %o4
203ab80: 92 07 bf ac add %fp, -84, %o1
203ab84: 15 00 81 81 sethi %hi(0x2060400), %o2
203ab88: 96 10 20 01 mov 1, %o3
203ab8c: 7f ff f3 c7 call 2037aa8 <rtems_rfs_dir_add_entry>
203ab90: 94 12 a3 60 or %o2, 0x360, %o2
if (rc > 0)
203ab94: ba 92 20 00 orcc %o0, 0, %i5
203ab98: 24 80 00 0a ble,a 203abc0 <rtems_rfs_format+0xbc8> <== ALWAYS TAKEN
203ab9c: d0 07 bf f8 ld [ %fp + -8 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
203aba0: 40 00 38 36 call 2048c78 <strerror> <== NOT EXECUTED
203aba4: 01 00 00 00 nop <== NOT EXECUTED
203aba8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203abac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203abb0: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203abb4: 40 00 2e 74 call 2046584 <printf> <== NOT EXECUTED
203abb8: 90 12 20 b8 or %o0, 0xb8, %o0 ! 20688b8 <__FUNCTION__.7646+0x1c30><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
203abbc: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
203abc0: 40 00 02 93 call 203b60c <rtems_rfs_inode_close>
203abc4: 92 07 bf ac add %fp, -84, %o1
if (rc > 0)
203abc8: ba 92 20 00 orcc %o0, 0, %i5
203abcc: 04 80 00 09 ble 203abf0 <rtems_rfs_format+0xbf8> <== ALWAYS TAKEN
203abd0: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
203abd4: 40 00 38 29 call 2048c78 <strerror> <== NOT EXECUTED
203abd8: 01 00 00 00 nop <== NOT EXECUTED
203abdc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203abe0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203abe4: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203abe8: 40 00 2e 67 call 2046584 <printf> <== NOT EXECUTED
203abec: 90 12 20 f0 or %o0, 0xf0, %o0 ! 20688f0 <__FUNCTION__.7646+0x1c68><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
203abf0: 7f ff fc b9 call 2039ed4 <rtems_rfs_fs_close>
203abf4: d0 07 bf f8 ld [ %fp + -8 ], %o0
if (rc < 0)
203abf8: ba 92 20 00 orcc %o0, 0, %i5
203abfc: 16 80 00 0f bge 203ac38 <rtems_rfs_format+0xc40> <== ALWAYS TAKEN
203ac00: 80 a7 60 00 cmp %i5, 0
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
203ac04: 40 00 1c 27 call 2041ca0 <__errno> <== NOT EXECUTED
203ac08: 01 00 00 00 nop <== NOT EXECUTED
203ac0c: 40 00 1c 25 call 2041ca0 <__errno> <== NOT EXECUTED
203ac10: fa 02 00 00 ld [ %o0 ], %i5 <== 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",
203ac14: 40 00 38 19 call 2048c78 <strerror> <== NOT EXECUTED
203ac18: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
203ac1c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ac20: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ac24: 90 12 21 20 or %o0, 0x120, %o0 ! 2068920 <__FUNCTION__.7646+0x1c98><== NOT EXECUTED
203ac28: 40 00 2e 57 call 2046584 <printf> <== NOT EXECUTED
203ac2c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
203ac30: 81 c7 e0 08 ret <== NOT EXECUTED
203ac34: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
203ac38: 04 bf fe be ble 203a730 <rtems_rfs_format+0x738> <== ALWAYS TAKEN
203ac3c: b0 10 20 00 clr %i0
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
203ac40: 40 00 38 0e call 2048c78 <strerror> <== NOT EXECUTED
203ac44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203ac48: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203ac4c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
rc, strerror (rc));
return -1;
203ac50: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
203ac54: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ac58: 40 00 2e 4b call 2046584 <printf> <== NOT EXECUTED
203ac5c: 90 12 21 58 or %o0, 0x158, %o0 ! 2068958 <__FUNCTION__.7646+0x1cd0><== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
203ac60: 81 c7 e0 08 ret <== NOT EXECUTED
203ac64: 81 e8 00 00 restore <== NOT EXECUTED
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
203ac68: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
203ac6c: 80 a0 60 00 cmp %g1, 0
203ac70: 02 bf fd e0 be 203a3f0 <rtems_rfs_format+0x3f8> <== ALWAYS TAKEN
203ac74: d2 07 bf 30 ld [ %fp + -208 ], %o1
203ac78: 30 bf fd 91 b,a 203a2bc <rtems_rfs_format+0x2c4> <== NOT EXECUTED
02039ed4 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
2039ed4: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
2039ed8: 90 10 20 00 clr %o0
2039edc: 7f ff a5 f3 call 20236a8 <rtems_rfs_trace>
2039ee0: 92 10 20 02 mov 2, %o1
2039ee4: 80 8a 20 ff btst 0xff, %o0
2039ee8: 22 80 00 06 be,a 2039f00 <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
2039eec: b8 10 20 00 clr %i4
printf ("rtems-rfs: close\n");
2039ef0: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039ef4: 40 00 32 3f call 20467f0 <puts> <== NOT EXECUTED
2039ef8: 90 12 20 98 or %o0, 0x98, %o0 ! 2068098 <__FUNCTION__.7646+0x1410><== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
2039efc: b8 10 20 00 clr %i4 <== NOT EXECUTED
2039f00: 10 80 00 07 b 2039f1c <rtems_rfs_fs_close+0x48>
2039f04: 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]);
2039f08: 90 10 00 18 mov %i0, %o0
2039f0c: 92 02 40 1c add %o1, %i4, %o1
2039f10: 40 00 03 da call 203ae78 <rtems_rfs_group_close>
2039f14: ba 07 60 01 inc %i5
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
2039f18: b8 07 20 50 add %i4, 0x50, %i4
2039f1c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2039f20: 80 a7 40 01 cmp %i5, %g1
2039f24: 26 bf ff f9 bl,a 2039f08 <rtems_rfs_fs_close+0x34>
2039f28: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
2039f2c: 7f ff f5 69 call 20374d0 <rtems_rfs_buffer_close>
2039f30: 90 10 00 18 mov %i0, %o0
free (fs);
2039f34: 90 10 00 18 mov %i0, %o0
2039f38: 7f ff 3a 10 call 2008778 <free>
2039f3c: b0 10 20 00 clr %i0
return 0;
}
2039f40: 81 c7 e0 08 ret
2039f44: 81 e8 00 00 restore
0203969c <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)
{
203969c: 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))
20396a0: 90 10 20 00 clr %o0
20396a4: 7f ff a8 01 call 20236a8 <rtems_rfs_trace>
20396a8: 92 10 20 01 mov 1, %o1
20396ac: 80 8a 20 ff btst 0xff, %o0
20396b0: 02 80 00 05 be 20396c4 <rtems_rfs_fs_open+0x28> <== ALWAYS TAKEN
20396b4: 11 00 81 9f sethi %hi(0x2067c00), %o0
printf ("rtems-rfs: open: %s\n", name);
20396b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20396bc: 40 00 33 b2 call 2046584 <printf> <== NOT EXECUTED
20396c0: 90 12 21 58 or %o0, 0x158, %o0 <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
20396c4: 7f ff 3d ad call 2008d78 <malloc>
20396c8: 90 10 20 84 mov 0x84, %o0
if (!*fs)
20396cc: 80 a2 20 00 cmp %o0, 0
20396d0: 12 80 00 0f bne 203970c <rtems_rfs_fs_open+0x70> <== ALWAYS TAKEN
20396d4: d0 27 00 00 st %o0, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
20396d8: 90 10 20 00 clr %o0 <== NOT EXECUTED
20396dc: 7f ff a7 f3 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20396e0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20396e4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20396e8: 02 80 00 05 be 20396fc <rtems_rfs_fs_open+0x60> <== NOT EXECUTED
20396ec: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
20396f0: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
20396f4: 40 00 34 3f call 20467f0 <puts> <== NOT EXECUTED
20396f8: 90 12 21 70 or %o0, 0x170, %o0 ! 2067d70 <__FUNCTION__.7646+0x10e8><== NOT EXECUTED
errno = ENOMEM;
20396fc: 40 00 21 69 call 2041ca0 <__errno> <== NOT EXECUTED
2039700: 01 00 00 00 nop <== NOT EXECUTED
2039704: 10 80 01 ca b 2039e2c <rtems_rfs_fs_open+0x790> <== NOT EXECUTED
2039708: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
203970c: 92 10 20 00 clr %o1
2039710: 40 00 2f 31 call 20453d4 <memset>
2039714: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
2039718: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
203971c: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
2039720: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
2039724: 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;
2039728: 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 );
203972c: 84 00 60 44 add %g1, 0x44, %g2
2039730: 86 00 60 48 add %g1, 0x48, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
2039734: 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;
2039738: c6 20 60 44 st %g3, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
203973c: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
2039740: 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 );
2039744: 84 00 60 54 add %g1, 0x54, %g2
2039748: 86 00 60 58 add %g1, 0x58, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
203974c: 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;
2039750: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
2039754: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
2039758: 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 );
203975c: 84 00 60 64 add %g1, 0x64, %g2
2039760: 86 00 60 68 add %g1, 0x68, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
2039764: 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;
2039768: c6 20 60 64 st %g3, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
203976c: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
2039770: 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 );
2039774: 84 00 60 74 add %g1, 0x74, %g2
2039778: 86 00 60 78 add %g1, 0x78, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
203977c: 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;
2039780: c6 20 60 74 st %g3, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
2039784: d2 07 00 00 ld [ %i4 ], %o1
2039788: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
203978c: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
2039790: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
2039794: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
2039798: 7f ff f6 6d call 203714c <rtems_rfs_buffer_open>
203979c: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
20397a0: ba 92 20 00 orcc %o0, 0, %i5
20397a4: 04 80 00 10 ble 20397e4 <rtems_rfs_fs_open+0x148> <== ALWAYS TAKEN
20397a8: f2 07 00 00 ld [ %i4 ], %i1
{
free (*fs);
20397ac: 7f ff 3b f3 call 2008778 <free> <== NOT EXECUTED
20397b0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
20397b4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20397b8: 7f ff a7 bc call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20397bc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20397c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20397c4: 02 80 01 b2 be 2039e8c <rtems_rfs_fs_open+0x7f0> <== NOT EXECUTED
20397c8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
20397cc: 40 00 3d 2b call 2048c78 <strerror> <== NOT EXECUTED
20397d0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20397d4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20397d8: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
20397dc: 10 80 01 aa b 2039e84 <rtems_rfs_fs_open+0x7e8> <== NOT EXECUTED
20397e0: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 2067da0 <__FUNCTION__.7646+0x1118><== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20397e4: c0 2f bf f4 clrb [ %fp + -12 ]
handle->bnum = 0;
20397e8: c0 27 bf f8 clr [ %fp + -8 ]
handle->buffer = NULL;
20397ec: c0 27 bf fc clr [ %fp + -4 ]
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);
20397f0: 90 10 00 19 mov %i1, %o0
20397f4: 92 07 bf f4 add %fp, -12, %o1
20397f8: 94 10 20 00 clr %o2
20397fc: 7f ff f5 ae call 2036eb4 <rtems_rfs_buffer_handle_request>
2039800: 96 10 20 01 mov 1, %o3
if (rc > 0)
2039804: b6 92 20 00 orcc %o0, 0, %i3
2039808: 04 80 00 0d ble 203983c <rtems_rfs_fs_open+0x1a0> <== ALWAYS TAKEN
203980c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039810: 7f ff a7 a6 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039814: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039818: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203981c: 02 80 01 3b be 2039d08 <rtems_rfs_fs_open+0x66c> <== NOT EXECUTED
2039820: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
2039824: 40 00 3d 15 call 2048c78 <strerror> <== NOT EXECUTED
2039828: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
203982c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039830: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039834: 10 80 00 e7 b 2039bd0 <rtems_rfs_fs_open+0x534> <== NOT EXECUTED
2039838: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 2067dd0 <__FUNCTION__.7646+0x1148><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
203983c: c2 07 bf fc ld [ %fp + -4 ], %g1
2039840: 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)
2039844: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
2039848: c4 0f 40 00 ldub [ %i5 ], %g2
203984c: 83 28 60 10 sll %g1, 0x10, %g1
2039850: 85 28 a0 18 sll %g2, 0x18, %g2
2039854: 84 10 80 01 or %g2, %g1, %g2
2039858: c2 0f 60 03 ldub [ %i5 + 3 ], %g1
203985c: 84 10 80 01 or %g2, %g1, %g2
2039860: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
2039864: 83 28 60 08 sll %g1, 8, %g1
2039868: 84 10 80 01 or %g2, %g1, %g2
203986c: 03 0a 02 48 sethi %hi(0x28092000), %g1
2039870: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001>
2039874: 80 a0 80 01 cmp %g2, %g1
2039878: 22 80 00 0b be,a 20398a4 <rtems_rfs_fs_open+0x208> <== ALWAYS TAKEN
203987c: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039880: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039884: 7f ff a7 89 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039888: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203988c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039890: 22 80 00 57 be,a 20399ec <rtems_rfs_fs_open+0x350> <== NOT EXECUTED
2039894: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
2039898: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
203989c: 10 80 00 2f b 2039958 <rtems_rfs_fs_open+0x2bc> <== NOT EXECUTED
20398a0: 90 12 22 08 or %o0, 0x208, %o0 ! 2067e08 <__FUNCTION__.7646+0x1180><== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
20398a4: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
20398a8: 83 28 60 10 sll %g1, 0x10, %g1
20398ac: 97 2a e0 18 sll %o3, 0x18, %o3
20398b0: 96 12 c0 01 or %o3, %g1, %o3
20398b4: 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;
20398b8: 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);
20398bc: 96 12 c0 01 or %o3, %g1, %o3
20398c0: 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;
20398c4: 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);
20398c8: 83 28 60 08 sll %g1, 8, %g1
20398cc: 96 12 c0 01 or %o3, %g1, %o3
20398d0: d6 26 60 04 st %o3, [ %i1 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
20398d4: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
20398d8: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
20398dc: 83 28 60 10 sll %g1, 0x10, %g1
20398e0: b5 2e a0 18 sll %i2, 0x18, %i2
20398e4: b4 16 80 01 or %i2, %g1, %i2
20398e8: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
20398ec: b4 16 80 01 or %i2, %g1, %i2
20398f0: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
20398f4: 83 28 60 08 sll %g1, 8, %g1
20398f8: b4 16 80 01 or %i2, %g1, %i2
20398fc: f4 26 60 08 st %i2, [ %i1 + 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;
2039900: 40 00 88 2c call 205b9b0 <__muldi3>
2039904: 92 10 00 1a mov %i2, %o1
2039908: b6 10 00 08 mov %o0, %i3
203990c: 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))
2039910: 7f ff ff 59 call 2039674 <rtems_rfs_fs_media_size>
2039914: 90 10 00 19 mov %i1, %o0
2039918: 80 a6 c0 08 cmp %i3, %o0
203991c: 38 80 00 08 bgu,a 203993c <rtems_rfs_fs_open+0x2a0> <== NEVER TAKEN
2039920: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039924: 32 80 00 11 bne,a 2039968 <rtems_rfs_fs_open+0x2cc> <== NEVER TAKEN
2039928: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
203992c: 80 a6 00 09 cmp %i0, %o1
2039930: 28 80 00 0e bleu,a 2039968 <rtems_rfs_fs_open+0x2cc> <== ALWAYS TAKEN
2039934: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039938: 90 10 20 00 clr %o0 <== NOT EXECUTED
203993c: 7f ff a7 5b call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039940: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039944: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039948: 22 80 00 29 be,a 20399ec <rtems_rfs_fs_open+0x350> <== NOT EXECUTED
203994c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
2039950: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039954: 90 12 22 48 or %o0, 0x248, %o0 ! 2067e48 <__FUNCTION__.7646+0x11c0><== NOT EXECUTED
2039958: 40 00 33 a6 call 20467f0 <puts> <== NOT EXECUTED
203995c: 01 00 00 00 nop <== 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);
2039960: 10 80 00 23 b 20399ec <rtems_rfs_fs_open+0x350> <== NOT EXECUTED
2039964: 90 10 00 19 mov %i1, %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)
2039968: c2 0f 60 25 ldub [ %i5 + 0x25 ], %g1
203996c: 85 28 a0 18 sll %g2, 0x18, %g2
2039970: 83 28 60 10 sll %g1, 0x10, %g1
2039974: 82 10 80 01 or %g2, %g1, %g1
2039978: c4 0f 60 27 ldub [ %i5 + 0x27 ], %g2
203997c: 82 10 40 02 or %g1, %g2, %g1
2039980: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
2039984: 85 28 a0 08 sll %g2, 8, %g2
2039988: 82 10 40 02 or %g1, %g2, %g1
203998c: 80 a0 60 38 cmp %g1, 0x38
2039990: 22 80 00 1b be,a 20399fc <rtems_rfs_fs_open+0x360> <== ALWAYS TAKEN
2039994: c4 0f 60 10 ldub [ %i5 + 0x10 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039998: 90 10 20 00 clr %o0 <== NOT EXECUTED
203999c: 7f ff a7 43 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20399a0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20399a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20399a8: 22 80 00 11 be,a 20399ec <rtems_rfs_fs_open+0x350> <== NOT EXECUTED
20399ac: 90 10 00 19 mov %i1, %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);
20399b0: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
20399b4: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
20399b8: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
20399bc: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
20399c0: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
20399c4: 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",
20399c8: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
20399cc: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
20399d0: 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",
20399d4: 90 12 22 88 or %o0, 0x288, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
20399d8: 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",
20399dc: 94 10 20 00 clr %o2 <== NOT EXECUTED
20399e0: 40 00 32 e9 call 2046584 <printf> <== NOT EXECUTED
20399e4: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
20399e8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20399ec: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
20399f0: 7f ff f4 bf call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
20399f4: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED
20399f8: 30 80 00 c4 b,a 2039d08 <rtems_rfs_fs_open+0x66c> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
20399fc: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
2039a00: 85 28 a0 18 sll %g2, 0x18, %g2
2039a04: 83 28 60 10 sll %g1, 0x10, %g1
2039a08: 82 10 80 01 or %g2, %g1, %g1
2039a0c: 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);
2039a10: 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);
2039a14: 82 10 40 02 or %g1, %g2, %g1
2039a18: 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;
2039a1c: 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);
2039a20: 85 28 a0 08 sll %g2, 8, %g2
2039a24: 82 10 40 02 or %g1, %g2, %g1
2039a28: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
2039a2c: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
2039a30: c2 0f 60 15 ldub [ %i5 + 0x15 ], %g1
2039a34: 85 28 a0 18 sll %g2, 0x18, %g2
2039a38: 83 28 60 10 sll %g1, 0x10, %g1
2039a3c: 82 10 80 01 or %g2, %g1, %g1
2039a40: c4 0f 60 17 ldub [ %i5 + 0x17 ], %g2
2039a44: 82 10 40 02 or %g1, %g2, %g1
2039a48: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
2039a4c: 85 28 a0 08 sll %g2, 8, %g2
2039a50: 82 10 40 02 or %g1, %g2, %g1
2039a54: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
2039a58: c2 0f 60 19 ldub [ %i5 + 0x19 ], %g1
2039a5c: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
2039a60: 83 28 60 10 sll %g1, 0x10, %g1
2039a64: b1 2e 20 18 sll %i0, 0x18, %i0
2039a68: b0 16 00 01 or %i0, %g1, %i0
2039a6c: c2 0f 60 1b ldub [ %i5 + 0x1b ], %g1
2039a70: b0 16 00 01 or %i0, %g1, %i0
2039a74: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
2039a78: 83 28 60 08 sll %g1, 8, %g1
2039a7c: b0 16 00 01 or %i0, %g1, %i0
2039a80: f0 26 60 24 st %i0, [ %i1 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
2039a84: c2 0f 60 1d ldub [ %i5 + 0x1d ], %g1
2039a88: f6 0f 60 1c ldub [ %i5 + 0x1c ], %i3
2039a8c: 83 28 60 10 sll %g1, 0x10, %g1
2039a90: b7 2e e0 18 sll %i3, 0x18, %i3
2039a94: b6 16 c0 01 or %i3, %g1, %i3
2039a98: c2 0f 60 1f ldub [ %i5 + 0x1f ], %g1
2039a9c: b6 16 c0 01 or %i3, %g1, %i3
2039aa0: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
2039aa4: 83 28 60 08 sll %g1, 8, %g1
2039aa8: b6 16 c0 01 or %i3, %g1, %i3
2039aac: f6 26 60 28 st %i3, [ %i1 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
2039ab0: c2 0f 60 21 ldub [ %i5 + 0x21 ], %g1
2039ab4: c4 0f 60 20 ldub [ %i5 + 0x20 ], %g2
2039ab8: 83 28 60 10 sll %g1, 0x10, %g1
2039abc: 85 28 a0 18 sll %g2, 0x18, %g2
2039ac0: 84 10 80 01 or %g2, %g1, %g2
2039ac4: c2 0f 60 23 ldub [ %i5 + 0x23 ], %g1
2039ac8: 84 10 80 01 or %g2, %g1, %g2
2039acc: c2 0f 60 22 ldub [ %i5 + 0x22 ], %g1
fs->blocks_per_block =
2039ad0: d0 26 60 34 st %o0, [ %i1 + 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);
2039ad4: 83 28 60 08 sll %g1, 8, %g1
2039ad8: 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;
2039adc: 83 2a 20 02 sll %o0, 2, %g1
2039ae0: 82 00 40 08 add %g1, %o0, %g1
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);
2039ae4: fa 26 60 2c st %i5, [ %i1 + 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;
2039ae8: 7f ff 24 b5 call 2002dbc <.umul>
2039aec: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
2039af0: 83 2a 20 02 sll %o0, 2, %g1
2039af4: 82 00 40 08 add %g1, %o0, %g1
fs->inodes = fs->group_count * fs->group_inodes;
2039af8: 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 =
2039afc: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
2039b00: 7f ff 24 af call 2002dbc <.umul>
2039b04: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
2039b08: 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;
2039b0c: d0 26 60 14 st %o0, [ %i1 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
2039b10: 40 00 86 50 call 205b450 <.udiv>
2039b14: 90 10 00 1a mov %i2, %o0
2039b18: d0 26 60 30 st %o0, [ %i1 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
2039b1c: b5 2e a0 03 sll %i2, 3, %i2
2039b20: 90 10 00 19 mov %i1, %o0
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
2039b24: 80 a6 c0 1a cmp %i3, %i2
2039b28: 08 80 00 0f bleu 2039b64 <rtems_rfs_fs_open+0x4c8> <== ALWAYS TAKEN
2039b2c: 92 07 bf f4 add %fp, -12, %o1
2039b30: 7f ff f4 6f call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039b34: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039b38: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
2039b3c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2039b40: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2039b44: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2039b48: 7f ff a6 d8 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039b4c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039b50: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039b54: 02 80 00 6d be 2039d08 <rtems_rfs_fs_open+0x66c> <== NOT EXECUTED
2039b58: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
2039b5c: 10 80 00 36 b 2039c34 <rtems_rfs_fs_open+0x598> <== NOT EXECUTED
2039b60: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 2067ed0 <__FUNCTION__.7646+0x1248><== 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);
2039b64: 7f ff f4 62 call 2036cec <rtems_rfs_buffer_handle_release>
2039b68: 01 00 00 00 nop
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
2039b6c: d2 06 60 08 ld [ %i1 + 8 ], %o1
handle->dirty = false;
2039b70: c0 2f bf f4 clrb [ %fp + -12 ]
handle->bnum = 0;
2039b74: c0 27 bf f8 clr [ %fp + -8 ]
handle->buffer = NULL;
2039b78: c0 27 bf fc clr [ %fp + -4 ]
2039b7c: 7f ff f6 1a call 20373e4 <rtems_rfs_buffer_setblksize>
2039b80: 90 10 00 19 mov %i1, %o0
if (rc > 0)
2039b84: b6 92 20 00 orcc %o0, 0, %i3
2039b88: 04 80 00 15 ble 2039bdc <rtems_rfs_fs_open+0x540> <== ALWAYS TAKEN
2039b8c: 92 07 bf f4 add %fp, -12, %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);
2039b90: 7f ff f4 57 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039b94: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039b98: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
2039b9c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2039ba0: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2039ba4: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2039ba8: 7f ff a6 c0 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039bac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039bb0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039bb4: 02 80 00 55 be 2039d08 <rtems_rfs_fs_open+0x66c> <== NOT EXECUTED
2039bb8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
2039bbc: 40 00 3c 2f call 2048c78 <strerror> <== NOT EXECUTED
2039bc0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2039bc4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039bc8: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039bcc: 90 12 23 18 or %o0, 0x318, %o0 ! 2067f18 <__FUNCTION__.7646+0x1290><== NOT EXECUTED
2039bd0: 40 00 32 6d call 2046584 <printf> <== NOT EXECUTED
2039bd4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2039bd8: 30 80 00 4c b,a 2039d08 <rtems_rfs_fs_open+0x66c> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
2039bdc: d0 06 60 24 ld [ %i1 + 0x24 ], %o0
2039be0: 7f ff 3a 08 call 2008400 <calloc>
2039be4: 92 10 20 50 mov 0x50, %o1
2039be8: d0 26 60 20 st %o0, [ %i1 + 0x20 ]
if (!fs->groups)
2039bec: ba 10 20 00 clr %i5
2039bf0: 80 a2 20 00 cmp %o0, 0
2039bf4: 12 80 00 3f bne 2039cf0 <rtems_rfs_fs_open+0x654> <== ALWAYS TAKEN
2039bf8: b0 10 20 00 clr %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);
2039bfc: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2039c00: 7f ff f4 3b call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039c04: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039c08: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
2039c0c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2039c10: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2039c14: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2039c18: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039c1c: 7f ff a6 a3 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039c20: b6 10 20 0c mov 0xc, %i3 <== NOT EXECUTED
2039c24: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039c28: 02 80 00 38 be 2039d08 <rtems_rfs_fs_open+0x66c> <== NOT EXECUTED
2039c2c: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
2039c30: 90 12 23 60 or %o0, 0x360, %o0 ! 2067f60 <__FUNCTION__.7646+0x12d8><== NOT EXECUTED
2039c34: 40 00 32 ef call 20467f0 <puts> <== NOT EXECUTED
2039c38: 01 00 00 00 nop <== NOT EXECUTED
2039c3c: 30 80 00 33 b,a 2039d08 <rtems_rfs_fs_open+0x66c> <== 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),
2039c40: 90 10 00 18 mov %i0, %o0
2039c44: 7f ff 24 5e call 2002dbc <.umul>
2039c48: 92 10 00 1b mov %i3, %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,
2039c4c: d8 06 60 20 ld [ %i1 + 0x20 ], %o4
2039c50: d6 06 60 2c ld [ %i1 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
2039c54: 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,
2039c58: 94 10 00 1b mov %i3, %o2
2039c5c: 98 03 00 1d add %o4, %i5, %o4
2039c60: 90 10 00 19 mov %i1, %o0
2039c64: 40 00 04 06 call 203ac7c <rtems_rfs_group_open>
2039c68: ba 07 60 50 add %i5, 0x50, %i5
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
2039c6c: 80 a2 20 00 cmp %o0, 0
2039c70: 04 80 00 1f ble 2039cec <rtems_rfs_fs_open+0x650> <== ALWAYS TAKEN
2039c74: b6 10 00 08 mov %o0, %i3
2039c78: b4 10 20 00 clr %i2 <== NOT EXECUTED
2039c7c: 10 80 00 07 b 2039c98 <rtems_rfs_fs_open+0x5fc> <== NOT EXECUTED
2039c80: ba 10 20 00 clr %i5 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
2039c84: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2039c88: 92 02 40 1a add %o1, %i2, %o1 <== NOT EXECUTED
2039c8c: 40 00 04 7b call 203ae78 <rtems_rfs_group_close> <== NOT EXECUTED
2039c90: ba 07 60 01 inc %i5 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
2039c94: b4 06 a0 50 add %i2, 0x50, %i2 <== NOT EXECUTED
2039c98: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2039c9c: 26 bf ff fa bl,a 2039c84 <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
2039ca0: d2 06 60 20 ld [ %i1 + 0x20 ], %o1 <== 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);
2039ca4: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2039ca8: 7f ff f4 11 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039cac: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039cb0: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
2039cb4: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2039cb8: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2039cbc: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2039cc0: 7f ff a6 7a call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039cc4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039cc8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039ccc: 02 80 00 0f be 2039d08 <rtems_rfs_fs_open+0x66c> <== NOT EXECUTED
2039cd0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
2039cd4: 40 00 3b e9 call 2048c78 <strerror> <== NOT EXECUTED
2039cd8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2039cdc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039ce0: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039ce4: 10 bf ff bb b 2039bd0 <rtems_rfs_fs_open+0x534> <== NOT EXECUTED
2039ce8: 90 12 23 98 or %o0, 0x398, %o0 ! 2067f98 <__FUNCTION__.7646+0x1310><== 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++)
2039cec: b0 06 20 01 inc %i0
2039cf0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2039cf4: 80 a6 00 01 cmp %i0, %g1
2039cf8: 26 bf ff d2 bl,a 2039c40 <rtems_rfs_fs_open+0x5a4>
2039cfc: f6 06 60 28 ld [ %i1 + 0x28 ], %i3
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
2039d00: 10 80 00 6d b 2039eb4 <rtems_rfs_fs_open+0x818>
2039d04: d0 07 00 00 ld [ %i4 ], %o0
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
2039d08: 7f ff f5 f2 call 20374d0 <rtems_rfs_buffer_close> <== NOT EXECUTED
2039d0c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
2039d10: 7f ff 3a 9a call 2008778 <free> <== NOT EXECUTED
2039d14: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039d18: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039d1c: 7f ff a6 63 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039d20: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039d24: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039d28: 02 80 00 09 be 2039d4c <rtems_rfs_fs_open+0x6b0> <== NOT EXECUTED
2039d2c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
2039d30: 40 00 3b d2 call 2048c78 <strerror> <== NOT EXECUTED
2039d34: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2039d38: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2039d3c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039d40: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039d44: 40 00 32 10 call 2046584 <printf> <== NOT EXECUTED
2039d48: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 2067fd8 <__FUNCTION__.7646+0x1350><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
2039d4c: 40 00 1f d5 call 2041ca0 <__errno> <== NOT EXECUTED
2039d50: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2039d54: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
2039d58: 81 c7 e0 08 ret <== NOT EXECUTED
2039d5c: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
2039d60: 7f ff f5 dc call 20374d0 <rtems_rfs_buffer_close> <== NOT EXECUTED
2039d64: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
2039d68: 7f ff 3a 84 call 2008778 <free> <== NOT EXECUTED
2039d6c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039d70: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039d74: 7f ff a6 4d call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039d78: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039d7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039d80: 02 80 00 43 be 2039e8c <rtems_rfs_fs_open+0x7f0> <== NOT EXECUTED
2039d84: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
2039d88: 40 00 3b bc call 2048c78 <strerror> <== NOT EXECUTED
2039d8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2039d90: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039d94: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039d98: 10 80 00 3b b 2039e84 <rtems_rfs_fs_open+0x7e8> <== NOT EXECUTED
2039d9c: 90 12 20 08 or %o0, 8, %o0 ! 2068008 <__FUNCTION__.7646+0x1380><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
2039da0: c2 02 00 00 ld [ %o0 ], %g1
2039da4: 80 88 60 04 btst 4, %g1
2039da8: 12 80 00 23 bne 2039e34 <rtems_rfs_fs_open+0x798>
2039dac: c4 07 bf d8 ld [ %fp + -40 ], %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);
2039db0: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
2039db4: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
2039db8: 83 28 60 08 sll %g1, 8, %g1
2039dbc: 82 10 80 01 or %g2, %g1, %g1
2039dc0: 05 00 00 3f sethi %hi(0xfc00), %g2
2039dc4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
2039dc8: 80 a0 40 02 cmp %g1, %g2
2039dcc: 02 80 00 07 be 2039de8 <rtems_rfs_fs_open+0x74c> <== NEVER TAKEN
2039dd0: 05 00 00 3c sethi %hi(0xf000), %g2
2039dd4: 82 08 40 02 and %g1, %g2, %g1
2039dd8: 05 00 00 10 sethi %hi(0x4000), %g2
2039ddc: 80 a0 40 02 cmp %g1, %g2
2039de0: 02 80 00 15 be 2039e34 <rtems_rfs_fs_open+0x798> <== ALWAYS TAKEN
2039de4: 01 00 00 00 nop
{
rtems_rfs_inode_close (*fs, &inode);
2039de8: 40 00 06 09 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
2039dec: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
2039df0: 7f ff f5 b8 call 20374d0 <rtems_rfs_buffer_close> <== NOT EXECUTED
2039df4: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
2039df8: 7f ff 3a 60 call 2008778 <free> <== NOT EXECUTED
2039dfc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039e00: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039e04: 7f ff a6 29 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039e08: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039e0c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039e10: 02 80 00 04 be 2039e20 <rtems_rfs_fs_open+0x784> <== NOT EXECUTED
2039e14: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
2039e18: 40 00 32 76 call 20467f0 <puts> <== NOT EXECUTED
2039e1c: 90 12 20 38 or %o0, 0x38, %o0 ! 2068038 <__FUNCTION__.7646+0x13b0><== NOT EXECUTED
errno = EIO;
2039e20: 40 00 1f a0 call 2041ca0 <__errno> <== NOT EXECUTED
2039e24: 01 00 00 00 nop <== NOT EXECUTED
2039e28: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2039e2c: 10 80 00 1b b 2039e98 <rtems_rfs_fs_open+0x7fc> <== NOT EXECUTED
2039e30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
2039e34: 40 00 05 f6 call 203b60c <rtems_rfs_inode_close>
2039e38: 92 07 bf cc add %fp, -52, %o1
if (rc > 0)
2039e3c: ba 92 20 00 orcc %o0, 0, %i5
2039e40: 04 80 00 18 ble 2039ea0 <rtems_rfs_fs_open+0x804> <== ALWAYS TAKEN
2039e44: 01 00 00 00 nop
{
rtems_rfs_buffer_close (*fs);
2039e48: 7f ff f5 a2 call 20374d0 <rtems_rfs_buffer_close> <== NOT EXECUTED
2039e4c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
2039e50: 7f ff 3a 4a call 2008778 <free> <== NOT EXECUTED
2039e54: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039e58: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039e5c: 7f ff a6 13 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2039e60: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039e64: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039e68: 02 80 00 09 be 2039e8c <rtems_rfs_fs_open+0x7f0> <== NOT EXECUTED
2039e6c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
2039e70: 40 00 3b 82 call 2048c78 <strerror> <== NOT EXECUTED
2039e74: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2039e78: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039e7c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039e80: 90 12 20 68 or %o0, 0x68, %o0 ! 2068068 <__FUNCTION__.7646+0x13e0><== NOT EXECUTED
2039e84: 40 00 31 c0 call 2046584 <printf> <== NOT EXECUTED
2039e88: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
errno = rc;
2039e8c: 40 00 1f 85 call 2041ca0 <__errno> <== NOT EXECUTED
2039e90: 01 00 00 00 nop <== NOT EXECUTED
2039e94: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
2039e98: 81 c7 e0 08 ret <== NOT EXECUTED
2039e9c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
errno = 0;
2039ea0: 40 00 1f 80 call 2041ca0 <__errno>
2039ea4: b0 10 20 00 clr %i0
2039ea8: c0 22 00 00 clr [ %o0 ]
return 0;
}
2039eac: 81 c7 e0 08 ret
2039eb0: 81 e8 00 00 restore
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
2039eb4: 92 10 20 01 mov 1, %o1
2039eb8: 94 07 bf cc add %fp, -52, %o2
2039ebc: 40 00 05 62 call 203b444 <rtems_rfs_inode_open>
2039ec0: 96 10 20 01 mov 1, %o3
if (rc > 0)
2039ec4: ba 92 20 00 orcc %o0, 0, %i5
2039ec8: 24 bf ff b6 ble,a 2039da0 <rtems_rfs_fs_open+0x704> <== ALWAYS TAKEN
2039ecc: d0 07 00 00 ld [ %i4 ], %o0
2039ed0: 30 bf ff a4 b,a 2039d60 <rtems_rfs_fs_open+0x6c4> <== NOT EXECUTED
02039650 <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)
{
2039650: 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;
2039654: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
2039658: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
203965c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2039660: 40 00 88 d4 call 205b9b0 <__muldi3> <== NOT EXECUTED
2039664: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
2039668: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
203966c: 81 c7 e0 08 ret <== NOT EXECUTED
2039670: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
0203af08 <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)
{
203af08: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
203af0c: 80 a6 a0 00 cmp %i2, 0
203af10: 02 80 00 05 be 203af24 <rtems_rfs_group_bitmap_alloc+0x1c>
203af14: ba 10 00 18 mov %i0, %i5
{
size = fs->group_inodes;
203af18: e4 06 20 2c ld [ %i0 + 0x2c ], %l2
goal -= RTEMS_RFS_ROOT_INO;
203af1c: 10 80 00 03 b 203af28 <rtems_rfs_group_bitmap_alloc+0x20>
203af20: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
203af24: e4 06 20 28 ld [ %i0 + 0x28 ], %l2
group_start = goal / size;
203af28: 90 10 00 19 mov %i1, %o0
203af2c: 40 00 81 49 call 205b450 <.udiv>
203af30: 92 10 00 12 mov %l2, %o1
bit = (rtems_rfs_bitmap_bit) (goal % size);
203af34: 92 10 00 12 mov %l2, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
203af38: a8 10 00 08 mov %o0, %l4
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
203af3c: a2 10 20 01 mov 1, %l1
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
203af40: 90 10 00 19 mov %i1, %o0
203af44: 40 00 81 ef call 205b700 <.urem>
203af48: a0 10 20 00 clr %l0
offset = 0;
updown = true;
direction = 1;
203af4c: b2 10 20 01 mov 1, %i1
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
203af50: 10 80 00 03 b 203af5c <rtems_rfs_group_bitmap_alloc+0x54>
203af54: d0 27 bf f8 st %o0, [ %fp + -8 ]
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
updown = false;
203af58: a2 10 20 00 clr %l1
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
203af5c: c0 2f bf ff clrb [ %fp + -1 ]
/*
* 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);
203af60: 90 10 00 19 mov %i1, %o0
203af64: 7f ff 1f 96 call 2002dbc <.umul>
203af68: 92 10 00 10 mov %l0, %o1
if (offset)
203af6c: 80 a4 20 00 cmp %l0, 0
203af70: 02 80 00 07 be 203af8c <rtems_rfs_group_bitmap_alloc+0x84>
203af74: b8 05 00 08 add %l4, %o0, %i4
bit = direction > 0 ? 0 : size - 1;
203af78: 80 a6 60 01 cmp %i1, 1
203af7c: 02 80 00 03 be 203af88 <rtems_rfs_group_bitmap_alloc+0x80>
203af80: 82 10 20 00 clr %g1
203af84: 82 04 bf ff add %l2, -1, %g1
203af88: c2 27 bf f8 st %g1, [ %fp + -8 ]
/*
* 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))
203af8c: 80 a7 20 00 cmp %i4, 0
203af90: 06 80 00 07 bl 203afac <rtems_rfs_group_bitmap_alloc+0xa4>
203af94: 80 8c 60 ff btst 0xff, %l1
203af98: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
203af9c: 80 a7 00 01 cmp %i4, %g1
203afa0: 26 80 00 09 bl,a 203afc4 <rtems_rfs_group_bitmap_alloc+0xbc>
203afa4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
{
if (!updown)
203afa8: 80 8c 60 ff btst 0xff, %l1
203afac: 02 80 00 4c be 203b0dc <rtems_rfs_group_bitmap_alloc+0x1d4>
203afb0: 80 a6 60 01 cmp %i1, 1
break;
direction = direction > 0 ? -1 : 1;
203afb4: 22 bf ff e9 be,a 203af58 <rtems_rfs_group_bitmap_alloc+0x50><== NEVER TAKEN
203afb8: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
203afbc: 10 bf ff e7 b 203af58 <rtems_rfs_group_bitmap_alloc+0x50>
203afc0: b2 10 20 01 mov 1, %i1
203afc4: a7 2f 20 04 sll %i4, 4, %l3
203afc8: 85 2f 20 06 sll %i4, 6, %g2
updown = false;
continue;
}
if (inode)
203afcc: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
203afd0: a6 04 c0 02 add %l3, %g2, %l3
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
203afd4: 02 80 00 04 be 203afe4 <rtems_rfs_group_bitmap_alloc+0xdc>
203afd8: a6 00 40 13 add %g1, %l3, %l3
bitmap = &fs->groups[group].inode_bitmap;
203afdc: 10 80 00 03 b 203afe8 <rtems_rfs_group_bitmap_alloc+0xe0>
203afe0: a6 04 e0 2c add %l3, 0x2c, %l3
else
bitmap = &fs->groups[group].block_bitmap;
203afe4: a6 04 e0 08 add %l3, 8, %l3
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
203afe8: d2 07 bf f8 ld [ %fp + -8 ], %o1
203afec: 90 10 00 13 mov %l3, %o0
203aff0: 94 07 bf ff add %fp, -1, %o2
203aff4: 40 00 18 e1 call 2041378 <rtems_rfs_bitmap_map_alloc>
203aff8: 96 07 bf f8 add %fp, -8, %o3
if (rc > 0)
203affc: b0 92 20 00 orcc %o0, 0, %i0
203b000: 14 80 00 40 bg 203b100 <rtems_rfs_group_bitmap_alloc+0x1f8><== NEVER TAKEN
203b004: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
203b008: c2 07 40 00 ld [ %i5 ], %g1
203b00c: 80 88 60 01 btst 1, %g1
203b010: 12 80 00 06 bne 203b028 <rtems_rfs_group_bitmap_alloc+0x120><== NEVER TAKEN
203b014: c2 0f bf ff ldub [ %fp + -1 ], %g1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b018: d2 04 c0 00 ld [ %l3 ], %o1
203b01c: 7f ff ef 34 call 2036cec <rtems_rfs_buffer_handle_release>
203b020: 90 10 00 1d mov %i5, %o0
if (allocated)
203b024: c2 0f bf ff ldub [ %fp + -1 ], %g1
203b028: 80 a0 60 00 cmp %g1, 0
203b02c: 02 80 00 25 be 203b0c0 <rtems_rfs_group_bitmap_alloc+0x1b8>
203b030: 80 8c 60 ff btst 0xff, %l1
{
if (inode)
203b034: 80 a6 a0 00 cmp %i2, 0
203b038: 02 80 00 08 be 203b058 <rtems_rfs_group_bitmap_alloc+0x150>
203b03c: f2 07 bf f8 ld [ %fp + -8 ], %i1
*result = rtems_rfs_group_inode (fs, group, bit);
203b040: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
203b044: b2 06 60 01 inc %i1
203b048: 7f ff 1f 5d call 2002dbc <.umul>
203b04c: 90 10 00 1c mov %i4, %o0
203b050: 10 80 00 08 b 203b070 <rtems_rfs_group_bitmap_alloc+0x168>
203b054: b2 06 40 08 add %i1, %o0, %i1
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
203b058: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
203b05c: 85 2f 20 04 sll %i4, 4, %g2
203b060: b9 2f 20 06 sll %i4, 6, %i4
203b064: b8 00 80 1c add %g2, %i4, %i4
203b068: c2 00 40 1c ld [ %g1 + %i4 ], %g1
203b06c: b2 06 40 01 add %i1, %g1, %i1
203b070: f2 26 c0 00 st %i1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
203b074: 90 10 20 00 clr %o0
203b078: 13 00 00 80 sethi %hi(0x20000), %o1
203b07c: 7f ff a1 8b call 20236a8 <rtems_rfs_trace>
203b080: b0 10 20 00 clr %i0
203b084: 80 8a 20 ff btst 0xff, %o0
203b088: 02 80 00 0c be 203b0b8 <rtems_rfs_group_bitmap_alloc+0x1b0><== ALWAYS TAKEN
203b08c: 13 00 81 8c sethi %hi(0x2063000), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
203b090: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
203b094: 02 80 00 04 be 203b0a4 <rtems_rfs_group_bitmap_alloc+0x19c><== NOT EXECUTED
203b098: 92 12 61 90 or %o1, 0x190, %o1 <== NOT EXECUTED
203b09c: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b0a0: 92 12 62 a0 or %o1, 0x2a0, %o1 ! 20632a0 <rtems_rfs_rtems_eval_config+0x920><== NOT EXECUTED
203b0a4: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
203b0a8: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
203b0ac: 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",
203b0b0: 40 00 2d 35 call 2046584 <printf> <== NOT EXECUTED
203b0b4: 90 12 22 b0 or %o0, 0x2b0, %o0 <== NOT EXECUTED
203b0b8: 81 c7 e0 08 ret
203b0bc: 81 e8 00 00 restore
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
203b0c0: 02 bf ff a7 be 203af5c <rtems_rfs_group_bitmap_alloc+0x54><== NEVER TAKEN
203b0c4: a0 04 20 01 inc %l0
direction = direction > 0 ? -1 : 1;
203b0c8: b2 1e 60 01 xor %i1, 1, %i1
203b0cc: 80 a0 00 19 cmp %g0, %i1
203b0d0: b2 40 3f ff addx %g0, -1, %i1
203b0d4: 10 bf ff a2 b 203af5c <rtems_rfs_group_bitmap_alloc+0x54>
203b0d8: b2 16 60 01 or %i1, 1, %i1
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
203b0dc: 90 10 20 00 clr %o0
203b0e0: 13 00 00 80 sethi %hi(0x20000), %o1
203b0e4: 7f ff a1 71 call 20236a8 <rtems_rfs_trace>
203b0e8: b0 10 20 1c mov 0x1c, %i0
203b0ec: 80 8a 20 ff btst 0xff, %o0
203b0f0: 02 bf ff f2 be 203b0b8 <rtems_rfs_group_bitmap_alloc+0x1b0><== ALWAYS TAKEN
203b0f4: 11 00 81 a2 sethi %hi(0x2068800), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
203b0f8: 40 00 2d be call 20467f0 <puts> <== NOT EXECUTED
203b0fc: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 2068ae8 <__FUNCTION__.7646+0x1e60><== NOT EXECUTED
return ENOSPC;
}
203b100: 81 c7 e0 08 ret <== NOT EXECUTED
203b104: 81 e8 00 00 restore <== NOT EXECUTED
0203b108 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
203b108: 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))
203b10c: 90 10 20 00 clr %o0
203b110: 13 00 00 80 sethi %hi(0x20000), %o1
203b114: 7f ff a1 65 call 20236a8 <rtems_rfs_trace>
203b118: ba 10 00 18 mov %i0, %i5
203b11c: 80 8a 20 ff btst 0xff, %o0
203b120: 02 80 00 0c be 203b150 <rtems_rfs_group_bitmap_free+0x48> <== ALWAYS TAKEN
203b124: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
203b128: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b12c: 02 80 00 04 be 203b13c <rtems_rfs_group_bitmap_free+0x34> <== NOT EXECUTED
203b130: 92 12 61 90 or %o1, 0x190, %o1 ! 2063190 <rtems_rfs_rtems_eval_config+0x810><== NOT EXECUTED
203b134: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b138: 92 12 62 a0 or %o1, 0x2a0, %o1 ! 20632a0 <rtems_rfs_rtems_eval_config+0x920><== NOT EXECUTED
203b13c: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203b140: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203b144: 40 00 2d 10 call 2046584 <printf> <== NOT EXECUTED
203b148: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
203b14c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
203b150: 02 80 00 04 be 203b160 <rtems_rfs_group_bitmap_free+0x58>
203b154: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
203b158: 10 80 00 03 b 203b164 <rtems_rfs_group_bitmap_free+0x5c>
203b15c: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
203b160: f8 07 60 28 ld [ %i5 + 0x28 ], %i4
}
group = no / size;
203b164: 90 10 00 1a mov %i2, %o0
203b168: 40 00 80 ba call 205b450 <.udiv>
203b16c: 92 10 00 1c mov %i4, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
203b170: 92 10 00 1c mov %i4, %o1
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
203b174: b6 10 00 08 mov %o0, %i3
bit = (rtems_rfs_bitmap_bit) (no % size);
203b178: 40 00 81 62 call 205b700 <.urem>
203b17c: 90 10 00 1a mov %i2, %o0
203b180: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
203b184: b5 2e e0 04 sll %i3, 4, %i2
203b188: 92 10 00 08 mov %o0, %o1
203b18c: b7 2e e0 06 sll %i3, 6, %i3
if (inode)
203b190: 80 a6 60 00 cmp %i1, 0
bitmap = &fs->groups[group].inode_bitmap;
203b194: b4 06 80 1b add %i2, %i3, %i2
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
203b198: 02 80 00 04 be 203b1a8 <rtems_rfs_group_bitmap_free+0xa0>
203b19c: b4 00 40 1a add %g1, %i2, %i2
bitmap = &fs->groups[group].inode_bitmap;
203b1a0: 10 80 00 03 b 203b1ac <rtems_rfs_group_bitmap_free+0xa4>
203b1a4: b4 06 a0 2c add %i2, 0x2c, %i2
else
bitmap = &fs->groups[group].block_bitmap;
203b1a8: b4 06 a0 08 add %i2, 8, %i2
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
203b1ac: 40 00 17 e8 call 204114c <rtems_rfs_bitmap_map_clear>
203b1b0: 90 10 00 1a mov %i2, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b1b4: d2 06 80 00 ld [ %i2 ], %o1
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
203b1b8: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b1bc: 7f ff ee cc call 2036cec <rtems_rfs_buffer_handle_release>
203b1c0: 90 10 00 1d mov %i5, %o0
return rc;
}
203b1c4: 81 c7 e0 08 ret
203b1c8: 81 e8 00 00 restore
0203b1cc <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)
{
203b1cc: 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))
203b1d0: 90 10 20 00 clr %o0 <== NOT EXECUTED
203b1d4: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
203b1d8: 7f ff a1 34 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203b1dc: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
203b1e0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203b1e4: 02 80 00 0c be 203b214 <rtems_rfs_group_bitmap_test+0x48> <== NOT EXECUTED
203b1e8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
203b1ec: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b1f0: 02 80 00 04 be 203b200 <rtems_rfs_group_bitmap_test+0x34> <== NOT EXECUTED
203b1f4: 92 12 61 90 or %o1, 0x190, %o1 ! 2063190 <rtems_rfs_rtems_eval_config+0x810><== NOT EXECUTED
203b1f8: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b1fc: 92 12 62 a0 or %o1, 0x2a0, %o1 ! 20632a0 <rtems_rfs_rtems_eval_config+0x920><== NOT EXECUTED
203b200: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203b204: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203b208: 40 00 2c df call 2046584 <printf> <== NOT EXECUTED
203b20c: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
203b210: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
203b214: 22 80 00 0b be,a 203b240 <rtems_rfs_group_bitmap_test+0x74><== NOT EXECUTED
203b218: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
203b21c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
203b220: 04 80 00 25 ble 203b2b4 <rtems_rfs_group_bitmap_test+0xe8><== NOT EXECUTED
203b224: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
203b228: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
203b22c: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
203b230: 18 80 00 21 bgu 203b2b4 <rtems_rfs_group_bitmap_test+0xe8><== NOT EXECUTED
203b234: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
203b238: 10 80 00 06 b 203b250 <rtems_rfs_group_bitmap_test+0x84> <== NOT EXECUTED
203b23c: f0 07 60 2c ld [ %i5 + 0x2c ], %i0 <== NOT EXECUTED
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
203b240: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
203b244: 1a 80 00 1c bcc 203b2b4 <rtems_rfs_group_bitmap_test+0xe8><== NOT EXECUTED
203b248: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
203b24c: f0 07 60 28 ld [ %i5 + 0x28 ], %i0 <== NOT EXECUTED
}
group = no / size;
203b250: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203b254: 40 00 80 7f call 205b450 <.udiv> <== NOT EXECUTED
203b258: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
203b25c: 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;
203b260: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
203b264: 40 00 81 27 call 205b700 <.urem> <== NOT EXECUTED
203b268: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203b26c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
203b270: b5 2f 20 04 sll %i4, 4, %i2 <== NOT EXECUTED
203b274: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203b278: b9 2f 20 06 sll %i4, 6, %i4 <== NOT EXECUTED
if (inode)
203b27c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
203b280: b4 06 80 1c add %i2, %i4, %i2 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
203b284: 02 80 00 04 be 203b294 <rtems_rfs_group_bitmap_test+0xc8> <== NOT EXECUTED
203b288: b4 00 40 1a add %g1, %i2, %i2 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
203b28c: 10 80 00 03 b 203b298 <rtems_rfs_group_bitmap_test+0xcc> <== NOT EXECUTED
203b290: b4 06 a0 2c add %i2, 0x2c, %i2 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
203b294: b4 06 a0 08 add %i2, 8, %i2 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
203b298: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203b29c: 40 00 17 ce call 20411d4 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
203b2a0: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b2a4: d2 06 80 00 ld [ %i2 ], %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);
203b2a8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b2ac: 7f ff ee 90 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203b2b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
203b2b4: 81 c7 e0 08 ret <== NOT EXECUTED
203b2b8: 81 e8 00 00 restore <== NOT EXECUTED
0203ae78 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
203ae78: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
203ae7c: 90 10 20 00 clr %o0
203ae80: 13 00 00 40 sethi %hi(0x10000), %o1
203ae84: 7f ff a2 09 call 20236a8 <rtems_rfs_trace>
203ae88: ba 10 00 18 mov %i0, %i5
203ae8c: 80 8a 20 ff btst 0xff, %o0
203ae90: 02 80 00 06 be 203aea8 <rtems_rfs_group_close+0x30> <== ALWAYS TAKEN
203ae94: 01 00 00 00 nop
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
203ae98: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
203ae9c: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203aea0: 40 00 2d b9 call 2046584 <printf> <== NOT EXECUTED
203aea4: 90 12 22 88 or %o0, 0x288, %o0 ! 2068a88 <__FUNCTION__.7646+0x1e00><== 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);
203aea8: 40 00 19 b5 call 204157c <rtems_rfs_bitmap_close>
203aeac: 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);
203aeb0: 92 06 60 44 add %i1, 0x44, %o1
203aeb4: b8 10 00 08 mov %o0, %i4
203aeb8: 7f ff ef 8d call 2036cec <rtems_rfs_buffer_handle_release>
203aebc: 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);
203aec0: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
203aec4: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
203aec8: c0 26 60 48 clr [ %i1 + 0x48 ]
203aecc: 40 00 19 ac call 204157c <rtems_rfs_bitmap_close>
203aed0: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
203aed4: b0 92 20 00 orcc %o0, 0, %i0
203aed8: 14 80 00 05 bg 203aeec <rtems_rfs_group_close+0x74> <== NEVER TAKEN
203aedc: 90 10 00 1d mov %i5, %o0
203aee0: b0 38 00 1c xnor %g0, %i4, %i0
203aee4: b1 3e 20 1f sra %i0, 0x1f, %i0
203aee8: 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);
203aeec: 7f ff ef 80 call 2036cec <rtems_rfs_buffer_handle_release>
203aef0: 92 06 60 20 add %i1, 0x20, %o1
handle->dirty = false;
203aef4: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
203aef8: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
203aefc: 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;
}
203af00: 81 c7 e0 08 ret
203af04: 81 e8 00 00 restore
0203ac7c <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)
{
203ac7c: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
203ac80: c2 06 20 04 ld [ %i0 + 4 ], %g1
203ac84: 80 a6 40 01 cmp %i1, %g1
203ac88: 0a 80 00 10 bcs 203acc8 <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
203ac8c: ba 10 00 18 mov %i0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
203ac90: 90 10 20 00 clr %o0 <== NOT EXECUTED
203ac94: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
203ac98: 7f ff a2 84 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203ac9c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203aca0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203aca4: 02 80 00 73 be 203ae70 <rtems_rfs_group_open+0x1f4> <== NOT EXECUTED
203aca8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
203acac: 40 00 37 f3 call 2048c78 <strerror> <== NOT EXECUTED
203acb0: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
203acb4: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
203acb8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203acbc: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203acc0: 10 80 00 5e b 203ae38 <rtems_rfs_group_open+0x1bc> <== NOT EXECUTED
203acc4: 90 12 21 90 or %o0, 0x190, %o0 ! 2068990 <__FUNCTION__.7646+0x1d08><== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
203acc8: 84 06 80 19 add %i2, %i1, %g2
203accc: 80 a0 80 01 cmp %g2, %g1
203acd0: 3a 80 00 02 bcc,a 203acd8 <rtems_rfs_group_open+0x5c> <== ALWAYS TAKEN
203acd4: b4 20 40 19 sub %g1, %i1, %i2
size = rtems_rfs_fs_blocks (fs) - base;
203acd8: 80 a6 80 1b cmp %i2, %i3
203acdc: 08 80 00 03 bleu 203ace8 <rtems_rfs_group_open+0x6c> <== NEVER TAKEN
203ace0: a0 10 00 1a mov %i2, %l0
203ace4: 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))
203ace8: 90 10 20 00 clr %o0
203acec: 7f ff a2 6f call 20236a8 <rtems_rfs_trace>
203acf0: 13 00 00 20 sethi %hi(0x8000), %o1
203acf4: 80 8a 20 ff btst 0xff, %o0
203acf8: 22 80 00 09 be,a 203ad1c <rtems_rfs_group_open+0xa0> <== ALWAYS TAKEN
203acfc: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
203ad00: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ad04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203ad08: 90 12 21 d0 or %o0, 0x1d0, %o0 <== NOT EXECUTED
203ad0c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203ad10: 40 00 2e 1d call 2046584 <printf> <== NOT EXECUTED
203ad14: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
base, size, inodes);
group->base = base;
203ad18: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
203ad1c: 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;
203ad20: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
203ad24: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
203ad28: 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,
203ad2c: a2 07 20 08 add %i4, 8, %l1
203ad30: b6 07 20 20 add %i4, 0x20, %i3
203ad34: 90 10 00 11 mov %l1, %o0
203ad38: 92 10 00 1d mov %i5, %o1
203ad3c: 94 10 00 1b mov %i3, %o2
203ad40: 96 10 00 1a mov %i2, %o3
203ad44: 40 00 19 fd call 2041538 <rtems_rfs_bitmap_open>
203ad48: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
203ad4c: b0 92 20 00 orcc %o0, 0, %i0
203ad50: 04 80 00 13 ble 203ad9c <rtems_rfs_group_open+0x120> <== ALWAYS TAKEN
203ad54: 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);
203ad58: 7f ff ef e5 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203ad5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
203ad60: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
203ad64: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
203ad68: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
203ad6c: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
203ad70: 7f ff a2 4e call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203ad74: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
203ad78: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203ad7c: 02 80 00 3d be 203ae70 <rtems_rfs_group_open+0x1f4> <== NOT EXECUTED
203ad80: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
203ad84: 40 00 37 bd call 2048c78 <strerror> <== NOT EXECUTED
203ad88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203ad8c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ad90: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ad94: 10 80 00 28 b 203ae34 <rtems_rfs_group_open+0x1b8> <== NOT EXECUTED
203ad98: 90 12 22 08 or %o0, 0x208, %o0 ! 2068a08 <__FUNCTION__.7646+0x1d80><== 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,
203ad9c: 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;
203ada0: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
203ada4: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
203ada8: c0 27 20 4c clr [ %i4 + 0x4c ]
203adac: b4 07 20 44 add %i4, 0x44, %i2
203adb0: 90 07 20 2c add %i4, 0x2c, %o0
203adb4: 92 10 00 1d mov %i5, %o1
203adb8: 94 10 00 1a mov %i2, %o2
203adbc: 96 10 00 10 mov %l0, %o3
203adc0: 40 00 19 de call 2041538 <rtems_rfs_bitmap_open>
203adc4: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
203adc8: b0 92 20 00 orcc %o0, 0, %i0
203adcc: 04 80 00 1f ble 203ae48 <rtems_rfs_group_open+0x1cc> <== ALWAYS TAKEN
203add0: 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);
203add4: 7f ff ef c6 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203add8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
203addc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
203ade0: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
203ade4: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
203ade8: 40 00 19 e5 call 204157c <rtems_rfs_bitmap_close> <== NOT EXECUTED
203adec: 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);
203adf0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203adf4: 7f ff ef be call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203adf8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
203adfc: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
203ae00: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
203ae04: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
203ae08: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
203ae0c: 7f ff a2 27 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203ae10: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
203ae14: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203ae18: 02 80 00 16 be 203ae70 <rtems_rfs_group_open+0x1f4> <== NOT EXECUTED
203ae1c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
203ae20: 40 00 37 96 call 2048c78 <strerror> <== NOT EXECUTED
203ae24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203ae28: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ae2c: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ae30: 90 12 22 48 or %o0, 0x248, %o0 ! 2068a48 <__FUNCTION__.7646+0x1dc0><== NOT EXECUTED
203ae34: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
203ae38: 40 00 2d d3 call 2046584 <printf> <== NOT EXECUTED
203ae3c: 01 00 00 00 nop <== NOT EXECUTED
203ae40: 81 c7 e0 08 ret <== NOT EXECUTED
203ae44: 81 e8 00 00 restore <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
203ae48: c2 07 40 00 ld [ %i5 ], %g1
203ae4c: 80 88 60 01 btst 1, %g1
203ae50: 12 bf ff fc bne 203ae40 <rtems_rfs_group_open+0x1c4> <== NEVER TAKEN
203ae54: b0 10 20 00 clr %i0
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
203ae58: d2 07 20 08 ld [ %i4 + 8 ], %o1
203ae5c: 7f ff ef a4 call 2036cec <rtems_rfs_buffer_handle_release>
203ae60: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
203ae64: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
203ae68: 7f ff ef a1 call 2036cec <rtems_rfs_buffer_handle_release>
203ae6c: 90 10 00 1d mov %i5, %o0
}
return 0;
}
203ae70: 81 c7 e0 08 ret
203ae74: 81 e8 00 00 restore
0203b2bc <rtems_rfs_group_usage>:
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
203b2bc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int g;
*blocks = 0;
203b2c0: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
*inodes = 0;
203b2c4: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
203b2c8: 86 10 20 00 clr %g3 <== NOT EXECUTED
203b2cc: 10 80 00 11 b 203b310 <rtems_rfs_group_usage+0x54> <== NOT EXECUTED
203b2d0: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
203b2d4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
203b2d8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
203b2dc: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
203b2e0: da 00 60 14 ld [ %g1 + 0x14 ], %o5 <== NOT EXECUTED
203b2e4: de 00 60 18 ld [ %g1 + 0x18 ], %o7 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
203b2e8: 86 00 e0 50 add %g3, 0x50, %g3 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
203b2ec: 9e 23 40 0f sub %o5, %o7, %o7 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
203b2f0: 88 01 00 0f add %g4, %o7, %g4 <== NOT EXECUTED
203b2f4: c8 26 40 00 st %g4, [ %i1 ] <== 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) -
203b2f8: c8 00 60 38 ld [ %g1 + 0x38 ], %g4 <== NOT EXECUTED
203b2fc: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED
203b300: 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 +=
203b304: c8 06 80 00 ld [ %i2 ], %g4 <== NOT EXECUTED
203b308: 82 01 00 01 add %g4, %g1, %g1 <== NOT EXECUTED
203b30c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
203b310: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
203b314: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
203b318: 06 bf ff ef bl 203b2d4 <rtems_rfs_group_usage+0x18> <== NOT EXECUTED
203b31c: c8 06 40 00 ld [ %i1 ], %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))
203b320: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED
203b324: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
203b328: 08 80 00 03 bleu 203b334 <rtems_rfs_group_usage+0x78> <== NOT EXECUTED
203b32c: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
203b330: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
203b334: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
203b338: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
203b33c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
203b340: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203b344: 38 80 00 02 bgu,a 203b34c <rtems_rfs_group_usage+0x90> <== NOT EXECUTED
203b348: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
203b34c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
203b350: 81 c7 e0 08 ret <== NOT EXECUTED
203b354: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0203b60c <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
203b60c: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
203b610: 90 10 20 00 clr %o0
203b614: 7f ff a0 25 call 20236a8 <rtems_rfs_trace>
203b618: 13 00 02 00 sethi %hi(0x80000), %o1
203b61c: 80 8a 20 ff btst 0xff, %o0
203b620: 22 80 00 07 be,a 203b63c <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
203b624: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
203b628: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203b62c: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b630: 40 00 2b d5 call 2046584 <printf> <== NOT EXECUTED
203b634: 90 12 20 18 or %o0, 0x18, %o0 ! 2068c18 <__FUNCTION__.7646+0x1f90><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
203b638: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203b63c: 92 10 00 19 mov %i1, %o1
203b640: 7f ff ff b7 call 203b51c <rtems_rfs_inode_unload>
203b644: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
203b648: b0 92 20 00 orcc %o0, 0, %i0
203b64c: 32 80 00 11 bne,a 203b690 <rtems_rfs_inode_close+0x84> <== NEVER TAKEN
203b650: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
203b654: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
203b658: 80 a0 60 00 cmp %g1, 0
203b65c: 04 80 00 0c ble 203b68c <rtems_rfs_inode_close+0x80> <== ALWAYS TAKEN
203b660: 13 00 02 00 sethi %hi(0x80000), %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
203b664: 90 10 20 00 clr %o0 <== NOT EXECUTED
203b668: 7f ff a0 10 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203b66c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203b670: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203b674: 22 80 00 07 be,a 203b690 <rtems_rfs_inode_close+0x84> <== NOT EXECUTED
203b678: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
203b67c: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
203b680: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b684: 40 00 2b c0 call 2046584 <printf> <== NOT EXECUTED
203b688: 90 12 20 40 or %o0, 0x40, %o0 ! 2068c40 <__FUNCTION__.7646+0x1fb8><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
203b68c: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
203b690: 81 c7 e0 08 ret
203b694: 81 e8 00 00 restore
0203b964 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
203b964: 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))
203b968: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
203b96c: e2 07 a0 64 ld [ %fp + 0x64 ], %l1
203b970: e6 17 a0 5e lduh [ %fp + 0x5e ], %l3
203b974: e4 17 a0 62 lduh [ %fp + 0x62 ], %l2
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
203b978: 7f ff 9f 4c call 20236a8 <rtems_rfs_trace>
203b97c: 13 00 10 00 sethi %hi(0x400000), %o1
203b980: 80 8a 20 ff btst 0xff, %o0
203b984: 02 80 00 32 be 203ba4c <rtems_rfs_inode_create+0xe8> <== ALWAYS TAKEN
203b988: 21 00 00 3c sethi %hi(0xf000), %l0
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
203b98c: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
type = "dir";
203b990: 21 00 81 80 sethi %hi(0x2060000), %l0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
203b994: 82 0f 00 01 and %i4, %g1, %g1 <== NOT EXECUTED
203b998: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
203b99c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203b9a0: 02 80 00 18 be 203ba00 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
203b9a4: a0 14 23 d0 or %l0, 0x3d0, %l0 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
203b9a8: 21 00 81 a3 sethi %hi(0x2068c00), %l0 <== NOT EXECUTED
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
203b9ac: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
203b9b0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203b9b4: 02 80 00 13 be 203ba00 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
203b9b8: a0 14 20 a0 or %l0, 0xa0, %l0 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
203b9bc: 21 00 81 8c sethi %hi(0x2063000), %l0 <== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
203b9c0: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
203b9c4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203b9c8: 02 80 00 0e be 203ba00 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
203b9cc: a0 14 21 90 or %l0, 0x190, %l0 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
203b9d0: 21 00 81 89 sethi %hi(0x2062400), %l0 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
203b9d4: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
203b9d8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203b9dc: 02 80 00 09 be 203ba00 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
203b9e0: a0 14 20 d8 or %l0, 0xd8, %l0 <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
203b9e4: 21 00 81 8d sethi %hi(0x2063400), %l0 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
203b9e8: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
203b9ec: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203b9f0: 02 80 00 04 be 203ba00 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
203b9f4: a0 14 22 30 or %l0, 0x230, %l0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
203b9f8: 21 00 81 a3 sethi %hi(0x2068c00), %l0 <== NOT EXECUTED
203b9fc: a0 14 20 a8 or %l0, 0xa8, %l0 ! 2068ca8 <__FUNCTION__.7646+0x2020><== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
203ba00: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203ba04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203ba08: 90 12 20 b0 or %o0, 0xb0, %o0 <== NOT EXECUTED
203ba0c: 40 00 2a de call 2046584 <printf> <== NOT EXECUTED
203ba10: a8 10 20 00 clr %l4 <== NOT EXECUTED
for (c = 0; c < length; c++)
203ba14: 10 80 00 05 b 203ba28 <rtems_rfs_inode_create+0xc4> <== NOT EXECUTED
203ba18: 80 a5 00 1b cmp %l4, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
203ba1c: 40 00 2b 47 call 2046738 <putchar> <== NOT EXECUTED
203ba20: a8 05 20 01 inc %l4 <== 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++)
203ba24: 80 a5 00 1b cmp %l4, %i3 <== NOT EXECUTED
203ba28: 32 bf ff fd bne,a 203ba1c <rtems_rfs_inode_create+0xb8> <== NOT EXECUTED
203ba2c: d0 4e 80 14 ldsb [ %i2 + %l4 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
203ba30: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203ba34: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203ba38: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
203ba3c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203ba40: 40 00 2a d1 call 2046584 <printf> <== NOT EXECUTED
203ba44: 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)
203ba48: 21 00 00 3c sethi %hi(0xf000), %l0 <== NOT EXECUTED
203ba4c: 03 00 00 18 sethi %hi(0x6000), %g1
203ba50: a0 0f 00 10 and %i4, %l0, %l0
203ba54: 80 a4 00 01 cmp %l0, %g1
203ba58: 02 80 00 11 be 203ba9c <rtems_rfs_inode_create+0x138> <== NEVER TAKEN
203ba5c: 90 10 00 18 mov %i0, %o0
203ba60: 14 80 00 08 bg 203ba80 <rtems_rfs_inode_create+0x11c>
203ba64: 03 00 00 20 sethi %hi(0x8000), %g1
203ba68: 03 00 00 08 sethi %hi(0x2000), %g1
203ba6c: 80 a4 00 01 cmp %l0, %g1
203ba70: 02 80 00 0b be 203ba9c <rtems_rfs_inode_create+0x138> <== NEVER TAKEN
203ba74: 03 00 00 10 sethi %hi(0x4000), %g1
203ba78: 10 80 00 06 b 203ba90 <rtems_rfs_inode_create+0x12c>
203ba7c: 80 a4 00 01 cmp %l0, %g1
203ba80: 80 a4 00 01 cmp %l0, %g1
203ba84: 02 80 00 05 be 203ba98 <rtems_rfs_inode_create+0x134>
203ba88: 03 00 00 28 sethi %hi(0xa000), %g1
203ba8c: 80 a4 00 01 cmp %l0, %g1
203ba90: 12 80 00 80 bne 203bc90 <rtems_rfs_inode_create+0x32c> <== NEVER TAKEN
203ba94: a8 10 20 16 mov 0x16, %l4
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
203ba98: 90 10 00 18 mov %i0, %o0
203ba9c: 92 10 00 19 mov %i1, %o1
203baa0: 7f ff fe 2e call 203b358 <rtems_rfs_inode_alloc>
203baa4: 94 10 00 11 mov %l1, %o2
if (rc > 0)
203baa8: a8 92 20 00 orcc %o0, 0, %l4
203baac: 34 80 00 7a bg,a 203bc94 <rtems_rfs_inode_create+0x330>
203bab0: b0 10 00 14 mov %l4, %i0
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
203bab4: d2 04 40 00 ld [ %l1 ], %o1
203bab8: 90 10 00 18 mov %i0, %o0
203babc: 94 07 bf d8 add %fp, -40, %o2
203bac0: 7f ff fe 61 call 203b444 <rtems_rfs_inode_open>
203bac4: 96 10 20 01 mov 1, %o3
if (rc > 0)
203bac8: a8 92 20 00 orcc %o0, 0, %l4
203bacc: 34 80 00 6d bg,a 203bc80 <rtems_rfs_inode_create+0x31c> <== NEVER TAKEN
203bad0: 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);
203bad4: 90 07 bf d8 add %fp, -40, %o0
203bad8: 92 10 00 1d mov %i5, %o1
203badc: 94 10 00 1c mov %i4, %o2
203bae0: 96 10 00 13 mov %l3, %o3
203bae4: 7f ff ff 4a call 203b80c <rtems_rfs_inode_initialise>
203bae8: 98 10 00 12 mov %l2, %o4
if (rc > 0)
203baec: a8 92 20 00 orcc %o0, 0, %l4
203baf0: 04 80 00 07 ble 203bb0c <rtems_rfs_inode_create+0x1a8> <== ALWAYS TAKEN
203baf4: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_close (fs, &inode);
203baf8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203bafc: 7f ff fe c4 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203bb00: 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);
203bb04: 10 80 00 5f b 203bc80 <rtems_rfs_inode_create+0x31c> <== NOT EXECUTED
203bb08: 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))
203bb0c: 80 a4 00 01 cmp %l0, %g1
203bb10: 12 80 00 17 bne 203bb6c <rtems_rfs_inode_create+0x208>
203bb14: 90 10 00 18 mov %i0, %o0
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
203bb18: d8 04 40 00 ld [ %l1 ], %o4
203bb1c: 92 07 bf d8 add %fp, -40, %o1
203bb20: 15 00 81 81 sethi %hi(0x2060400), %o2
203bb24: 96 10 20 01 mov 1, %o3
203bb28: 7f ff ef e0 call 2037aa8 <rtems_rfs_dir_add_entry>
203bb2c: 94 12 a3 60 or %o2, 0x360, %o2
if (rc == 0)
203bb30: a8 92 20 00 orcc %o0, 0, %l4
203bb34: 12 80 00 0b bne 203bb60 <rtems_rfs_inode_create+0x1fc> <== NEVER TAKEN
203bb38: 80 a5 20 00 cmp %l4, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
203bb3c: 90 10 00 18 mov %i0, %o0
203bb40: 92 07 bf d8 add %fp, -40, %o1
203bb44: 15 00 81 80 sethi %hi(0x2060000), %o2
203bb48: 96 10 20 02 mov 2, %o3
203bb4c: 94 12 a0 80 or %o2, 0x80, %o2
203bb50: 7f ff ef d6 call 2037aa8 <rtems_rfs_dir_add_entry>
203bb54: 98 10 00 19 mov %i1, %o4
203bb58: a8 10 00 08 mov %o0, %l4
if (rc > 0)
203bb5c: 80 a5 20 00 cmp %l4, 0
203bb60: 14 80 00 0b bg 203bb8c <rtems_rfs_inode_create+0x228> <== NEVER TAKEN
203bb64: 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);
203bb68: 90 10 00 18 mov %i0, %o0
203bb6c: 92 10 00 19 mov %i1, %o1
203bb70: 94 07 bf b0 add %fp, -80, %o2
203bb74: 7f ff fe 34 call 203b444 <rtems_rfs_inode_open>
203bb78: 96 10 20 01 mov 1, %o3
203bb7c: a8 10 00 08 mov %o0, %l4
if (rc > 0)
203bb80: 80 a5 20 00 cmp %l4, 0
203bb84: 04 80 00 04 ble 203bb94 <rtems_rfs_inode_create+0x230> <== ALWAYS TAKEN
203bb88: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
203bb8c: 10 80 00 30 b 203bc4c <rtems_rfs_inode_create+0x2e8> <== NOT EXECUTED
203bb90: 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);
203bb94: d8 04 40 00 ld [ %l1 ], %o4
203bb98: 92 07 bf b0 add %fp, -80, %o1
203bb9c: 94 10 00 1a mov %i2, %o2
203bba0: 7f ff ef c2 call 2037aa8 <rtems_rfs_dir_add_entry>
203bba4: 96 10 00 1b mov %i3, %o3
if (rc > 0)
203bba8: a8 92 20 00 orcc %o0, 0, %l4
203bbac: 04 80 00 0b ble 203bbd8 <rtems_rfs_inode_create+0x274> <== ALWAYS TAKEN
203bbb0: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_delete (fs, &inode);
203bbb4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203bbb8: 7f ff fe b8 call 203b698 <rtems_rfs_inode_delete> <== NOT EXECUTED
203bbbc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
203bbc0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203bbc4: 7f ff fe 92 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203bbc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
203bbcc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203bbd0: 10 80 00 23 b 203bc5c <rtems_rfs_inode_create+0x2f8> <== NOT EXECUTED
203bbd4: 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))
203bbd8: 80 a4 00 01 cmp %l0, %g1
203bbdc: 12 80 00 15 bne 203bc30 <rtems_rfs_inode_create+0x2cc>
203bbe0: 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);
203bbe4: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
203bbe8: 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);
203bbec: c6 08 60 01 ldub [ %g1 + 1 ], %g3
203bbf0: c4 08 40 00 ldub [ %g1 ], %g2
203bbf4: 85 28 a0 08 sll %g2, 8, %g2
203bbf8: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
203bbfc: 87 28 a0 10 sll %g2, 0x10, %g3
203bc00: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
203bc04: 86 39 00 03 xnor %g4, %g3, %g3
203bc08: 80 a0 00 03 cmp %g0, %g3
203bc0c: 86 60 20 00 subx %g0, 0, %g3
203bc10: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
203bc14: 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);
203bc18: 87 30 a0 08 srl %g2, 8, %g3
203bc1c: c6 28 40 00 stb %g3, [ %g1 ]
203bc20: c2 07 bf bc ld [ %fp + -68 ], %g1
203bc24: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203bc28: 82 10 20 01 mov 1, %g1
203bc2c: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
203bc30: 7f ff fe 77 call 203b60c <rtems_rfs_inode_close>
203bc34: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
203bc38: 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);
203bc3c: a8 10 00 08 mov %o0, %l4
if (rc > 0)
203bc40: 80 a5 20 00 cmp %l4, 0
203bc44: 04 80 00 09 ble 203bc68 <rtems_rfs_inode_create+0x304> <== ALWAYS TAKEN
203bc48: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
203bc4c: 7f ff fe 93 call 203b698 <rtems_rfs_inode_delete> <== NOT EXECUTED
203bc50: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
203bc54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203bc58: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203bc5c: 7f ff fe 6c call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203bc60: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
return rc;
203bc64: 30 80 00 0c b,a 203bc94 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
203bc68: 7f ff fe 69 call 203b60c <rtems_rfs_inode_close>
203bc6c: 01 00 00 00 nop
if (rc > 0)
203bc70: a8 92 20 00 orcc %o0, 0, %l4
203bc74: 24 80 00 07 ble,a 203bc90 <rtems_rfs_inode_create+0x32c> <== ALWAYS TAKEN
203bc78: a8 10 20 00 clr %l4
{
rtems_rfs_inode_free (fs, *ino);
203bc7c: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
203bc80: 7f ff fd c0 call 203b380 <rtems_rfs_inode_free> <== NOT EXECUTED
203bc84: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
203bc88: 81 c7 e0 08 ret <== NOT EXECUTED
203bc8c: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED
}
return 0;
}
203bc90: b0 10 00 14 mov %l4, %i0
203bc94: 81 c7 e0 08 ret
203bc98: 81 e8 00 00 restore
0203b698 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
203b698: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
203b69c: 90 10 20 00 clr %o0
203b6a0: 13 00 20 00 sethi %hi(0x800000), %o1
203b6a4: 7f ff a0 01 call 20236a8 <rtems_rfs_trace>
203b6a8: ba 10 00 18 mov %i0, %i5
203b6ac: 80 8a 20 ff btst 0xff, %o0
203b6b0: 02 80 00 0d be 203b6e4 <rtems_rfs_inode_delete+0x4c> <== ALWAYS TAKEN
203b6b4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
203b6b8: 15 00 81 9d sethi %hi(0x2067400), %o2 <== NOT EXECUTED
203b6bc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203b6c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203b6c4: 02 80 00 04 be 203b6d4 <rtems_rfs_inode_delete+0x3c> <== NOT EXECUTED
203b6c8: 94 12 a3 20 or %o2, 0x320, %o2 <== NOT EXECUTED
203b6cc: 15 00 81 9d sethi %hi(0x2067400), %o2 <== NOT EXECUTED
203b6d0: 94 12 a3 18 or %o2, 0x318, %o2 ! 2067718 <__FUNCTION__.7646+0xa90><== NOT EXECUTED
203b6d4: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b6d8: 40 00 2b ab call 2046584 <printf> <== NOT EXECUTED
203b6dc: 90 12 20 70 or %o0, 0x70, %o0 ! 2068c70 <__FUNCTION__.7646+0x1fe8><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
203b6e0: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
203b6e4: 80 a0 60 00 cmp %g1, 0
203b6e8: 02 80 00 1e be 203b760 <rtems_rfs_inode_delete+0xc8> <== NEVER TAKEN
203b6ec: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
203b6f0: d2 06 60 08 ld [ %i1 + 8 ], %o1
203b6f4: 7f ff ff 23 call 203b380 <rtems_rfs_inode_free>
203b6f8: 90 10 00 1d mov %i5, %o0
if (rc > 0)
203b6fc: 80 a2 20 00 cmp %o0, 0
203b700: 14 80 00 18 bg 203b760 <rtems_rfs_inode_delete+0xc8> <== NEVER TAKEN
203b704: 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);
203b708: 90 10 00 1d mov %i5, %o0
203b70c: 7f ff e9 fb call 2035ef8 <rtems_rfs_block_map_open>
203b710: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
203b714: 80 a2 20 00 cmp %o0, 0
203b718: 12 80 00 12 bne 203b760 <rtems_rfs_inode_delete+0xc8> <== NEVER TAKEN
203b71c: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
203b720: 7f ff ed 0f call 2036b5c <rtems_rfs_block_map_free_all>
203b724: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_block_map_close (fs, &map);
203b728: 92 07 bf b0 add %fp, -80, %o1
203b72c: 7f ff ea 55 call 2036080 <rtems_rfs_block_map_close>
203b730: 90 10 00 1d mov %i5, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
203b734: d0 06 60 0c ld [ %i1 + 0xc ], %o0
203b738: 92 10 20 ff mov 0xff, %o1
203b73c: 40 00 27 26 call 20453d4 <memset>
203b740: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203b744: 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);
203b748: 90 10 00 1d mov %i5, %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);
203b74c: 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);
203b750: 7f ff ed 67 call 2036cec <rtems_rfs_buffer_handle_release>
203b754: 92 06 60 10 add %i1, 0x10, %o1
handle->loads = 0;
203b758: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
203b75c: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
203b760: 81 c7 e0 08 ret
203b764: 91 e8 00 08 restore %g0, %o0, %o0
0202137c <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]);
202137c: c4 02 20 0c ld [ %o0 + 0xc ], %g2 <== NOT EXECUTED
2021380: 83 2a 60 02 sll %o1, 2, %g1 <== NOT EXECUTED
2021384: 86 00 a0 1c add %g2, 0x1c, %g3 <== NOT EXECUTED
2021388: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
202138c: 93 2a 60 02 sll %o1, 2, %o1 <== NOT EXECUTED
2021390: 84 00 80 09 add %g2, %o1, %g2 <== NOT EXECUTED
2021394: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
2021398: d0 08 a0 04 ldub [ %g2 + 4 ], %o0 <== NOT EXECUTED
202139c: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED
20213a0: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
20213a4: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
20213a8: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
20213ac: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
20213b0: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
20213b4: 90 10 c0 08 or %g3, %o0, %o0 <== NOT EXECUTED
20213b8: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
}
20213bc: 81 c3 e0 08 retl <== NOT EXECUTED
20213c0: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
0203b394 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
203b394: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
203b398: 90 10 20 00 clr %o0
203b39c: 7f ff a0 c3 call 20236a8 <rtems_rfs_trace>
203b3a0: 13 00 04 00 sethi %hi(0x100000), %o1
203b3a4: 80 8a 20 ff btst 0xff, %o0
203b3a8: 02 80 00 0e be 203b3e0 <rtems_rfs_inode_load+0x4c> <== ALWAYS TAKEN
203b3ac: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
203b3b0: 17 00 81 9d sethi %hi(0x2067400), %o3 <== NOT EXECUTED
203b3b4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203b3b8: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
203b3bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203b3c0: 02 80 00 04 be 203b3d0 <rtems_rfs_inode_load+0x3c> <== NOT EXECUTED
203b3c4: 96 12 e3 20 or %o3, 0x320, %o3 <== NOT EXECUTED
203b3c8: 17 00 81 9d sethi %hi(0x2067400), %o3 <== NOT EXECUTED
203b3cc: 96 12 e3 18 or %o3, 0x318, %o3 ! 2067718 <__FUNCTION__.7646+0xa90><== NOT EXECUTED
203b3d0: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203b3d4: 40 00 2c 6c call 2046584 <printf> <== NOT EXECUTED
203b3d8: 90 12 23 80 or %o0, 0x380, %o0 ! 2068b80 <__FUNCTION__.7646+0x1ef8><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
203b3dc: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
203b3e0: 80 a0 60 00 cmp %g1, 0
203b3e4: 32 80 00 13 bne,a 203b430 <rtems_rfs_inode_load+0x9c>
203b3e8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
203b3ec: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
203b3f0: 90 10 00 18 mov %i0, %o0
203b3f4: 92 06 60 10 add %i1, 0x10, %o1
203b3f8: 7f ff ee af call 2036eb4 <rtems_rfs_buffer_handle_request>
203b3fc: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
203b400: b0 92 20 00 orcc %o0, 0, %i0
203b404: 14 80 00 0e bg 203b43c <rtems_rfs_inode_load+0xa8> <== NEVER TAKEN
203b408: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
203b40c: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
203b410: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
203b414: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
203b418: 87 28 60 03 sll %g1, 3, %g3
203b41c: 83 28 60 06 sll %g1, 6, %g1
203b420: 82 20 40 03 sub %g1, %g3, %g1
203b424: 82 00 80 01 add %g2, %g1, %g1
203b428: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
handle->loads++;
203b42c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
203b430: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
203b434: 82 00 60 01 inc %g1
203b438: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
203b43c: 81 c7 e0 08 ret
203b440: 81 e8 00 00 restore
0203b444 <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)
{
203b444: 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))
203b448: 90 10 20 00 clr %o0
203b44c: 7f ff a0 97 call 20236a8 <rtems_rfs_trace>
203b450: 13 00 01 00 sethi %hi(0x40000), %o1
203b454: 80 8a 20 ff btst 0xff, %o0
203b458: 02 80 00 07 be 203b474 <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
203b45c: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
203b460: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203b464: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203b468: 40 00 2c 47 call 2046584 <printf> <== NOT EXECUTED
203b46c: 90 12 23 b8 or %o0, 0x3b8, %o0 <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
203b470: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
203b474: 02 80 00 28 be 203b514 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
203b478: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
203b47c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
203b480: ba 06 7f ff add %i1, -1, %i5
203b484: 80 a7 40 02 cmp %i5, %g2
203b488: 18 80 00 23 bgu 203b514 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
203b48c: 90 10 00 1d mov %i5, %o0
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
203b490: f8 06 20 2c ld [ %i0 + 0x2c ], %i4
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
203b494: 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;
gino = gino % fs->group_inodes;
203b498: 92 10 00 1c mov %i4, %o1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
203b49c: 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;
203b4a0: 40 00 80 98 call 205b700 <.urem>
203b4a4: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
203b4a8: f2 06 20 30 ld [ %i0 + 0x30 ], %i1
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
203b4ac: 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;
203b4b0: 40 00 80 94 call 205b700 <.urem>
203b4b4: 92 10 00 19 mov %i1, %o1
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
203b4b8: 92 10 00 1c mov %i4, %o1
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
203b4bc: 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;
203b4c0: 40 00 7f e4 call 205b450 <.udiv>
203b4c4: 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);
203b4c8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
203b4cc: 85 2a 20 04 sll %o0, 4, %g2
203b4d0: 91 2a 20 06 sll %o0, 6, %o0
203b4d4: 90 00 80 08 add %g2, %o0, %o0
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;
203b4d8: fa 00 40 08 ld [ %g1 + %o0 ], %i5
203b4dc: 92 10 00 19 mov %i1, %o1
203b4e0: ba 07 60 02 add %i5, 2, %i5
203b4e4: 40 00 7f db call 205b450 <.udiv>
203b4e8: 90 10 00 10 mov %l0, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203b4ec: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
203b4f0: ba 07 40 08 add %i5, %o0, %i5
handle->bnum = 0;
203b4f4: c0 26 a0 14 clr [ %i2 + 0x14 ]
203b4f8: fa 26 a0 1c st %i5, [ %i2 + 0x1c ]
handle->buffer = NULL;
203b4fc: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
203b500: 80 a6 e0 00 cmp %i3, 0
203b504: 02 80 00 04 be 203b514 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
203b508: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
203b50c: 7f ff ff a2 call 203b394 <rtems_rfs_inode_load>
203b510: 93 e8 00 1a restore %g0, %i2, %o1
return rc;
}
203b514: 81 c7 e0 08 ret <== NOT EXECUTED
203b518: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
02039f9c <rtems_rfs_inode_overhead>:
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
2039f9c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
2039fa0: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
2039fa4: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== 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,
2039fa8: 85 28 60 03 sll %g1, 3, %g2 <== NOT EXECUTED
2039fac: 83 28 60 06 sll %g1, 6, %g1 <== NOT EXECUTED
2039fb0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2039fb4: 7f ff ff ef call 2039f70 <rtems_rfs_rup_quotient> <== NOT EXECUTED
2039fb8: 90 20 40 02 sub %g1, %g2, %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))
2039fbc: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== 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));
2039fc0: bb 2f 60 03 sll %i5, 3, %i5 <== 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))
2039fc4: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED
2039fc8: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED
2039fcc: 28 80 00 02 bleu,a 2039fd4 <rtems_rfs_inode_overhead+0x38><== NOT EXECUTED
2039fd0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
return ((blocks + 1) * 100 * 10) / bits_per_block;
2039fd4: 90 02 20 01 inc %o0 <== NOT EXECUTED
2039fd8: 85 2a 20 07 sll %o0, 7, %g2 <== NOT EXECUTED
2039fdc: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
2039fe0: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED
2039fe4: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
2039fe8: 40 00 85 1c call 205b458 <.div> <== NOT EXECUTED
2039fec: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
}
2039ff0: 81 c7 e0 08 ret <== NOT EXECUTED
2039ff4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
020213c4 <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);
20213c4: c4 02 20 0c ld [ %o0 + 0xc ], %g2 <== NOT EXECUTED
20213c8: 82 02 60 06 add %o1, 6, %g1 <== NOT EXECUTED
20213cc: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
20213d0: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
20213d4: 85 32 a0 18 srl %o2, 0x18, %g2 <== NOT EXECUTED
20213d8: c4 28 60 04 stb %g2, [ %g1 + 4 ] <== NOT EXECUTED
20213dc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20213e0: 93 2a 60 02 sll %o1, 2, %o1 <== NOT EXECUTED
20213e4: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
20213e8: 85 32 a0 10 srl %o2, 0x10, %g2 <== NOT EXECUTED
20213ec: c4 28 60 1d stb %g2, [ %g1 + 0x1d ] <== NOT EXECUTED
20213f0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20213f4: 85 32 a0 08 srl %o2, 8, %g2 <== NOT EXECUTED
20213f8: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
20213fc: c4 28 60 1e stb %g2, [ %g1 + 0x1e ] <== NOT EXECUTED
2021400: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2021404: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
2021408: d4 2a 60 1f stb %o2, [ %o1 + 0x1f ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
202140c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
}
2021410: 81 c3 e0 08 retl <== NOT EXECUTED
2021414: c2 2a 20 10 stb %g1, [ %o0 + 0x10 ] <== NOT EXECUTED
0203b768 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
203b768: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
203b76c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
203b770: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
203b774: 80 a0 60 00 cmp %g1, 0
203b778: 02 80 00 23 be 203b804 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
203b77c: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
203b780: 40 00 4c 5a call 204e8e8 <time>
203b784: 90 10 20 00 clr %o0
if (atime)
203b788: 80 a6 60 00 cmp %i1, 0
203b78c: 02 80 00 0f be 203b7c8 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
203b790: 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);
203b794: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b798: 85 32 20 18 srl %o0, 0x18, %g2
203b79c: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
203b7a0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b7a4: 85 32 20 10 srl %o0, 0x10, %g2
203b7a8: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
203b7ac: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b7b0: 85 32 20 08 srl %o0, 8, %g2
203b7b4: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
203b7b8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b7bc: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203b7c0: 82 10 20 01 mov 1, %g1
203b7c4: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
203b7c8: 02 80 00 0f be 203b804 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
203b7cc: 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);
203b7d0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b7d4: 85 32 20 18 srl %o0, 0x18, %g2
203b7d8: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
203b7dc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b7e0: 85 32 20 10 srl %o0, 0x10, %g2
203b7e4: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
203b7e8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b7ec: 85 32 20 08 srl %o0, 8, %g2
203b7f0: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
203b7f4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203b7f8: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203b7fc: 82 10 20 01 mov 1, %g1
203b800: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
203b804: 81 c7 e0 08 ret
203b808: 81 e8 00 00 restore
0203b51c <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
203b51c: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
203b520: 90 10 20 00 clr %o0
203b524: 13 00 08 00 sethi %hi(0x200000), %o1
203b528: 7f ff a0 60 call 20236a8 <rtems_rfs_trace>
203b52c: ba 10 00 18 mov %i0, %i5
203b530: 80 8a 20 ff btst 0xff, %o0
203b534: 02 80 00 0e be 203b56c <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
203b538: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
203b53c: 17 00 81 9d sethi %hi(0x2067400), %o3 <== NOT EXECUTED
203b540: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203b544: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
203b548: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203b54c: 02 80 00 04 be 203b55c <rtems_rfs_inode_unload+0x40> <== NOT EXECUTED
203b550: 96 12 e3 20 or %o3, 0x320, %o3 <== NOT EXECUTED
203b554: 17 00 81 9d sethi %hi(0x2067400), %o3 <== NOT EXECUTED
203b558: 96 12 e3 18 or %o3, 0x318, %o3 ! 2067718 <__FUNCTION__.7646+0xa90><== NOT EXECUTED
203b55c: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203b560: 40 00 2c 09 call 2046584 <printf> <== NOT EXECUTED
203b564: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 2068be0 <__FUNCTION__.7646+0x1f58><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
203b568: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
203b56c: 80 a0 60 00 cmp %g1, 0
203b570: 02 80 00 25 be 203b604 <rtems_rfs_inode_unload+0xe8>
203b574: 90 10 20 00 clr %o0
{
if (handle->loads == 0)
203b578: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
203b57c: 80 a0 60 00 cmp %g1, 0
203b580: 02 80 00 21 be 203b604 <rtems_rfs_inode_unload+0xe8> <== NEVER TAKEN
203b584: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
203b588: 82 00 7f ff add %g1, -1, %g1
203b58c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
if (handle->loads == 0)
203b590: 80 a0 60 00 cmp %g1, 0
203b594: 12 80 00 1c bne 203b604 <rtems_rfs_inode_unload+0xe8>
203b598: 90 10 20 00 clr %o0
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
203b59c: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
203b5a0: 80 a0 60 00 cmp %g1, 0
203b5a4: 22 80 00 15 be,a 203b5f8 <rtems_rfs_inode_unload+0xdc>
203b5a8: 90 10 00 1d mov %i5, %o0
203b5ac: 80 a6 a0 00 cmp %i2, 0
203b5b0: 22 80 00 12 be,a 203b5f8 <rtems_rfs_inode_unload+0xdc> <== NEVER TAKEN
203b5b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
203b5b8: 40 00 4c cc call 204e8e8 <time>
203b5bc: 01 00 00 00 nop
*/
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);
203b5c0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
203b5c4: 85 32 20 18 srl %o0, 0x18, %g2
203b5c8: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
203b5cc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
203b5d0: 85 32 20 10 srl %o0, 0x10, %g2
203b5d4: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
203b5d8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
203b5dc: 85 32 20 08 srl %o0, 8, %g2
203b5e0: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
203b5e4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
203b5e8: d0 28 60 1b stb %o0, [ %g1 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203b5ec: 82 10 20 01 mov 1, %g1
203b5f0: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
203b5f4: 90 10 00 1d mov %i5, %o0
203b5f8: 7f ff ed bd call 2036cec <rtems_rfs_buffer_handle_release>
203b5fc: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
203b600: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
203b604: 81 c7 e0 08 ret
203b608: 91 e8 00 08 restore %g0, %o0, %o0
0203bd38 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
203bd38: 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))
203bd3c: 90 10 20 00 clr %o0
203bd40: 7f ff 9e 5a call 20236a8 <rtems_rfs_trace>
203bd44: 13 00 40 00 sethi %hi(0x1000000), %o1
203bd48: 80 8a 20 ff btst 0xff, %o0
203bd4c: 02 80 00 13 be 203bd98 <rtems_rfs_link+0x60> <== ALWAYS TAKEN
203bd50: 90 10 00 18 mov %i0, %o0
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
203bd54: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203bd58: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203bd5c: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
203bd60: 40 00 2a 09 call 2046584 <printf> <== NOT EXECUTED
203bd64: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
203bd68: 10 80 00 05 b 203bd7c <rtems_rfs_link+0x44> <== NOT EXECUTED
203bd6c: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
203bd70: 40 00 2a 72 call 2046738 <putchar> <== NOT EXECUTED
203bd74: 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++)
203bd78: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
203bd7c: 26 bf ff fd bl,a 203bd70 <rtems_rfs_link+0x38> <== NOT EXECUTED
203bd80: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
203bd84: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203bd88: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203bd8c: 40 00 29 fe call 2046584 <printf> <== NOT EXECUTED
203bd90: 90 12 21 28 or %o0, 0x128, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
203bd94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203bd98: 92 10 00 1c mov %i4, %o1
203bd9c: 94 07 bf d8 add %fp, -40, %o2
203bda0: 7f ff fd a9 call 203b444 <rtems_rfs_inode_open>
203bda4: 96 10 20 01 mov 1, %o3
if (rc)
203bda8: a0 92 20 00 orcc %o0, 0, %l0
203bdac: 12 80 00 47 bne 203bec8 <rtems_rfs_link+0x190> <== NEVER TAKEN
203bdb0: 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)))
203bdb4: 12 80 00 10 bne 203bdf4 <rtems_rfs_link+0xbc> <== NEVER TAKEN
203bdb8: 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);
203bdbc: c2 07 bf e4 ld [ %fp + -28 ], %g1
203bdc0: c4 08 60 02 ldub [ %g1 + 2 ], %g2
203bdc4: 03 00 00 3c sethi %hi(0xf000), %g1
203bdc8: 85 28 a0 08 sll %g2, 8, %g2
203bdcc: 84 08 80 01 and %g2, %g1, %g2
203bdd0: 03 00 00 10 sethi %hi(0x4000), %g1
203bdd4: 80 a0 80 01 cmp %g2, %g1
203bdd8: 12 80 00 08 bne 203bdf8 <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
203bddc: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_inode_close (fs, &target_inode);
203bde0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203bde4: 7f ff fe 0a call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203bde8: a0 10 20 86 mov 0x86, %l0 <== NOT EXECUTED
return ENOTSUP;
203bdec: 81 c7 e0 08 ret <== NOT EXECUTED
203bdf0: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
203bdf4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203bdf8: 94 07 bf b0 add %fp, -80, %o2
203bdfc: 7f ff fd 92 call 203b444 <rtems_rfs_inode_open>
203be00: 96 10 20 01 mov 1, %o3
203be04: a0 10 00 08 mov %o0, %l0
if (rc)
203be08: 80 a4 20 00 cmp %l0, 0
203be0c: 12 80 00 0e bne 203be44 <rtems_rfs_link+0x10c> <== NEVER TAKEN
203be10: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
203be14: 92 07 bf b0 add %fp, -80, %o1
203be18: 94 10 00 19 mov %i1, %o2
203be1c: 96 10 00 1a mov %i2, %o3
203be20: 7f ff ef 22 call 2037aa8 <rtems_rfs_dir_add_entry>
203be24: 98 10 00 1c mov %i4, %o4
if (rc > 0)
203be28: a0 92 20 00 orcc %o0, 0, %l0
203be2c: 04 80 00 0a ble 203be54 <rtems_rfs_link+0x11c> <== ALWAYS TAKEN
203be30: 92 07 bf b0 add %fp, -80, %o1
{
rtems_rfs_inode_close (fs, &parent_inode);
203be34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203be38: 7f ff fd f5 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203be3c: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
203be40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203be44: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203be48: 7f ff fd f1 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203be4c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return rc;
203be50: 30 80 00 1f b,a 203becc <rtems_rfs_link+0x194> <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
203be54: 7f ff ff aa call 203bcfc <rtems_rfs_inode_get_links>
203be58: 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);
203be5c: c2 07 bf e4 ld [ %fp + -28 ], %g1
203be60: 90 02 20 01 inc %o0
203be64: 85 32 20 08 srl %o0, 8, %g2
203be68: c4 28 40 00 stb %g2, [ %g1 ]
203be6c: 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);
203be70: 92 10 20 01 mov 1, %o1
203be74: d0 28 60 01 stb %o0, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203be78: 82 10 20 01 mov 1, %g1
203be7c: 90 07 bf b0 add %fp, -80, %o0
203be80: c2 2f bf e8 stb %g1, [ %fp + -24 ]
203be84: 7f ff fe 39 call 203b768 <rtems_rfs_inode_time_stamp_now>
203be88: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
203be8c: 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);
203be90: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203be94: 80 a4 20 00 cmp %l0, 0
203be98: 14 bf ff e8 bg 203be38 <rtems_rfs_link+0x100> <== NEVER TAKEN
203be9c: 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);
203bea0: 7f ff fd db call 203b60c <rtems_rfs_inode_close>
203bea4: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
203bea8: 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);
203beac: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203beb0: 80 a4 20 00 cmp %l0, 0
203beb4: 14 bf ff e5 bg 203be48 <rtems_rfs_link+0x110> <== NEVER TAKEN
203beb8: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
203bebc: 7f ff fd d4 call 203b60c <rtems_rfs_inode_close>
203bec0: 01 00 00 00 nop
203bec4: a0 10 00 08 mov %o0, %l0
return rc;
}
203bec8: b0 10 00 10 mov %l0, %i0
203becc: 81 c7 e0 08 ret
203bed0: 81 e8 00 00 restore
0203c6a4 <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
203c6a4: 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'),
203c6a8: 11 14 91 94 sethi %hi(0x52465000), %o0
203c6ac: 98 10 00 18 mov %i0, %o4
203c6b0: 90 12 23 6d or %o0, 0x36d, %o0
203c6b4: 92 10 20 01 mov 1, %o1
203c6b8: 94 10 20 54 mov 0x54, %o2
203c6bc: 96 10 20 00 clr %o3
203c6c0: 7f ff 41 eb call 200ce6c <rtems_semaphore_create>
203c6c4: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
203c6c8: 80 a2 20 00 cmp %o0, 0
203c6cc: 02 80 00 0f be 203c708 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
203c6d0: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203c6d4: 90 10 20 00 clr %o0 <== NOT EXECUTED
203c6d8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203c6dc: 7f ff 9b f3 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c6e0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203c6e4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c6e8: 02 80 00 08 be 203c708 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
203c6ec: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
203c6f0: 7f ff 2f 8b call 200851c <rtems_status_text> <== NOT EXECUTED
203c6f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c6f8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203c6fc: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c700: 40 00 27 a1 call 2046584 <printf> <== NOT EXECUTED
203c704: 90 12 23 58 or %o0, 0x358, %o0 ! 2068f58 <__FUNCTION__.7646+0x22d0><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
203c708: 81 c7 e0 08 ret
203c70c: 81 e8 00 00 restore
0203c710 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
203c710: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
203c714: d0 06 00 00 ld [ %i0 ], %o0
203c718: 7f ff 42 40 call 200d018 <rtems_semaphore_delete>
203c71c: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
203c720: 80 a2 20 00 cmp %o0, 0
203c724: 02 80 00 0f be 203c760 <rtems_rfs_mutex_destroy+0x50> <== ALWAYS TAKEN
203c728: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203c72c: 90 10 20 00 clr %o0 <== NOT EXECUTED
203c730: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203c734: 7f ff 9b dd call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c738: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203c73c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c740: 02 80 00 08 be 203c760 <rtems_rfs_mutex_destroy+0x50> <== NOT EXECUTED
203c744: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
203c748: 7f ff 2f 75 call 200851c <rtems_status_text> <== NOT EXECUTED
203c74c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c750: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203c754: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c758: 40 00 27 8b call 2046584 <printf> <== NOT EXECUTED
203c75c: 90 12 23 80 or %o0, 0x380, %o0 ! 2068f80 <__FUNCTION__.7646+0x22f8><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
203c760: 81 c7 e0 08 ret
203c764: 81 e8 00 00 restore
02022180 <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)
2022180: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2022184: 92 10 20 00 clr %o1
2022188: 90 10 00 18 mov %i0, %o0
202218c: 94 10 20 00 clr %o2
2022190: 7f ff ab eb call 200d13c <rtems_semaphore_obtain>
2022194: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2022198: 80 a2 20 00 cmp %o0, 0
202219c: 02 80 00 0f be 20221d8 <rtems_rfs_mutex_lock.isra.3+0x58> <== ALWAYS TAKEN
20221a0: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20221a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20221a8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20221ac: 40 00 05 3f call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20221b0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
20221b4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20221b8: 02 80 00 08 be 20221d8 <rtems_rfs_mutex_lock.isra.3+0x58> <== NOT EXECUTED
20221bc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
20221c0: 7f ff 98 d7 call 200851c <rtems_status_text> <== NOT EXECUTED
20221c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20221c8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
20221cc: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
20221d0: 40 00 90 ed call 2046584 <printf> <== NOT EXECUTED
20221d4: 90 12 20 98 or %o0, 0x98, %o0 ! 2062898 <rtems_nvdisk_sram_handlers+0x38><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
20221d8: 81 c7 e0 08 ret
20221dc: 81 e8 00 00 restore
02036b6c <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
2036b6c: 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))
2036b70: 90 10 20 00 clr %o0
2036b74: 92 10 20 80 mov 0x80, %o1
2036b78: 7f ff b2 cc call 20236a8 <rtems_rfs_trace>
2036b7c: ba 10 00 18 mov %i0, %i5
2036b80: 80 8a 20 ff btst 0xff, %o0
2036b84: 22 80 00 07 be,a 2036ba0 <rtems_rfs_release_chain+0x34> <== ALWAYS TAKEN
2036b88: b0 10 20 00 clr %i0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
2036b8c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2036b90: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036b94: 40 00 3e 7c call 2046584 <printf> <== NOT EXECUTED
2036b98: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 2066db8 <__FUNCTION__.7646+0x130><== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
2036b9c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2036ba0: 10 80 00 10 b 2036be0 <rtems_rfs_release_chain+0x74>
2036ba4: b8 07 60 04 add %i5, 4, %i4
2036ba8: 7f ff 5c bf call 200dea4 <_Chain_Get>
2036bac: 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)--;
2036bb0: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
2036bb4: 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)--;
2036bb8: 82 00 7f ff add %g1, -1, %g1
2036bbc: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
2036bc0: 40 00 2a 86 call 20415d8 <rtems_rfs_buffer_bdbuf_release>
2036bc4: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
2036bc8: 80 a2 20 00 cmp %o0, 0
2036bcc: 24 80 00 06 ble,a 2036be4 <rtems_rfs_release_chain+0x78> <== ALWAYS TAKEN
2036bd0: c2 07 40 00 ld [ %i5 ], %g1
2036bd4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
2036bd8: 22 80 00 02 be,a 2036be0 <rtems_rfs_release_chain+0x74> <== NOT EXECUTED
2036bdc: 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))
2036be0: c2 07 40 00 ld [ %i5 ], %g1
2036be4: 80 a0 40 1c cmp %g1, %i4
2036be8: 12 bf ff f0 bne 2036ba8 <rtems_rfs_release_chain+0x3c>
2036bec: 01 00 00 00 nop
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
2036bf0: 81 c7 e0 08 ret
2036bf4: 81 e8 00 00 restore
02021768 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
2021768: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
202176c: c2 06 20 18 ld [ %i0 + 0x18 ], %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);
2021770: 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);
2021774: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
2021778: 94 07 bf d8 add %fp, -40, %o2
202177c: 90 10 00 1d mov %i5, %o0
2021780: 40 00 67 31 call 203b444 <rtems_rfs_inode_open>
2021784: 96 10 20 01 mov 1, %o3
if (rc > 0)
2021788: b0 92 20 00 orcc %o0, 0, %i0
202178c: 04 80 00 06 ble 20217a4 <rtems_rfs_rtems_chown+0x3c> <== ALWAYS TAKEN
2021790: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
2021794: 40 00 81 43 call 2041ca0 <__errno> <== NOT EXECUTED
2021798: 01 00 00 00 nop <== NOT EXECUTED
202179c: 10 80 00 18 b 20217fc <rtems_rfs_rtems_chown+0x94> <== NOT EXECUTED
20217a0: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
20217a4: 40 00 18 9f call 2027a20 <geteuid>
20217a8: 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;
20217ac: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
20217b0: 91 2a 20 10 sll %o0, 0x10, %o0
20217b4: c6 08 60 07 ldub [ %g1 + 7 ], %g3
20217b8: c4 08 60 06 ldub [ %g1 + 6 ], %g2
20217bc: 85 28 a0 08 sll %g2, 8, %g2
20217c0: 84 10 80 03 or %g2, %g3, %g2
20217c4: 85 28 a0 10 sll %g2, 0x10, %g2
20217c8: 80 a0 80 08 cmp %g2, %o0
20217cc: 02 80 00 0e be 2021804 <rtems_rfs_rtems_chown+0x9c> <== ALWAYS TAKEN
20217d0: 87 32 20 10 srl %o0, 0x10, %g3
20217d4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
20217d8: 22 80 00 0c be,a 2021808 <rtems_rfs_rtems_chown+0xa0> <== NOT EXECUTED
20217dc: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
20217e0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20217e4: 40 00 67 8a call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
20217e8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
20217ec: 40 00 81 2d call 2041ca0 <__errno> <== NOT EXECUTED
20217f0: 01 00 00 00 nop <== NOT EXECUTED
20217f4: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1> <== NOT EXECUTED
20217f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20217fc: 81 c7 e0 08 ret <== NOT EXECUTED
2021800: 91 e8 3f ff restore %g0, -1, %o0 <== 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);
2021804: b5 2e a0 10 sll %i2, 0x10, %i2
2021808: b4 16 80 19 or %i2, %i1, %i2
202180c: 85 36 a0 18 srl %i2, 0x18, %g2
2021810: c4 28 60 04 stb %g2, [ %g1 + 4 ]
2021814: c2 07 bf e4 ld [ %fp + -28 ], %g1
2021818: 85 36 a0 10 srl %i2, 0x10, %g2
202181c: c4 28 60 05 stb %g2, [ %g1 + 5 ]
2021820: c2 07 bf e4 ld [ %fp + -28 ], %g1
2021824: b5 36 a0 08 srl %i2, 8, %i2
2021828: f4 28 60 06 stb %i2, [ %g1 + 6 ]
202182c: 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);
2021830: 90 10 00 1d mov %i5, %o0
2021834: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2021838: 82 10 20 01 mov 1, %g1
202183c: 92 07 bf d8 add %fp, -40, %o1
2021840: c2 2f bf e8 stb %g1, [ %fp + -24 ]
2021844: 40 00 67 72 call 203b60c <rtems_rfs_inode_close>
2021848: b0 10 20 00 clr %i0
if (rc)
202184c: 80 a2 20 00 cmp %o0, 0
2021850: 02 80 00 05 be 2021864 <rtems_rfs_rtems_chown+0xfc> <== ALWAYS TAKEN
2021854: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
2021858: 40 00 81 12 call 2041ca0 <__errno> <== NOT EXECUTED
202185c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021860: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021864: 81 c7 e0 08 ret
2021868: 81 e8 00 00 restore
0203c8a8 <rtems_rfs_rtems_device_close>:
* @return int
*/
static int
rtems_rfs_rtems_device_close (rtems_libio_t* iop)
{
203c8a8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
203c8ac: d2 06 20 40 ld [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
203c8b0: d0 06 20 3c ld [ %i0 + 0x3c ], %o0 <== NOT EXECUTED
args.iop = iop;
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
203c8b4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
203c8b8: f0 27 bf f4 st %i0, [ %fp + -12 ] <== NOT EXECUTED
args.flags = 0;
203c8bc: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
203c8c0: 40 00 08 dc call 203ec30 <rtems_io_close> <== NOT EXECUTED
203c8c4: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
return rtems_deviceio_errno (status);
203c8c8: 40 00 02 7c call 203d2b8 <rtems_deviceio_errno> <== NOT EXECUTED
203c8cc: 01 00 00 00 nop <== NOT EXECUTED
}
203c8d0: 81 c7 e0 08 ret <== NOT EXECUTED
203c8d4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0203c7bc <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
203c7bc: 81 c3 e0 08 retl <== NOT EXECUTED
203c7c0: 90 10 20 00 clr %o0 <== NOT EXECUTED
0203c7c4 <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
203c7c4: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
203c7c8: d0 06 20 3c ld [ %i0 + 0x3c ], %o0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
203c7cc: d2 06 20 40 ld [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
args.iop = iop;
args.command = command;
203c7d0: f0 3f bf f0 std %i0, [ %fp + -16 ] <== NOT EXECUTED
args.buffer = buffer;
203c7d4: f4 27 bf f8 st %i2, [ %fp + -8 ] <== NOT EXECUTED
status = rtems_io_control (major, minor, (void *) &args);
203c7d8: 40 00 09 2c call 203ec88 <rtems_io_control> <== NOT EXECUTED
203c7dc: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if (status)
203c7e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
203c7e4: 02 80 00 05 be 203c7f8 <rtems_rfs_rtems_device_ioctl+0x34><== NOT EXECUTED
203c7e8: f0 07 bf fc ld [ %fp + -4 ], %i0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
203c7ec: 40 00 02 b3 call 203d2b8 <rtems_deviceio_errno> <== NOT EXECUTED
203c7f0: 01 00 00 00 nop <== NOT EXECUTED
203c7f4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return args.ioctl_return;
}
203c7f8: 81 c7 e0 08 ret <== NOT EXECUTED
203c7fc: 81 e8 00 00 restore <== NOT EXECUTED
0203c7b0 <rtems_rfs_rtems_device_lseek>:
rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
return offset;
}
203c7b0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
203c7b4: 81 c3 e0 08 retl <== NOT EXECUTED
203c7b8: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
0203c934 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
203c934: 9d e3 bf 68 save %sp, -152, %sp <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203c938: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
203c93c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
const char *pathname,
int oflag,
mode_t mode)
{
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203c940: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
203c944: 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
};
203c948: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
203c94c: 94 10 20 00 clr %o2 <== NOT EXECUTED
203c950: 7f ff 41 fb call 200d13c <rtems_semaphore_obtain> <== NOT EXECUTED
203c954: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
203c958: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203c95c: 22 80 00 0f be,a 203c998 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
203c960: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203c964: 90 10 20 00 clr %o0 <== NOT EXECUTED
203c968: 7f ff 9b 50 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c96c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203c970: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c974: 02 80 00 09 be 203c998 <rtems_rfs_rtems_device_open+0x64> <== NOT EXECUTED
203c978: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
203c97c: 7f ff 2e e8 call 200851c <rtems_status_text> <== NOT EXECUTED
203c980: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203c984: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203c988: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
203c98c: 40 00 26 fe call 2046584 <printf> <== NOT EXECUTED
203c990: 90 12 20 98 or %o0, 0x98, %o0 ! 2062898 <rtems_nvdisk_sram_handlers+0x38><== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203c994: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203c998: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c99c: 94 07 bf cc add %fp, -52, %o2 <== NOT EXECUTED
203c9a0: 7f ff fa a9 call 203b444 <rtems_rfs_inode_open> <== NOT EXECUTED
203c9a4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
203c9a8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
203c9ac: 04 80 00 09 ble 203c9d0 <rtems_rfs_rtems_device_open+0x9c><== NOT EXECUTED
203c9b0: 92 10 20 00 clr %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
203c9b4: 7f ff ff c9 call 203c8d8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203c9b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
203c9bc: 40 00 14 b9 call 2041ca0 <__errno> <== NOT EXECUTED
203c9c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203c9c4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203c9c8: 81 c7 e0 08 ret <== NOT EXECUTED
203c9cc: 81 e8 00 00 restore <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
203c9d0: 7f ff ff 66 call 203c768 <rtems_rfs_inode_get_block> <== NOT EXECUTED
203c9d4: 90 07 bf cc add %fp, -52, %o0 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
203c9d8: 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);
203c9dc: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
203c9e0: 7f ff ff 62 call 203c768 <rtems_rfs_inode_get_block> <== NOT EXECUTED
203c9e4: 90 07 bf cc add %fp, -52, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
203c9e8: 92 07 bf cc add %fp, -52, %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);
203c9ec: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
203c9f0: 7f ff fb 07 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203c9f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c9f8: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
if (rc > 0)
203c9fc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
203ca00: 04 80 00 09 ble 203ca24 <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
203ca04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
203ca08: 7f ff ff b4 call 203c8d8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203ca0c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
203ca10: 40 00 14 a4 call 2041ca0 <__errno> <== NOT EXECUTED
203ca14: 01 00 00 00 nop <== NOT EXECUTED
203ca18: f2 22 00 00 st %i1, [ %o0 ] <== NOT EXECUTED
203ca1c: 81 c7 e0 08 ret <== NOT EXECUTED
203ca20: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
203ca24: 7f ff ff ad call 203c8d8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203ca28: 01 00 00 00 nop <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
203ca2c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
203ca30: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203ca34: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
203ca38: f4 26 20 3c st %i2, [ %i0 + 0x3c ] <== NOT EXECUTED
iop->data1 = (void*)((intptr_t) minor);
203ca3c: f8 26 20 40 st %i4, [ %i0 + 0x40 ] <== NOT EXECUTED
args.iop = iop;
203ca40: f0 27 bf f4 st %i0, [ %fp + -12 ] <== NOT EXECUTED
args.flags = iop->flags;
203ca44: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
args.mode = mode;
203ca48: f6 27 bf fc st %i3, [ %fp + -4 ] <== NOT EXECUTED
status = rtems_io_open (major, minor, (void *) &args);
203ca4c: 40 00 08 a5 call 203ece0 <rtems_io_open> <== NOT EXECUTED
203ca50: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
203ca54: 40 00 02 19 call 203d2b8 <rtems_deviceio_errno> <== NOT EXECUTED
203ca58: 01 00 00 00 nop <== NOT EXECUTED
}
203ca5c: 81 c7 e0 08 ret <== NOT EXECUTED
203ca60: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0203c854 <rtems_rfs_rtems_device_read>:
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
203c854: 9d e3 bf 80 save %sp, -128, %sp <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
203c858: c4 1e 20 10 ldd [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
203c85c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
203c860: d0 06 20 3c ld [ %i0 + 0x3c ], %o0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
203c864: d2 06 20 40 ld [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
args.iop = iop;
203c868: f0 27 bf e0 st %i0, [ %fp + -32 ] <== NOT EXECUTED
args.offset = iop->offset;
203c86c: c4 3f bf e8 std %g2, [ %fp + -24 ] <== NOT EXECUTED
args.buffer = buffer;
203c870: f2 27 bf f0 st %i1, [ %fp + -16 ] <== NOT EXECUTED
args.count = count;
203c874: f4 27 bf f4 st %i2, [ %fp + -12 ] <== NOT EXECUTED
args.flags = iop->flags;
203c878: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
args.bytes_moved = 0;
203c87c: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
status = rtems_io_read (major, minor, (void *) &args);
203c880: 40 00 09 2e call 203ed38 <rtems_io_read> <== NOT EXECUTED
203c884: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
if (status)
203c888: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
203c88c: 02 80 00 05 be 203c8a0 <rtems_rfs_rtems_device_read+0x4c> <== NOT EXECUTED
203c890: f0 07 bf fc ld [ %fp + -4 ], %i0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
203c894: 40 00 02 89 call 203d2b8 <rtems_deviceio_errno> <== NOT EXECUTED
203c898: 01 00 00 00 nop <== NOT EXECUTED
203c89c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
203c8a0: 81 c7 e0 08 ret <== NOT EXECUTED
203c8a4: 81 e8 00 00 restore <== NOT EXECUTED
0203c800 <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
203c800: 9d e3 bf 80 save %sp, -128, %sp <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
203c804: c4 1e 20 10 ldd [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
203c808: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
203c80c: d0 06 20 3c ld [ %i0 + 0x3c ], %o0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
203c810: d2 06 20 40 ld [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
args.iop = iop;
203c814: f0 27 bf e0 st %i0, [ %fp + -32 ] <== NOT EXECUTED
args.offset = iop->offset;
203c818: c4 3f bf e8 std %g2, [ %fp + -24 ] <== NOT EXECUTED
args.buffer = (void *) buffer;
203c81c: f2 27 bf f0 st %i1, [ %fp + -16 ] <== NOT EXECUTED
args.count = count;
203c820: f4 27 bf f4 st %i2, [ %fp + -12 ] <== NOT EXECUTED
args.flags = iop->flags;
203c824: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
args.bytes_moved = 0;
203c828: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
status = rtems_io_write (major, minor, (void *) &args);
203c82c: 40 00 09 59 call 203ed90 <rtems_io_write> <== NOT EXECUTED
203c830: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
if (status)
203c834: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
203c838: 02 80 00 05 be 203c84c <rtems_rfs_rtems_device_write+0x4c><== NOT EXECUTED
203c83c: f0 07 bf fc ld [ %fp + -4 ], %i0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
203c840: 40 00 02 9e call 203d2b8 <rtems_deviceio_errno> <== NOT EXECUTED
203c844: 01 00 00 00 nop <== NOT EXECUTED
203c848: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
203c84c: 81 c7 e0 08 ret <== NOT EXECUTED
203c850: 81 e8 00 00 restore <== NOT EXECUTED
0203ccd0 <rtems_rfs_rtems_dir_lseek>:
*/
static off_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
203ccd0: 9d e3 bf a0 save %sp, -96, %sp
switch (whence)
203ccd4: 80 a6 e0 01 cmp %i3, 1
203ccd8: 28 80 00 09 bleu,a 203ccfc <rtems_rfs_rtems_dir_lseek+0x2c><== ALWAYS TAKEN
203ccdc: b0 10 20 00 clr %i0
break;
case SEEK_END: /* Movement past the end of the directory via lseek */
/* is not a permitted operation */
default:
return rtems_rfs_rtems_error ("dir_lseek: bad whence", EINVAL);
203cce0: 40 00 13 f0 call 2041ca0 <__errno> <== NOT EXECUTED
203cce4: 31 3f ff ff sethi %hi(0xfffffc00), %i0 <== NOT EXECUTED
203cce8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
203ccec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203ccf0: b0 16 23 ff or %i0, 0x3ff, %i0 <== NOT EXECUTED
203ccf4: 81 c7 e0 08 ret <== NOT EXECUTED
203ccf8: 93 e8 00 18 restore %g0, %i0, %o1 <== NOT EXECUTED
break;
}
return 0;
}
203ccfc: 81 c7 e0 08 ret
203cd00: 93 e8 20 00 restore %g0, 0, %o1
0203cc10 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
203cc10: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203cc14: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
203cc18: f8 06 20 24 ld [ %i0 + 0x24 ], %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);
203cc1c: fa 00 60 20 ld [ %g1 + 0x20 ], %i5
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
203cc20: 7f ff ff 93 call 203ca6c <rtems_rfs_rtems_lock>
203cc24: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203cc28: 92 10 00 1c mov %i4, %o1
203cc2c: 90 10 00 1d mov %i5, %o0
203cc30: 94 07 bf d8 add %fp, -40, %o2
203cc34: 7f ff fa 04 call 203b444 <rtems_rfs_inode_open>
203cc38: 96 10 20 01 mov 1, %o3
if (rc)
203cc3c: b8 92 20 00 orcc %o0, 0, %i4
203cc40: 02 80 00 09 be 203cc64 <rtems_rfs_rtems_dir_open+0x54> <== ALWAYS TAKEN
203cc44: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_rfs_rtems_unlock (fs);
203cc48: 7f ff ff a0 call 203cac8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203cc4c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
203cc50: 40 00 14 14 call 2041ca0 <__errno> <== NOT EXECUTED
203cc54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203cc58: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203cc5c: 81 c7 e0 08 ret <== NOT EXECUTED
203cc60: 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);
203cc64: c4 08 60 02 ldub [ %g1 + 2 ], %g2
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
203cc68: 03 00 00 3c sethi %hi(0xf000), %g1
203cc6c: 85 28 a0 08 sll %g2, 8, %g2
203cc70: 84 08 80 01 and %g2, %g1, %g2
203cc74: 03 00 00 10 sethi %hi(0x4000), %g1
203cc78: 80 a0 80 01 cmp %g2, %g1
203cc7c: 02 80 00 0c be 203ccac <rtems_rfs_rtems_dir_open+0x9c> <== ALWAYS TAKEN
203cc80: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_close (fs, &inode);
203cc84: 7f ff fa 62 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203cc88: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
203cc8c: 7f ff ff 8f call 203cac8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203cc90: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
203cc94: 40 00 14 03 call 2041ca0 <__errno> <== NOT EXECUTED
203cc98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203cc9c: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
203cca0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203cca4: 81 c7 e0 08 ret <== NOT EXECUTED
203cca8: 81 e8 00 00 restore <== NOT EXECUTED
}
iop->offset = 0;
203ccac: c0 26 20 10 clr [ %i0 + 0x10 ]
203ccb0: c0 26 20 14 clr [ %i0 + 0x14 ]
rtems_rfs_inode_close (fs, &inode);
203ccb4: 7f ff fa 56 call 203b60c <rtems_rfs_inode_close>
203ccb8: 90 10 00 1d mov %i5, %o0
rtems_rfs_rtems_unlock (fs);
203ccbc: 90 10 00 1d mov %i5, %o0
203ccc0: 7f ff ff 82 call 203cac8 <rtems_rfs_rtems_unlock>
203ccc4: b0 10 20 00 clr %i0
return 0;
}
203ccc8: 81 c7 e0 08 ret
203cccc: 81 e8 00 00 restore
0203cb24 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
203cb24: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203cb28: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
203cb2c: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
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);
203cb30: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
203cb34: 92 10 21 18 mov 0x118, %o1
203cb38: 40 00 7a 46 call 205b450 <.udiv>
203cb3c: 90 10 00 1a mov %i2, %o0
203cb40: b4 10 00 08 mov %o0, %i2
dirent = buffer;
rtems_rfs_rtems_lock (fs);
203cb44: 7f ff ff ca call 203ca6c <rtems_rfs_rtems_lock>
203cb48: 90 10 00 1c mov %i4, %o0
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203cb4c: 92 10 00 1b mov %i3, %o1
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
203cb50: ba 10 00 18 mov %i0, %i5
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203cb54: a0 07 bf d4 add %fp, -44, %l0
203cb58: 90 10 00 1c mov %i4, %o0
203cb5c: 94 10 00 10 mov %l0, %o2
203cb60: 96 10 20 01 mov 1, %o3
203cb64: 7f ff fa 38 call 203b444 <rtems_rfs_inode_open>
203cb68: b0 10 20 00 clr %i0
if (rc)
203cb6c: b6 92 20 00 orcc %o0, 0, %i3
203cb70: 02 80 00 1f be 203cbec <rtems_rfs_rtems_dir_read+0xc8> <== ALWAYS TAKEN
203cb74: 80 a6 c0 1a cmp %i3, %i2
{
rtems_rfs_rtems_unlock (fs);
203cb78: 7f ff ff d4 call 203cac8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203cb7c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
203cb80: 40 00 14 48 call 2041ca0 <__errno> <== NOT EXECUTED
203cb84: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203cb88: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
203cb8c: 81 c7 e0 08 ret <== NOT EXECUTED
203cb90: 81 e8 00 00 restore <== 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);
203cb94: d4 1f 60 10 ldd [ %i5 + 0x10 ], %o2
203cb98: 90 10 00 1c mov %i4, %o0
203cb9c: 92 10 00 10 mov %l0, %o1
203cba0: 7f ff ed a6 call 2038238 <rtems_rfs_dir_read>
203cba4: 9a 07 bf fc add %fp, -4, %o5
if (rc == ENOENT)
203cba8: 80 a2 20 02 cmp %o0, 2
203cbac: 02 80 00 12 be 203cbf4 <rtems_rfs_rtems_dir_read+0xd0>
203cbb0: a2 10 00 08 mov %o0, %l1
{
rc = 0;
break;
}
if (rc > 0)
203cbb4: 80 a2 20 00 cmp %o0, 0
203cbb8: 24 80 00 06 ble,a 203cbd0 <rtems_rfs_rtems_dir_read+0xac><== ALWAYS TAKEN
203cbbc: d8 1f 60 10 ldd [ %i5 + 0x10 ], %o4
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
203cbc0: 40 00 14 38 call 2041ca0 <__errno> <== NOT EXECUTED
203cbc4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203cbc8: 10 80 00 0b b 203cbf4 <rtems_rfs_rtems_dir_read+0xd0> <== NOT EXECUTED
203cbcc: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
break;
}
iop->offset += size;
203cbd0: c4 07 bf fc ld [ %fp + -4 ], %g2
* 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,
203cbd4: b0 06 21 18 add %i0, 0x118, %i0
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
203cbd8: 86 83 40 02 addcc %o5, %g2, %g3
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
203cbdc: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
203cbe0: 84 43 20 00 addx %o4, 0, %g2
203cbe4: c4 3f 60 10 std %g2, [ %i5 + 0x10 ]
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
203cbe8: 80 a6 c0 1a cmp %i3, %i2
203cbec: 12 bf ff ea bne 203cb94 <rtems_rfs_rtems_dir_read+0x70>
203cbf0: 98 06 40 18 add %i1, %i0, %o4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
203cbf4: 90 10 00 1c mov %i4, %o0
203cbf8: 7f ff fa 85 call 203b60c <rtems_rfs_inode_close>
203cbfc: 92 07 bf d4 add %fp, -44, %o1
rtems_rfs_rtems_unlock (fs);
203cc00: 7f ff ff b2 call 203cac8 <rtems_rfs_rtems_unlock>
203cc04: 90 10 00 1c mov %i4, %o0
return bytes_transferred;
}
203cc08: 81 c7 e0 08 ret
203cc0c: 81 e8 00 00 restore
02021b44 <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)
{
2021b44: 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);
2021b48: c2 06 20 30 ld [ %i0 + 0x30 ], %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);
2021b4c: 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);
2021b50: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
2021b54: 94 07 bf d8 add %fp, -40, %o2
2021b58: 90 10 00 1d mov %i5, %o0
2021b5c: 40 00 66 3a call 203b444 <rtems_rfs_inode_open>
2021b60: 96 10 20 01 mov 1, %o3
if (rc == 0) {
2021b64: b8 92 20 00 orcc %o0, 0, %i4
2021b68: 12 80 00 14 bne 2021bb8 <rtems_rfs_rtems_eval_path+0x74> <== NEVER TAKEN
2021b6c: 92 07 bf d8 add %fp, -40, %o1
rtems_filesystem_eval_path_generic (
2021b70: 90 10 00 18 mov %i0, %o0
2021b74: 15 00 81 8a sethi %hi(0x2062800), %o2
2021b78: 40 00 1c f0 call 2028f38 <rtems_filesystem_eval_path_generic>
2021b7c: 94 12 a1 80 or %o2, 0x180, %o2 ! 2062980 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
2021b80: 90 10 00 1d mov %i5, %o0
2021b84: 40 00 66 a2 call 203b60c <rtems_rfs_inode_close>
2021b88: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
2021b8c: ba 92 20 00 orcc %o0, 0, %i5
2021b90: 02 80 00 10 be 2021bd0 <rtems_rfs_rtems_eval_path+0x8c> <== ALWAYS TAKEN
2021b94: 01 00 00 00 nop
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
2021b98: 40 00 80 42 call 2041ca0 <__errno> <== NOT EXECUTED
2021b9c: 01 00 00 00 nop <== NOT EXECUTED
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
2021ba0: 92 10 3f ff mov -1, %o1 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
2021ba4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
2021ba8: 7f ff a0 ea call 2009f50 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2021bac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021bb0: 81 c7 e0 08 ret <== NOT EXECUTED
2021bb4: 81 e8 00 00 restore <== NOT EXECUTED
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
2021bb8: 40 00 80 3a call 2041ca0 <__errno> <== NOT EXECUTED
2021bbc: 01 00 00 00 nop <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
2021bc0: 92 10 3f ff mov -1, %o1 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
2021bc4: 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 (
2021bc8: 7f ff a0 e2 call 2009f50 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2021bcc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021bd0: 81 c7 e0 08 ret
2021bd4: 81 e8 00 00 restore
02021f74 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
2021f74: 9d e3 bf 90 save %sp, -112, %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);
2021f78: f8 06 60 0c ld [ %i1 + 0xc ], %i4
2021f7c: 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;
2021f80: c2 0f 20 07 ldub [ %i4 + 7 ], %g1
2021f84: 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(
2021f88: 90 10 00 19 mov %i1, %o0
2021f8c: b1 2e 20 08 sll %i0, 8, %i0
2021f90: 7f ff fc f3 call 202135c <rtems_rfs_inode_get_gid>
2021f94: 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);
2021f98: c2 0f 20 02 ldub [ %i4 + 2 ], %g1
2021f9c: d4 0f 20 03 ldub [ %i4 + 3 ], %o2
2021fa0: 83 28 60 08 sll %g1, 8, %g1
2021fa4: 97 2e 20 10 sll %i0, 0x10, %o3
2021fa8: 99 2a 20 10 sll %o0, 0x10, %o4
2021fac: 92 10 20 01 mov 1, %o1
2021fb0: 90 10 00 1d mov %i5, %o0
2021fb4: 94 12 80 01 or %o2, %g1, %o2
2021fb8: 97 32 e0 10 srl %o3, 0x10, %o3
2021fbc: 99 33 20 10 srl %o4, 0x10, %o4
2021fc0: 40 00 1b d0 call 2028f00 <rtems_filesystem_eval_path_check_access>
2021fc4: 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) {
2021fc8: 80 8a 20 ff btst 0xff, %o0
2021fcc: 02 80 00 09 be 2021ff0 <rtems_rfs_rtems_eval_token+0x7c>
2021fd0: 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] == '.';
2021fd4: 32 80 00 49 bne,a 20220f8 <rtems_rfs_rtems_eval_token+0x184>
2021fd8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2021fdc: c2 4e 80 00 ldsb [ %i2 ], %g1
2021fe0: 80 a0 60 2e cmp %g1, 0x2e
2021fe4: 32 80 00 45 bne,a 20220f8 <rtems_rfs_rtems_eval_token+0x184>
2021fe8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
2021fec: c0 27 60 0c clr [ %i5 + 0xc ]
2021ff0: 81 c7 e0 08 ret
2021ff4: 81 e8 00 00 restore
&entry_ino,
&entry_doff
);
if (rc == 0) {
rc = rtems_rfs_inode_close (fs, inode);
2021ff8: 90 10 00 1c mov %i4, %o0
2021ffc: 40 00 65 84 call 203b60c <rtems_rfs_inode_close>
2022000: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
2022004: 80 a2 20 00 cmp %o0, 0
2022008: 12 80 00 0a bne 2022030 <rtems_rfs_rtems_eval_token+0xbc> <== NEVER TAKEN
202200c: 90 10 00 19 mov %i1, %o0
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
2022010: d2 07 bf f4 ld [ %fp + -12 ], %o1
2022014: 90 10 00 1c mov %i4, %o0
2022018: 94 10 00 19 mov %i1, %o2
202201c: 40 00 65 0a call 203b444 <rtems_rfs_inode_open>
2022020: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
2022024: 80 a2 20 00 cmp %o0, 0
2022028: 02 80 00 41 be 202212c <rtems_rfs_rtems_eval_token+0x1b8> <== ALWAYS TAKEN
202202c: 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));
2022030: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022034: 40 00 8c e8 call 20453d4 <memset> <== NOT EXECUTED
2022038: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
202203c: 81 c7 e0 08 ret <== NOT EXECUTED
2022040: 91 e8 20 01 restore %g0, 1, %o0 <== 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)) {
2022044: 12 80 00 04 bne 2022054 <rtems_rfs_rtems_eval_token+0xe0>
2022048: 80 8e 20 ff btst 0xff, %i0
202204c: 12 80 00 20 bne 20220cc <rtems_rfs_rtems_eval_token+0x158>
2022050: 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;
2022054: 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);
2022058: f6 07 bf f4 ld [ %fp + -12 ], %i3
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
202205c: c2 27 bf fc st %g1, [ %fp + -4 ]
char *link = malloc(len + 1);
2022060: 7f ff 9b 46 call 2008d78 <malloc>
2022064: 90 10 24 01 mov 0x401, %o0
if (link != NULL) {
2022068: b4 92 20 00 orcc %o0, 0, %i2
202206c: 02 80 00 14 be 20220bc <rtems_rfs_rtems_eval_token+0x148> <== NEVER TAKEN
2022070: 94 10 00 1a mov %i2, %o2
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
2022074: 90 10 00 1c mov %i4, %o0
2022078: 92 10 00 1b mov %i3, %o1
202207c: 96 10 24 00 mov 0x400, %o3
2022080: 40 00 69 17 call 203c4dc <rtems_rfs_symlink_read>
2022084: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
2022088: 80 a2 20 00 cmp %o0, 0
202208c: 12 80 00 06 bne 20220a4 <rtems_rfs_rtems_eval_token+0x130><== NEVER TAKEN
2022090: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
2022094: d4 07 bf fc ld [ %fp + -4 ], %o2
2022098: 7f ff a0 90 call 200a2d8 <rtems_filesystem_eval_path_recursive>
202209c: 92 10 00 1a mov %i2, %o1
20220a0: 30 80 00 03 b,a 20220ac <rtems_rfs_rtems_eval_token+0x138>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
20220a4: 7f ff 9f ab call 2009f50 <rtems_filesystem_eval_path_error><== NOT EXECUTED
20220a8: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
free(link);
20220ac: 7f ff 99 b3 call 2008778 <free>
20220b0: 90 10 00 1a mov %i2, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20220b4: 81 c7 e0 08 ret
20220b8: 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);
20220bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20220c0: 10 80 00 2c b 2022170 <rtems_rfs_rtems_eval_token+0x1fc> <== NOT EXECUTED
20220c4: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
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;
20220c8: 90 07 60 18 add %i5, 0x18, %o0
20220cc: 40 00 00 ce call 2022404 <rtems_rfs_rtems_set_handlers>
20220d0: 92 10 00 19 mov %i1, %o1
20220d4: 80 8a 20 ff btst 0xff, %o0
20220d8: 02 80 00 20 be 2022158 <rtems_rfs_rtems_eval_token+0x1e4> <== NEVER TAKEN
20220dc: c2 07 bf f4 ld [ %fp + -12 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20220e0: 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);
20220e4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
20220e8: c2 07 bf f8 ld [ %fp + -8 ], %g1
20220ec: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
20220f0: 81 c7 e0 08 ret
20220f4: 81 e8 00 00 restore
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 (
20220f8: 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);
20220fc: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
2022100: 94 10 00 1a mov %i2, %o2
2022104: 90 10 00 1c mov %i4, %o0
2022108: 96 10 00 1b mov %i3, %o3
202210c: 98 07 bf f4 add %fp, -12, %o4
2022110: 40 00 55 2e call 20375c8 <rtems_rfs_dir_lookup_ino>
2022114: 9a 07 bf f8 add %fp, -8, %o5
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
2022118: 80 a2 20 00 cmp %o0, 0
202211c: 02 bf ff b7 be 2021ff8 <rtems_rfs_rtems_eval_token+0x84>
2022120: b0 10 20 02 mov 2, %i0
2022124: 81 c7 e0 08 ret
2022128: 81 e8 00 00 restore
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)
202212c: 7f ff fc bb call 2021418 <rtems_rfs_rtems_node_type_by_inode>
2022130: 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);
2022134: c4 07 60 04 ld [ %i5 + 4 ], %g2
2022138: c0 27 60 0c clr [ %i5 + 0xc ]
202213c: 80 a0 00 02 cmp %g0, %g2
2022140: b0 60 3f ff subx %g0, -1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
2022144: 80 a2 20 03 cmp %o0, 3
2022148: 12 bf ff e0 bne 20220c8 <rtems_rfs_rtems_eval_token+0x154>
202214c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2022150: 10 bf ff bd b 2022044 <rtems_rfs_rtems_eval_token+0xd0>
2022154: 80 88 60 10 btst 0x10, %g1
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
2022158: 40 00 7e d2 call 2041ca0 <__errno> <== NOT EXECUTED
202215c: 01 00 00 00 nop <== NOT EXECUTED
2022160: 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 (
2022164: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
2022168: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
202216c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2022170: 7f ff 9f 78 call 2009f50 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2022174: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2022178: 81 c7 e0 08 ret <== NOT EXECUTED
202217c: 81 e8 00 00 restore <== NOT EXECUTED
0202186c <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
202186c: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2021870: c2 06 20 18 ld [ %i0 + 0x18 ], %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);
2021874: 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);
2021878: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
202187c: 94 07 bf d8 add %fp, -40, %o2
2021880: 90 10 00 1d mov %i5, %o0
2021884: 40 00 66 f0 call 203b444 <rtems_rfs_inode_open>
2021888: 96 10 20 01 mov 1, %o3
if (rc)
202188c: b8 92 20 00 orcc %o0, 0, %i4
2021890: 02 80 00 07 be 20218ac <rtems_rfs_rtems_fchmod+0x40> <== ALWAYS TAKEN
2021894: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
2021898: 40 00 81 02 call 2041ca0 <__errno> <== NOT EXECUTED
202189c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20218a0: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20218a4: 81 c7 e0 08 ret <== NOT EXECUTED
20218a8: 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);
20218ac: f0 08 60 02 ldub [ %g1 + 2 ], %i0
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
20218b0: 40 00 18 5c call 2027a20 <geteuid>
20218b4: f8 08 60 03 ldub [ %g1 + 3 ], %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;
20218b8: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
20218bc: 91 2a 20 10 sll %o0, 0x10, %o0
20218c0: c6 08 60 07 ldub [ %g1 + 7 ], %g3
20218c4: c4 08 60 06 ldub [ %g1 + 6 ], %g2
20218c8: 85 28 a0 08 sll %g2, 8, %g2
20218cc: 84 10 80 03 or %g2, %g3, %g2
20218d0: 85 28 a0 10 sll %g2, 0x10, %g2
20218d4: 80 a0 80 08 cmp %g2, %o0
20218d8: 02 80 00 0e be 2021910 <rtems_rfs_rtems_fchmod+0xa4> <== ALWAYS TAKEN
20218dc: 87 32 20 10 srl %o0, 0x10, %g3
20218e0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
20218e4: 22 80 00 0c be,a 2021914 <rtems_rfs_rtems_fchmod+0xa8> <== NOT EXECUTED
20218e8: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
20218ec: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20218f0: 40 00 67 47 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
20218f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
20218f8: 40 00 80 ea call 2041ca0 <__errno> <== NOT EXECUTED
20218fc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021900: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2021904: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2021908: 81 c7 e0 08 ret
202190c: 81 e8 00 00 restore
* @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);
2021910: b0 0e 20 ff and %i0, 0xff, %i0
2021914: b8 0f 20 ff and %i4, 0xff, %i4
2021918: b1 2e 20 08 sll %i0, 8, %i0
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
202191c: b2 0e 6f ff and %i1, 0xfff, %i1
2021920: b8 16 00 1c or %i0, %i4, %i4
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
2021924: b8 0f 30 00 and %i4, -4096, %i4
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
2021928: 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);
202192c: 85 36 60 08 srl %i1, 8, %g2
2021930: c4 28 60 02 stb %g2, [ %g1 + 2 ]
2021934: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
2021938: 90 10 00 1d mov %i5, %o0
202193c: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2021940: 82 10 20 01 mov 1, %g1
2021944: 92 07 bf d8 add %fp, -40, %o1
2021948: c2 2f bf e8 stb %g1, [ %fp + -24 ]
202194c: 40 00 67 30 call 203b60c <rtems_rfs_inode_close>
2021950: b0 10 20 00 clr %i0
if (rc > 0)
2021954: 80 a2 20 00 cmp %o0, 0
2021958: 04 bf ff ec ble 2021908 <rtems_rfs_rtems_fchmod+0x9c> <== ALWAYS TAKEN
202195c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
2021960: 40 00 80 d0 call 2041ca0 <__errno> <== NOT EXECUTED
2021964: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021968: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
202196c: 81 c7 e0 08 ret <== NOT EXECUTED
2021970: 81 e8 00 00 restore <== NOT EXECUTED
020223d0 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
20223d0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
20223d4: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
20223d8: 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));
20223dc: 40 00 53 c0 call 20372dc <rtems_rfs_buffer_sync> <== NOT EXECUTED
20223e0: d0 00 60 20 ld [ %g1 + 0x20 ], %o0 <== NOT EXECUTED
if (rc)
20223e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20223e8: 02 80 00 05 be 20223fc <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
20223ec: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
20223f0: 40 00 7e 2c call 2041ca0 <__errno> <== NOT EXECUTED
20223f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20223f8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
20223fc: 81 c7 e0 08 ret <== NOT EXECUTED
2022400: 81 e8 00 00 restore <== NOT EXECUTED
0203d100 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
203d100: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203d104: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
203d108: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
203d10c: 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);
203d110: 7f ff fe ff call 203cd0c <rtems_rfs_rtems_lock>
203d114: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_file_close (fs, file);
203d118: 92 10 00 18 mov %i0, %o1
203d11c: 7f ff ed b4 call 20387ec <rtems_rfs_file_close>
203d120: 90 10 00 1d mov %i5, %o0
if (rc > 0)
203d124: b0 92 20 00 orcc %o0, 0, %i0
203d128: 04 80 00 06 ble 203d140 <rtems_rfs_rtems_file_close+0x40> <== ALWAYS TAKEN
203d12c: 01 00 00 00 nop
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
203d130: 40 00 12 dc call 2041ca0 <__errno> <== NOT EXECUTED
203d134: 01 00 00 00 nop <== NOT EXECUTED
203d138: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
203d13c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
203d140: 7f ff ff 0a call 203cd68 <rtems_rfs_rtems_unlock>
203d144: 90 10 00 1d mov %i5, %o0
return rc;
}
203d148: 81 c7 e0 08 ret
203d14c: 81 e8 00 00 restore
0203cdc4 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
203cdc4: 9d e3 bf a0 save %sp, -96, %sp
203cdc8: ba 10 00 1a mov %i2, %i5
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203cdcc: f4 06 20 28 ld [ %i0 + 0x28 ], %i2
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
203cdd0: b6 10 00 18 mov %i0, %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));
203cdd4: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
203cdd8: 7f ff ff cd call 203cd0c <rtems_rfs_rtems_lock>
203cddc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rc = rtems_rfs_file_set_size (file, length);
203cde0: 90 10 00 1a mov %i2, %o0
203cde4: 92 10 00 19 mov %i1, %o1
203cde8: 7f ff f0 98 call 2039048 <rtems_rfs_file_set_size>
203cdec: 94 10 00 1d mov %i5, %o2
if (rc)
203cdf0: b0 92 20 00 orcc %o0, 0, %i0
203cdf4: 22 80 00 07 be,a 203ce10 <rtems_rfs_rtems_file_ftruncate+0x4c><== ALWAYS TAKEN
203cdf8: d2 06 a0 1c ld [ %i2 + 0x1c ], %o1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
203cdfc: 40 00 13 a9 call 2041ca0 <__errno> <== NOT EXECUTED
203ce00: 01 00 00 00 nop <== NOT EXECUTED
203ce04: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
203ce08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
203ce0c: d2 06 a0 1c ld [ %i2 + 0x1c ], %o1 <== NOT EXECUTED
203ce10: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203ce14: 7f ff e4 23 call 2035ea0 <rtems_rfs_block_get_size>
203ce18: 92 02 60 84 add %o1, 0x84, %o1
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203ce1c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_rfs_file_set_size (file, length);
if (rc)
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
iop->size = rtems_rfs_file_size (file);
203ce20: d0 3e e0 08 std %o0, [ %i3 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203ce24: 7f ff ff d1 call 203cd68 <rtems_rfs_rtems_unlock>
203ce28: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return rc;
}
203ce2c: 81 c7 e0 08 ret
203ce30: 81 e8 00 00 restore
0203cd04 <rtems_rfs_rtems_file_ioctl>:
static int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
return 0;
}
203cd04: 81 c3 e0 08 retl <== NOT EXECUTED
203cd08: 90 10 20 00 clr %o0 <== NOT EXECUTED
0203ce34 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
203ce34: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203ce38: fa 06 20 28 ld [ %i0 + 0x28 ], %i5
int rc;
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));
203ce3c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
203ce40: 7f ff ff b3 call 203cd0c <rtems_rfs_rtems_lock>
203ce44: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
203ce48: c4 1e 20 10 ldd [ %i0 + 0x10 ], %g2
rc = rtems_rfs_file_seek (file, pos, &pos);
203ce4c: 90 10 00 1d mov %i5, %o0
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));
pos = iop->offset;
203ce50: c4 3f bf f8 std %g2, [ %fp + -8 ]
rc = rtems_rfs_file_seek (file, pos, &pos);
203ce54: 92 10 00 02 mov %g2, %o1
203ce58: 94 10 00 03 mov %g3, %o2
203ce5c: 7f ff f0 3c call 2038f4c <rtems_rfs_file_seek>
203ce60: 96 07 bf f8 add %fp, -8, %o3
203ce64: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (rc)
203ce68: b8 92 20 00 orcc %o0, 0, %i4
203ce6c: 02 80 00 09 be 203ce90 <rtems_rfs_rtems_file_lseek+0x5c> <== ALWAYS TAKEN
203ce70: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203ce74: 7f ff ff bd call 203cd68 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203ce78: 31 3f ff ff sethi %hi(0xfffffc00), %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
203ce7c: 40 00 13 89 call 2041ca0 <__errno> <== NOT EXECUTED
203ce80: b0 16 23 ff or %i0, 0x3ff, %i0 ! ffffffff <RAM_END+0xfdbfffff><== NOT EXECUTED
203ce84: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203ce88: 81 c7 e0 08 ret <== NOT EXECUTED
203ce8c: 93 e8 00 18 restore %g0, %i0, %o1 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203ce90: 7f ff ff b6 call 203cd68 <rtems_rfs_rtems_unlock>
203ce94: 01 00 00 00 nop
return iop->offset;
203ce98: f0 1e 20 10 ldd [ %i0 + 0x10 ], %i0
}
203ce9c: 81 c7 e0 08 ret
203cea0: 81 e8 00 00 restore
0203d150 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
203d150: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203d154: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
203d158: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
203d15c: 7f ff fe ec call 203cd0c <rtems_rfs_rtems_lock>
203d160: 90 10 00 1d mov %i5, %o0
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
203d164: d2 06 20 24 ld [ %i0 + 0x24 ], %o1
203d168: 90 10 00 1d mov %i5, %o0
203d16c: 94 10 20 00 clr %o2
203d170: 7f ff f0 82 call 2039378 <rtems_rfs_file_open>
203d174: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
203d178: b8 92 20 00 orcc %o0, 0, %i4
203d17c: 04 80 00 09 ble 203d1a0 <rtems_rfs_rtems_file_open+0x50> <== ALWAYS TAKEN
203d180: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rtems_rfs_rtems_unlock (fs);
203d184: 7f ff fe f9 call 203cd68 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d188: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
203d18c: 40 00 12 c5 call 2041ca0 <__errno> <== NOT EXECUTED
203d190: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d194: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203d198: 81 c7 e0 08 ret <== NOT EXECUTED
203d19c: 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);
iop->size = rtems_rfs_file_size (file);
203d1a0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
203d1a4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203d1a8: 7f ff e3 3e call 2035ea0 <rtems_rfs_block_get_size>
203d1ac: 92 02 60 84 add %o1, 0x84, %o1
rtems_rfs_rtems_set_iop_file_handle (iop, file);
203d1b0: c2 07 bf fc ld [ %fp + -4 ], %g1
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
203d1b4: d0 3e 20 08 std %o0, [ %i0 + 8 ]
rtems_rfs_rtems_set_iop_file_handle (iop, file);
203d1b8: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
rtems_rfs_rtems_unlock (fs);
203d1bc: 90 10 00 1d mov %i5, %o0
203d1c0: 7f ff fe ea call 203cd68 <rtems_rfs_rtems_unlock>
203d1c4: b0 10 20 00 clr %i0
return 0;
}
203d1c8: 81 c7 e0 08 ret
203d1cc: 81 e8 00 00 restore
0203d004 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
203d004: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203d008: fa 06 20 28 ld [ %i0 + 0x28 ], %i5
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));
203d00c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
203d010: 7f ff ff 3f call 203cd0c <rtems_rfs_rtems_lock>
203d014: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
203d018: d2 07 60 1c ld [ %i5 + 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;
203d01c: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
203d020: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203d024: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
203d028: 7f ff e3 9e call 2035ea0 <rtems_rfs_block_get_size>
203d02c: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
203d030: 80 a2 00 1c cmp %o0, %i4
203d034: 38 80 00 2b bgu,a 203d0e0 <rtems_rfs_rtems_file_read+0xdc><== NEVER TAKEN
203d038: b0 10 20 00 clr %i0 <== NOT EXECUTED
203d03c: 80 a2 00 1c cmp %o0, %i4
203d040: 12 80 00 04 bne 203d050 <rtems_rfs_rtems_file_read+0x4c> <== NEVER TAKEN
203d044: 80 a2 40 18 cmp %o1, %i0
203d048: 38 80 00 26 bgu,a 203d0e0 <rtems_rfs_rtems_file_read+0xdc><== ALWAYS TAKEN
203d04c: b0 10 20 00 clr %i0
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
uint8_t* data = buffer;
ssize_t read = 0;
203d050: 10 80 00 27 b 203d0ec <rtems_rfs_rtems_file_read+0xe8> <== NOT EXECUTED
203d054: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
203d058: 92 07 bf fc add %fp, -4, %o1
203d05c: 7f ff ee 90 call 2038a9c <rtems_rfs_file_io_start>
203d060: 94 10 20 01 mov 1, %o2
if (rc > 0)
203d064: b8 92 20 00 orcc %o0, 0, %i4
203d068: 14 80 00 1a bg 203d0d0 <rtems_rfs_rtems_file_read+0xcc> <== NEVER TAKEN
203d06c: 01 00 00 00 nop
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
203d070: c2 07 bf fc ld [ %fp + -4 ], %g1
203d074: 80 a0 60 00 cmp %g1, 0
203d078: 02 80 00 1d be 203d0ec <rtems_rfs_rtems_file_read+0xe8> <== NEVER TAKEN
203d07c: 80 a0 40 1a cmp %g1, %i2
break;
if (size > count)
203d080: 38 80 00 02 bgu,a 203d088 <rtems_rfs_rtems_file_read+0x84><== NEVER TAKEN
203d084: f4 27 bf fc st %i2, [ %fp + -4 ] <== NOT EXECUTED
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
203d088: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203d08c: f8 07 bf fc ld [ %fp + -4 ], %i4
203d090: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
203d094: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
203d098: 94 10 00 1c mov %i4, %o2
203d09c: 92 02 40 01 add %o1, %g1, %o1
203d0a0: 40 00 20 41 call 20451a4 <memcpy>
203d0a4: 90 10 00 19 mov %i1, %o0
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
203d0a8: 92 10 00 1c mov %i4, %o1
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
203d0ac: b2 06 40 1c add %i1, %i4, %i1
count -= size;
203d0b0: b4 26 80 1c sub %i2, %i4, %i2
read += size;
203d0b4: b0 06 00 1c add %i0, %i4, %i0
rc = rtems_rfs_file_io_end (file, size, true);
203d0b8: 90 10 00 1d mov %i5, %o0
203d0bc: 7f ff ee fd call 2038cb0 <rtems_rfs_file_io_end>
203d0c0: 94 10 20 01 mov 1, %o2
if (rc > 0)
203d0c4: b8 92 20 00 orcc %o0, 0, %i4
203d0c8: 04 80 00 07 ble 203d0e4 <rtems_rfs_rtems_file_read+0xe0> <== ALWAYS TAKEN
203d0cc: 80 a6 a0 00 cmp %i2, 0
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
203d0d0: 40 00 12 f4 call 2041ca0 <__errno> <== NOT EXECUTED
203d0d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d0d8: 10 80 00 05 b 203d0ec <rtems_rfs_rtems_file_read+0xe8> <== NOT EXECUTED
203d0dc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
203d0e0: 80 a6 a0 00 cmp %i2, 0
203d0e4: 12 bf ff dd bne 203d058 <rtems_rfs_rtems_file_read+0x54>
203d0e8: 90 10 00 1d mov %i5, %o0
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d0ec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
203d0f0: 7f ff ff 1e call 203cd68 <rtems_rfs_rtems_unlock>
203d0f4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return read;
}
203d0f8: 81 c7 e0 08 ret
203d0fc: 81 e8 00 00 restore
0203cea4 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
203cea4: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203cea8: e0 06 20 28 ld [ %i0 + 0x28 ], %l0
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
203ceac: b6 10 00 18 mov %i0, %i3
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));
203ceb0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
203ceb4: 7f ff ff 96 call 203cd0c <rtems_rfs_rtems_lock>
203ceb8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
203cebc: d2 04 20 1c ld [ %l0 + 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;
203cec0: f8 1e 20 10 ldd [ %i0 + 0x10 ], %i4
203cec4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203cec8: 7f ff e3 f6 call 2035ea0 <rtems_rfs_block_get_size>
203cecc: 92 02 60 84 add %o1, 0x84, %o1
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
203ced0: 80 a2 00 1c cmp %o0, %i4
203ced4: 38 80 00 18 bgu,a 203cf34 <rtems_rfs_rtems_file_write+0x90><== NEVER TAKEN
203ced8: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
203cedc: 80 a2 00 1c cmp %o0, %i4
203cee0: 12 80 00 06 bne 203cef8 <rtems_rfs_rtems_file_write+0x54> <== NEVER TAKEN
203cee4: 86 87 60 01 addcc %i5, 1, %g3
203cee8: 80 a2 40 1d cmp %o1, %i5
203ceec: 38 80 00 12 bgu,a 203cf34 <rtems_rfs_rtems_file_write+0x90>
203cef0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
{
rc = rtems_rfs_file_set_size (file, pos + 1);
203cef4: 86 87 60 01 addcc %i5, 1, %g3
203cef8: 84 47 20 00 addx %i4, 0, %g2
203cefc: 90 10 00 10 mov %l0, %o0
203cf00: 92 10 00 02 mov %g2, %o1
203cf04: 7f ff f0 51 call 2039048 <rtems_rfs_file_set_size>
203cf08: 94 10 00 03 mov %g3, %o2
if (rc)
203cf0c: b0 92 20 00 orcc %o0, 0, %i0
203cf10: 02 80 00 09 be 203cf34 <rtems_rfs_rtems_file_write+0x90> <== ALWAYS TAKEN
203cf14: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203cf18: 7f ff ff 94 call 203cd68 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203cf1c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
203cf20: 40 00 13 60 call 2041ca0 <__errno> <== NOT EXECUTED
203cf24: 01 00 00 00 nop <== NOT EXECUTED
203cf28: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
203cf2c: 81 c7 e0 08 ret <== NOT EXECUTED
203cf30: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
203cf34: 92 10 00 1c mov %i4, %o1
203cf38: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
203cf3c: 94 10 00 1d mov %i5, %o2
203cf40: 96 04 20 10 add %l0, 0x10, %o3
203cf44: 7f ff e3 a7 call 2035de0 <rtems_rfs_block_get_bpos>
203cf48: b0 10 20 00 clr %i0
while (count)
203cf4c: 10 80 00 22 b 203cfd4 <rtems_rfs_rtems_file_write+0x130>
203cf50: 80 a6 a0 00 cmp %i2, 0
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
203cf54: 90 10 00 10 mov %l0, %o0
203cf58: 92 07 bf fc add %fp, -4, %o1
203cf5c: 7f ff ee d0 call 2038a9c <rtems_rfs_file_io_start>
203cf60: 94 10 20 00 clr %o2
if (rc)
203cf64: b8 92 20 00 orcc %o0, 0, %i4
203cf68: 12 80 00 17 bne 203cfc4 <rtems_rfs_rtems_file_write+0x120>
203cf6c: 01 00 00 00 nop
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
203cf70: c2 07 bf fc ld [ %fp + -4 ], %g1
203cf74: 80 a0 40 1a cmp %g1, %i2
203cf78: 38 80 00 02 bgu,a 203cf80 <rtems_rfs_rtems_file_write+0xdc>
203cf7c: f4 27 bf fc st %i2, [ %fp + -4 ]
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
203cf80: c2 04 20 0c ld [ %l0 + 0xc ], %g1
203cf84: d4 07 bf fc ld [ %fp + -4 ], %o2
203cf88: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
203cf8c: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
203cf90: 92 10 00 19 mov %i1, %o1
203cf94: 40 00 20 84 call 20451a4 <memcpy>
203cf98: 90 02 00 01 add %o0, %g1, %o0
data += size;
203cf9c: d2 07 bf fc ld [ %fp + -4 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
203cfa0: 90 10 00 10 mov %l0, %o0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
203cfa4: b2 06 40 09 add %i1, %o1, %i1
count -= size;
203cfa8: b4 26 80 09 sub %i2, %o1, %i2
write += size;
203cfac: b0 06 00 09 add %i0, %o1, %i0
rc = rtems_rfs_file_io_end (file, size, false);
203cfb0: 7f ff ef 40 call 2038cb0 <rtems_rfs_file_io_end>
203cfb4: 94 10 20 00 clr %o2
if (rc)
203cfb8: b8 92 20 00 orcc %o0, 0, %i4
203cfbc: 02 80 00 06 be 203cfd4 <rtems_rfs_rtems_file_write+0x130> <== ALWAYS TAKEN
203cfc0: 80 a6 a0 00 cmp %i2, 0
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
203cfc4: 40 00 13 37 call 2041ca0 <__errno>
203cfc8: b0 10 3f ff mov -1, %i0
203cfcc: 10 80 00 04 b 203cfdc <rtems_rfs_rtems_file_write+0x138>
203cfd0: f8 22 00 00 st %i4, [ %o0 ]
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
203cfd4: 32 bf ff e0 bne,a 203cf54 <rtems_rfs_rtems_file_write+0xb0>
203cfd8: f4 27 bf fc st %i2, [ %fp + -4 ]
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
203cfdc: d2 04 20 1c ld [ %l0 + 0x1c ], %o1
203cfe0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203cfe4: 7f ff e3 af call 2035ea0 <rtems_rfs_block_get_size>
203cfe8: 92 02 60 84 add %o1, 0x84, %o1
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203cfec: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
203cff0: d0 3e e0 08 std %o0, [ %i3 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203cff4: 7f ff ff 5d call 203cd68 <rtems_rfs_rtems_unlock>
203cff8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return write;
}
203cffc: 81 c7 e0 08 ret
203d000: 81 e8 00 00 restore
02021c64 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
2021c64: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2021c68: c2 06 20 18 ld [ %i0 + 0x18 ], %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);
2021c6c: 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);
2021c70: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
2021c74: 94 07 bf d8 add %fp, -40, %o2
2021c78: 90 10 00 1d mov %i5, %o0
2021c7c: 40 00 65 f2 call 203b444 <rtems_rfs_inode_open>
2021c80: 96 10 20 01 mov 1, %o3
if (rc)
2021c84: b8 92 20 00 orcc %o0, 0, %i4
2021c88: 02 80 00 07 be 2021ca4 <rtems_rfs_rtems_fstat+0x40> <== ALWAYS TAKEN
2021c8c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
2021c90: 40 00 80 04 call 2041ca0 <__errno> <== NOT EXECUTED
2021c94: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021c98: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2021c9c: 81 c7 e0 08 ret
2021ca0: 81 e8 00 00 restore
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
2021ca4: 05 00 00 18 sethi %hi(0x6000), %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);
2021ca8: f8 08 60 02 ldub [ %g1 + 2 ], %i4
2021cac: c2 08 60 03 ldub [ %g1 + 3 ], %g1
2021cb0: b9 2f 20 08 sll %i4, 8, %i4
2021cb4: b8 10 40 1c or %g1, %i4, %i4
2021cb8: 03 00 00 3c sethi %hi(0xf000), %g1
2021cbc: 82 0f 00 01 and %i4, %g1, %g1
2021cc0: 80 a0 40 02 cmp %g1, %g2
2021cc4: 02 80 00 07 be 2021ce0 <rtems_rfs_rtems_fstat+0x7c> <== NEVER TAKEN
2021cc8: 92 10 20 00 clr %o1
2021ccc: 05 00 00 08 sethi %hi(0x2000), %g2
2021cd0: 80 a0 40 02 cmp %g1, %g2
2021cd4: 32 80 00 0c bne,a 2021d04 <rtems_rfs_rtems_fstat+0xa0> <== ALWAYS TAKEN
2021cd8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
2021cdc: 92 10 20 00 clr %o1 <== NOT EXECUTED
2021ce0: 7f ff fd a7 call 202137c <rtems_rfs_inode_get_block> <== NOT EXECUTED
2021ce4: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2021ce8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2021cec: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
2021cf0: 7f ff fd a3 call 202137c <rtems_rfs_inode_get_block> <== NOT EXECUTED
2021cf4: 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 =
2021cf8: f6 26 60 18 st %i3, [ %i1 + 0x18 ] <== NOT EXECUTED
2021cfc: 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);
2021d00: 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);
2021d04: 90 10 00 1c mov %i4, %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);
2021d08: c2 26 60 04 st %g1, [ %i1 + 4 ]
2021d0c: 83 38 60 1f sra %g1, 0x1f, %g1
2021d10: c2 26 40 00 st %g1, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
2021d14: c2 07 bf e0 ld [ %fp + -32 ], %g1
buf->st_mode = rtems_rfs_rtems_mode (mode);
2021d18: 40 00 01 ec call 20224c8 <rtems_rfs_rtems_mode>
2021d1c: 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);
2021d20: c2 07 bf e4 ld [ %fp + -28 ], %g1
2021d24: d0 26 60 0c st %o0, [ %i1 + 0xc ]
2021d28: c6 08 60 01 ldub [ %g1 + 1 ], %g3
2021d2c: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
2021d30: 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);
2021d34: 85 28 a0 08 sll %g2, 8, %g2
2021d38: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
2021d3c: 87 28 a0 10 sll %g2, 0x10, %g3
2021d40: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
2021d44: 86 39 00 03 xnor %g4, %g3, %g3
2021d48: 80 a0 00 03 cmp %g0, %g3
2021d4c: 86 60 20 00 subx %g0, 0, %g3
2021d50: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
2021d54: 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;
2021d58: c6 08 60 06 ldub [ %g1 + 6 ], %g3
2021d5c: c4 08 60 07 ldub [ %g1 + 7 ], %g2
2021d60: 87 28 e0 08 sll %g3, 8, %g3
2021d64: 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);
2021d68: 90 07 bf d8 add %fp, -40, %o0
2021d6c: 7f ff fd 7c call 202135c <rtems_rfs_inode_get_gid>
2021d70: 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));
2021d74: 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);
2021d78: 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));
2021d7c: 40 00 5d 71 call 2039340 <rtems_rfs_file_get_shared>
2021d80: 90 10 00 1d mov %i5, %o0
if (shared)
2021d84: 92 92 20 00 orcc %o0, 0, %o1
2021d88: 02 80 00 17 be 2021de4 <rtems_rfs_rtems_fstat+0x180>
2021d8c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
2021d90: 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))
2021d94: 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);
2021d98: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
2021d9c: c2 02 60 90 ld [ %o1 + 0x90 ], %g1
2021da0: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
2021da4: c2 02 60 94 ld [ %o1 + 0x94 ], %g1
2021da8: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
2021dac: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
2021db0: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
2021db4: 03 00 00 3c sethi %hi(0xf000), %g1
2021db8: 84 08 80 01 and %g2, %g1, %g2
2021dbc: 03 00 00 28 sethi %hi(0xa000), %g1
2021dc0: 80 a0 80 01 cmp %g2, %g1
2021dc4: 12 80 00 04 bne 2021dd4 <rtems_rfs_rtems_fstat+0x170> <== ALWAYS TAKEN
2021dc8: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
2021dcc: 10 80 00 3d b 2021ec0 <rtems_rfs_rtems_fstat+0x25c> <== NOT EXECUTED
2021dd0: 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);
2021dd4: 40 00 50 33 call 2035ea0 <rtems_rfs_block_get_size>
2021dd8: 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);
2021ddc: 10 80 00 3f b 2021ed8 <rtems_rfs_rtems_fstat+0x274>
2021de0: 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);
2021de4: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
2021de8: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
2021dec: 87 28 e0 18 sll %g3, 0x18, %g3
2021df0: 85 28 a0 10 sll %g2, 0x10, %g2
2021df4: 84 10 c0 02 or %g3, %g2, %g2
2021df8: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
2021dfc: 84 10 80 03 or %g2, %g3, %g2
2021e00: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
2021e04: 87 28 e0 08 sll %g3, 8, %g3
2021e08: 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);
2021e0c: 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);
2021e10: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
2021e14: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
2021e18: 87 28 e0 18 sll %g3, 0x18, %g3
2021e1c: 85 28 a0 10 sll %g2, 0x10, %g2
2021e20: 84 10 c0 02 or %g3, %g2, %g2
2021e24: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
2021e28: 84 10 80 03 or %g2, %g3, %g2
2021e2c: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
2021e30: 87 28 e0 08 sll %g3, 8, %g3
2021e34: 84 10 80 03 or %g2, %g3, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
2021e38: 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);
2021e3c: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
2021e40: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
2021e44: 87 28 e0 18 sll %g3, 0x18, %g3
2021e48: 85 28 a0 10 sll %g2, 0x10, %g2
2021e4c: 84 10 c0 02 or %g3, %g2, %g2
2021e50: c6 08 60 1b ldub [ %g1 + 0x1b ], %g3
2021e54: 84 10 80 03 or %g2, %g3, %g2
2021e58: c6 08 60 1a ldub [ %g1 + 0x1a ], %g3
2021e5c: 87 28 e0 08 sll %g3, 8, %g3
2021e60: 84 10 80 03 or %g2, %g3, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
2021e64: 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);
2021e68: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2021e6c: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
2021e70: 87 28 e0 18 sll %g3, 0x18, %g3
2021e74: 85 28 a0 10 sll %g2, 0x10, %g2
2021e78: 84 10 c0 02 or %g3, %g2, %g2
2021e7c: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
2021e80: 84 10 80 03 or %g2, %g3, %g2
2021e84: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
2021e88: 87 28 e0 08 sll %g3, 8, %g3
2021e8c: 84 10 80 03 or %g2, %g3, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
2021e90: 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);
2021e94: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
2021e98: 05 00 00 3c sethi %hi(0xf000), %g2
2021e9c: 86 08 c0 02 and %g3, %g2, %g3
2021ea0: 05 00 00 28 sethi %hi(0xa000), %g2
2021ea4: 80 a0 c0 02 cmp %g3, %g2
2021ea8: 12 80 00 09 bne 2021ecc <rtems_rfs_rtems_fstat+0x268>
2021eac: 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);
2021eb0: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
2021eb4: c2 08 60 0b ldub [ %g1 + 0xb ], %g1
2021eb8: 85 28 a0 08 sll %g2, 8, %g2
2021ebc: 82 10 40 02 or %g1, %g2, %g1
2021ec0: c0 26 60 20 clr [ %i1 + 0x20 ]
2021ec4: 10 80 00 05 b 2021ed8 <rtems_rfs_rtems_fstat+0x274>
2021ec8: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
2021ecc: 40 00 67 74 call 203bc9c <rtems_rfs_inode_get_size>
2021ed0: 92 07 bf d8 add %fp, -40, %o1
2021ed4: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
2021ed8: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
2021edc: 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);
2021ee0: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
2021ee4: 92 07 bf d8 add %fp, -40, %o1
2021ee8: 40 00 65 c9 call 203b60c <rtems_rfs_inode_close>
2021eec: b0 10 20 00 clr %i0
if (rc > 0)
2021ef0: 80 a2 20 00 cmp %o0, 0
2021ef4: 04 bf ff 6a ble 2021c9c <rtems_rfs_rtems_fstat+0x38> <== ALWAYS TAKEN
2021ef8: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
2021efc: 40 00 7f 69 call 2041ca0 <__errno> <== NOT EXECUTED
2021f00: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021f04: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021f08: 81 c7 e0 08 ret <== NOT EXECUTED
2021f0c: 81 e8 00 00 restore <== NOT EXECUTED
020221f8 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
20221f8: 9d e3 bf 98 save %sp, -104, %sp
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
20221fc: 23 00 81 8a sethi %hi(0x2062800), %l1
if (strncmp (options, "hold-bitmaps",
2022200: 21 00 81 8a sethi %hi(0x2062800), %l0
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2022204: 35 00 81 8a sethi %hi(0x2062800), %i2
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
2022208: 3b 00 81 8a sethi %hi(0x2062800), %i5
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;
202220c: 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;
2022210: b8 10 20 00 clr %i4
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2022214: a2 14 60 c0 or %l1, 0xc0, %l1
if (strncmp (options, "hold-bitmaps",
2022218: a0 14 20 d0 or %l0, 0xd0, %l0
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
202221c: b4 16 a0 e0 or %i2, 0xe0, %i2
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2022220: 10 80 00 2f b 20222dc <rtems_rfs_rtems_initialise+0xe4>
2022224: ba 17 60 f0 or %i5, 0xf0, %i5
{
printf ("options=%s\n", options);
2022228: 40 00 90 d7 call 2046584 <printf> <== NOT EXECUTED
202222c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
2022230: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2022234: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2022238: 40 00 9b 28 call 2048ed8 <strncmp> <== NOT EXECUTED
202223c: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
2022240: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022244: 12 80 00 04 bne 2022254 <rtems_rfs_rtems_initialise+0x5c> <== NOT EXECUTED
2022248: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
202224c: 10 80 00 1a b 20222b4 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2022250: b8 17 20 01 or %i4, 1, %i4 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
2022254: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2022258: 40 00 9b 20 call 2048ed8 <strncmp> <== NOT EXECUTED
202225c: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
2022260: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022264: 12 80 00 04 bne 2022274 <rtems_rfs_rtems_initialise+0x7c> <== NOT EXECUTED
2022268: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
202226c: 10 80 00 12 b 20222b4 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2022270: b8 17 20 02 or %i4, 2, %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
2022274: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022278: 40 00 9b 18 call 2048ed8 <strncmp> <== NOT EXECUTED
202227c: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
2022280: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022284: 12 80 00 07 bne 20222a0 <rtems_rfs_rtems_initialise+0xa8> <== NOT EXECUTED
2022288: 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);
202228c: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
2022290: 40 00 a1 1d call 204a704 <strtoul> <== NOT EXECUTED
2022294: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022298: 10 80 00 06 b 20222b0 <rtems_rfs_rtems_initialise+0xb8> <== NOT EXECUTED
202229c: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
20222a0: 40 00 7e 80 call 2041ca0 <__errno> <== NOT EXECUTED
20222a4: 01 00 00 00 nop <== NOT EXECUTED
20222a8: 10 80 00 18 b 2022308 <rtems_rfs_rtems_initialise+0x110> <== NOT EXECUTED
20222ac: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
options = strchr (options, ',');
20222b0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20222b4: 40 00 98 15 call 2048308 <strchr> <== NOT EXECUTED
20222b8: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
20222bc: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
20222c0: 02 80 00 0a be 20222e8 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
20222c4: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
20222c8: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1 <== NOT EXECUTED
20222cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20222d0: 02 80 00 06 be 20222e8 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
20222d4: 01 00 00 00 nop <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
20222d8: b2 06 60 01 inc %i1 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
20222dc: 80 a6 60 00 cmp %i1, 0
20222e0: 12 bf ff d2 bne 2022228 <rtems_rfs_rtems_initialise+0x30> <== NEVER TAKEN
20222e4: 92 10 00 19 mov %i1, %o1
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
20222e8: 7f ff 9a a4 call 2008d78 <malloc>
20222ec: 90 10 20 04 mov 4, %o0
if (!rtems)
20222f0: ba 92 20 00 orcc %o0, 0, %i5
20222f4: 12 80 00 07 bne 2022310 <rtems_rfs_rtems_initialise+0x118><== ALWAYS TAKEN
20222f8: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
20222fc: 40 00 7e 69 call 2041ca0 <__errno> <== NOT EXECUTED
2022300: 01 00 00 00 nop <== NOT EXECUTED
2022304: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2022308: 10 80 00 22 b 2022390 <rtems_rfs_rtems_initialise+0x198> <== NOT EXECUTED
202230c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
2022310: 40 00 68 e5 call 203c6a4 <rtems_rfs_mutex_create>
2022314: c0 27 40 00 clr [ %i5 ]
if (rc > 0)
2022318: b4 92 20 00 orcc %o0, 0, %i2
202231c: 14 80 00 09 bg 2022340 <rtems_rfs_rtems_initialise+0x148> <== NEVER TAKEN
2022320: 01 00 00 00 nop
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
2022324: 7f ff ff 97 call 2022180 <rtems_rfs_mutex_lock.isra.3>
2022328: d0 07 40 00 ld [ %i5 ], %o0
if (rc > 0)
202232c: b4 92 20 00 orcc %o0, 0, %i2
2022330: 24 80 00 0b ble,a 202235c <rtems_rfs_rtems_initialise+0x164><== ALWAYS TAKEN
2022334: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
{
rtems_rfs_mutex_destroy (&rtems->access);
2022338: 40 00 68 f6 call 203c710 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
202233c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free (rtems);
2022340: 7f ff 99 0e call 2008778 <free> <== NOT EXECUTED
2022344: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
2022348: 40 00 7e 56 call 2041ca0 <__errno> <== NOT EXECUTED
202234c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2022350: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
2022354: 81 c7 e0 08 ret <== NOT EXECUTED
2022358: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
202235c: 94 10 00 1c mov %i4, %o2
2022360: 92 10 00 1d mov %i5, %o1
2022364: 96 10 00 1b mov %i3, %o3
2022368: 40 00 5c cd call 203969c <rtems_rfs_fs_open>
202236c: 98 07 bf fc add %fp, -4, %o4
if (rc)
2022370: b8 92 20 00 orcc %o0, 0, %i4
2022374: 02 80 00 09 be 2022398 <rtems_rfs_rtems_initialise+0x1a0> <== ALWAYS TAKEN
2022378: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
202237c: 7f ff 98 ff call 2008778 <free> <== NOT EXECUTED
2022380: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
2022384: 40 00 7e 47 call 2041ca0 <__errno> <== NOT EXECUTED
2022388: 01 00 00 00 nop <== NOT EXECUTED
202238c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2022390: 81 c7 e0 08 ret <== NOT EXECUTED
2022394: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
mt_entry->fs_info = fs;
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
2022398: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
202239c: d0 26 20 20 st %o0, [ %i0 + 0x20 ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
20223a0: 84 10 20 01 mov 1, %g2
20223a4: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
20223a8: 05 00 81 a3 sethi %hi(0x2068c00), %g2
20223ac: 84 10 a3 d0 or %g2, 0x3d0, %g2 ! 2068fd0 <rtems_rfs_rtems_dir_handlers>
20223b0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
mt_entry->mt_fs_root->location.ops = &rtems_rfs_ops;
20223b4: 05 00 81 8a sethi %hi(0x2062800), %g2
20223b8: 84 10 a1 00 or %g2, 0x100, %g2 ! 2062900 <rtems_rfs_ops>
rtems_rfs_rtems_unlock (fs);
return 0;
20223bc: b0 10 20 00 clr %i0
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
mt_entry->mt_fs_root->location.ops = &rtems_rfs_ops;
rtems_rfs_rtems_unlock (fs);
20223c0: 7f ff fe 06 call 2021bd8 <rtems_rfs_rtems_unlock>
20223c4: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return 0;
}
20223c8: 81 c7 e0 08 ret
20223cc: 81 e8 00 00 restore
02021524 <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)
{
2021524: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
2021528: c2 06 60 18 ld [ %i1 + 0x18 ], %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);
202152c: d6 06 20 08 ld [ %i0 + 8 ], %o3
2021530: d8 06 60 08 ld [ %i1 + 8 ], %o4
2021534: d0 00 60 20 ld [ %g1 + 0x20 ], %o0
2021538: 92 10 00 1a mov %i2, %o1
202153c: 94 10 00 1b mov %i3, %o2
2021540: 9a 10 20 00 clr %o5
2021544: 40 00 69 fd call 203bd38 <rtems_rfs_link>
2021548: b0 10 20 00 clr %i0
if (rc)
202154c: 80 a2 20 00 cmp %o0, 0
2021550: 02 80 00 05 be 2021564 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
2021554: b2 10 00 08 mov %o0, %i1
{
return rtems_rfs_rtems_error ("link: linking", rc);
2021558: 40 00 81 d2 call 2041ca0 <__errno> <== NOT EXECUTED
202155c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021560: f2 22 00 00 st %i1, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021564: 81 c7 e0 08 ret
2021568: 81 e8 00 00 restore
0203ca6c <rtems_rfs_rtems_lock>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
203ca6c: 9d e3 bf a0 save %sp, -96, %sp
.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
};
203ca70: 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);
203ca74: 92 10 20 00 clr %o1
203ca78: d0 00 40 00 ld [ %g1 ], %o0
203ca7c: 7f ff 41 b0 call 200d13c <rtems_semaphore_obtain>
203ca80: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
203ca84: ba 92 20 00 orcc %o0, 0, %i5
203ca88: 02 80 00 0e be 203cac0 <rtems_rfs_rtems_lock+0x54> <== ALWAYS TAKEN
203ca8c: 01 00 00 00 nop
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203ca90: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
203ca94: 7f ff 9b 05 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203ca98: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203ca9c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203caa0: 02 80 00 08 be 203cac0 <rtems_rfs_rtems_lock+0x54> <== NOT EXECUTED
203caa4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
203caa8: 7f ff 2e 9d call 200851c <rtems_status_text> <== NOT EXECUTED
203caac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203cab0: 31 00 81 8a sethi %hi(0x2062800), %i0 <== NOT EXECUTED
203cab4: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
203cab8: 40 00 26 b3 call 2046584 <printf> <== NOT EXECUTED
203cabc: 91 ee 20 98 restore %i0, 0x98, %o0 <== NOT EXECUTED
203cac0: 81 c7 e0 08 ret
203cac4: 81 e8 00 00 restore
020219ec <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)
{
20219ec: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
20219f0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
20219f4: f0 06 20 08 ld [ %i0 + 8 ], %i0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
20219f8: 40 00 18 0a call 2027a20 <geteuid>
20219fc: e0 00 60 20 ld [ %g1 + 0x20 ], %l0
gid = getegid ();
2021a00: 40 00 18 04 call 2027a10 <getegid>
2021a04: a4 10 00 08 mov %o0, %l2
2021a08: a2 10 00 08 mov %o0, %l1
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
2021a0c: 40 00 02 ac call 20224bc <rtems_rfs_rtems_imode>
2021a10: 90 10 00 1b mov %i3, %o0
2021a14: 82 07 bf fc add %fp, -4, %g1
2021a18: 99 2a 20 10 sll %o0, 0x10, %o4
2021a1c: 96 10 00 1a mov %i2, %o3
2021a20: a5 2c a0 10 sll %l2, 0x10, %l2
2021a24: a3 2c 60 10 sll %l1, 0x10, %l1
2021a28: a5 34 a0 10 srl %l2, 0x10, %l2
2021a2c: a3 34 60 10 srl %l1, 0x10, %l1
2021a30: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
2021a34: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
2021a38: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2021a3c: 90 10 00 10 mov %l0, %o0
2021a40: 92 10 00 18 mov %i0, %o1
2021a44: 94 10 00 19 mov %i1, %o2
2021a48: 99 33 20 10 srl %o4, 0x10, %o4
2021a4c: 40 00 67 c6 call 203b964 <rtems_rfs_inode_create>
2021a50: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
2021a54: b4 92 20 00 orcc %o0, 0, %i2
2021a58: 14 80 00 0a bg 2021a80 <rtems_rfs_rtems_mknod+0x94>
2021a5c: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2021a60: d2 07 bf fc ld [ %fp + -4 ], %o1
2021a64: 90 10 00 10 mov %l0, %o0
2021a68: 94 07 bf d4 add %fp, -44, %o2
2021a6c: 40 00 66 76 call 203b444 <rtems_rfs_inode_open>
2021a70: 96 10 20 01 mov 1, %o3
if (rc > 0)
2021a74: b4 92 20 00 orcc %o0, 0, %i2
2021a78: 04 80 00 07 ble 2021a94 <rtems_rfs_rtems_mknod+0xa8> <== ALWAYS TAKEN
2021a7c: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
2021a80: 40 00 80 88 call 2041ca0 <__errno>
2021a84: b0 10 3f ff mov -1, %i0
2021a88: f4 22 00 00 st %i2, [ %o0 ]
2021a8c: 81 c7 e0 08 ret
2021a90: 81 e8 00 00 restore
}
if (S_ISDIR(mode) || S_ISREG(mode))
2021a94: b6 0e c0 01 and %i3, %g1, %i3
2021a98: 03 00 00 20 sethi %hi(0x8000), %g1
2021a9c: 80 a6 c0 01 cmp %i3, %g1
2021aa0: 02 80 00 1d be 2021b14 <rtems_rfs_rtems_mknod+0x128>
2021aa4: 03 00 00 10 sethi %hi(0x4000), %g1
2021aa8: 80 a6 c0 01 cmp %i3, %g1
2021aac: 02 80 00 1a be 2021b14 <rtems_rfs_rtems_mknod+0x128> <== ALWAYS TAKEN
2021ab0: 03 00 00 18 sethi %hi(0x6000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
2021ab4: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2021ab8: 02 80 00 06 be 2021ad0 <rtems_rfs_rtems_mknod+0xe4> <== NOT EXECUTED
2021abc: 90 07 bf d4 add %fp, -44, %o0 <== NOT EXECUTED
2021ac0: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
2021ac4: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2021ac8: 12 80 00 0b bne 2021af4 <rtems_rfs_rtems_mknod+0x108> <== NOT EXECUTED
2021acc: 92 07 bf d4 add %fp, -44, %o1 <== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
2021ad0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2021ad4: 7f ff fe 3c call 20213c4 <rtems_rfs_inode_set_block> <== NOT EXECUTED
2021ad8: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
2021adc: 90 07 bf d4 add %fp, -44, %o0 <== NOT EXECUTED
2021ae0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2021ae4: 7f ff fe 38 call 20213c4 <rtems_rfs_inode_set_block> <== NOT EXECUTED
2021ae8: 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);
2021aec: 10 80 00 0b b 2021b18 <rtems_rfs_rtems_mknod+0x12c> <== NOT EXECUTED
2021af0: 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);
2021af4: 40 00 66 c6 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
2021af8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
2021afc: 40 00 80 69 call 2041ca0 <__errno> <== NOT EXECUTED
2021b00: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021b04: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2021b08: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2021b0c: 81 c7 e0 08 ret
2021b10: 81 e8 00 00 restore
}
rc = rtems_rfs_inode_close (fs, &inode);
2021b14: 90 10 00 10 mov %l0, %o0
2021b18: 92 07 bf d4 add %fp, -44, %o1
2021b1c: 40 00 66 bc call 203b60c <rtems_rfs_inode_close>
2021b20: b0 10 20 00 clr %i0
if (rc > 0)
2021b24: 80 a2 20 00 cmp %o0, 0
2021b28: 04 bf ff f9 ble 2021b0c <rtems_rfs_rtems_mknod+0x120> <== ALWAYS TAKEN
2021b2c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
2021b30: 40 00 80 5c call 2041ca0 <__errno> <== NOT EXECUTED
2021b34: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021b38: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021b3c: 81 c7 e0 08 ret <== NOT EXECUTED
2021b40: 81 e8 00 00 restore <== NOT EXECUTED
02021974 <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)
{
2021974: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2021978: c2 06 20 18 ld [ %i0 + 0x18 ], %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);
202197c: 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);
2021980: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
2021984: 94 07 bf d8 add %fp, -40, %o2
2021988: 90 10 00 1d mov %i5, %o0
202198c: 40 00 66 ae call 203b444 <rtems_rfs_inode_open>
2021990: 96 10 20 01 mov 1, %o3
if (rc > 0)
2021994: b0 92 20 00 orcc %o0, 0, %i0
2021998: 04 80 00 07 ble 20219b4 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
202199c: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
20219a0: 40 00 80 c0 call 2041ca0 <__errno> <== NOT EXECUTED
20219a4: 01 00 00 00 nop <== NOT EXECUTED
20219a8: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
20219ac: 81 c7 e0 08 ret <== NOT EXECUTED
20219b0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
20219b4: 7f ff fe 99 call 2021418 <rtems_rfs_rtems_node_type_by_inode>
20219b8: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
20219bc: 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);
20219c0: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
20219c4: 40 00 67 12 call 203b60c <rtems_rfs_inode_close>
20219c8: 90 10 00 1d mov %i5, %o0
if (rc > 0)
20219cc: ba 92 20 00 orcc %o0, 0, %i5
20219d0: 04 80 00 05 ble 20219e4 <rtems_rfs_rtems_node_type+0x70> <== ALWAYS TAKEN
20219d4: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
20219d8: 40 00 80 b2 call 2041ca0 <__errno> <== NOT EXECUTED
20219dc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
20219e0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
20219e4: 81 c7 e0 08 ret
20219e8: 81 e8 00 00 restore
02021418 <rtems_rfs_rtems_node_type_by_inode>:
* @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);
2021418: c2 02 20 0c ld [ %o0 + 0xc ], %g1
* link is actually the normal path to a regular file, directory, device
* etc's inode. Links to inodes can be considered "the real" one, yet they
* are all links.
*/
uint16_t mode = rtems_rfs_inode_get_mode (inode);
if (RTEMS_RFS_S_ISDIR (mode))
202141c: 05 00 00 3c sethi %hi(0xf000), %g2
2021420: c2 08 60 02 ldub [ %g1 + 2 ], %g1
2021424: 83 28 60 08 sll %g1, 8, %g1
2021428: 82 08 40 02 and %g1, %g2, %g1
202142c: 05 00 00 10 sethi %hi(0x4000), %g2
2021430: 80 a0 40 02 cmp %g1, %g2
2021434: 02 80 00 0e be 202146c <rtems_rfs_rtems_node_type_by_inode+0x54>
2021438: 90 10 20 00 clr %o0
return RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
202143c: 05 00 00 28 sethi %hi(0xa000), %g2
2021440: 80 a0 40 02 cmp %g1, %g2
2021444: 02 80 00 0a be 202146c <rtems_rfs_rtems_node_type_by_inode+0x54>
2021448: 90 10 20 03 mov 3, %o0
return RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
202144c: 05 00 00 08 sethi %hi(0x2000), %g2
2021450: 80 a0 40 02 cmp %g1, %g2
2021454: 02 80 00 05 be 2021468 <rtems_rfs_rtems_node_type_by_inode+0x50><== NEVER TAKEN
2021458: 05 00 00 18 sethi %hi(0x6000), %g2
202145c: 80 a0 40 02 cmp %g1, %g2
2021460: 12 80 00 03 bne 202146c <rtems_rfs_rtems_node_type_by_inode+0x54><== ALWAYS TAKEN
2021464: 90 10 20 04 mov 4, %o0
return RTEMS_FILESYSTEM_DEVICE;
2021468: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
else
return RTEMS_FILESYSTEM_MEMORY_FILE;
}
202146c: 81 c3 e0 08 retl
020215f8 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
20215f8: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20215fc: c2 06 20 18 ld [ %i0 + 0x18 ], %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);
2021600: d2 06 20 08 ld [ %i0 + 8 ], %o1
2021604: d0 00 60 20 ld [ %g1 + 0x20 ], %o0
2021608: 94 10 00 19 mov %i1, %o2
202160c: 96 10 00 1a mov %i2, %o3
2021610: 40 00 6b b3 call 203c4dc <rtems_rfs_symlink_read>
2021614: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
2021618: 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)
202161c: 80 a2 20 00 cmp %o0, 0
2021620: 02 80 00 05 be 2021634 <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
2021624: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
2021628: 40 00 81 9e call 2041ca0 <__errno> <== NOT EXECUTED
202162c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021630: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
2021634: 81 c7 e0 08 ret
2021638: 81 e8 00 00 restore
0202156c <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)
{
202156c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
2021570: c2 06 60 18 ld [ %i1 + 0x18 ], %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);
2021574: 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);
2021578: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
202157c: 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);
2021580: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
2021584: 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);
2021588: 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);
202158c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021590: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2021594: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
2021598: 40 00 69 e8 call 203bd38 <rtems_rfs_link> <== NOT EXECUTED
202159c: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
20215a0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20215a4: 02 80 00 07 be 20215c0 <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
20215a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
20215ac: 40 00 81 bd call 2041ca0 <__errno> <== NOT EXECUTED
20215b0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20215b4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20215b8: 81 c7 e0 08 ret <== NOT EXECUTED
20215bc: 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,
20215c0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
20215c4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20215c8: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
20215cc: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
20215d0: 40 00 6a 41 call 203bed4 <rtems_rfs_unlink> <== NOT EXECUTED
20215d4: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
20215d8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20215dc: 02 bf ff f7 be 20215b8 <rtems_rfs_rtems_rename+0x4c> <== NOT EXECUTED
20215e0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
20215e4: 40 00 81 af call 2041ca0 <__errno> <== NOT EXECUTED
20215e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20215ec: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20215f0: 81 c7 e0 08 ret <== NOT EXECUTED
20215f4: 81 e8 00 00 restore <== NOT EXECUTED
02022404 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
2022404: 9d e3 bf a0 save %sp, -96, %sp
2022408: c2 06 60 0c ld [ %i1 + 0xc ], %g1
202240c: c4 08 60 02 ldub [ %g1 + 2 ], %g2
2022410: d2 08 60 03 ldub [ %g1 + 3 ], %o1
2022414: 85 28 a0 08 sll %g2, 8, %g2
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
2022418: 92 0a 60 ff and %o1, 0xff, %o1
202241c: 03 00 00 3c sethi %hi(0xf000), %g1
2022420: 92 12 40 02 or %o1, %g2, %o1
2022424: 05 00 00 10 sethi %hi(0x4000), %g2
2022428: 82 0a 40 01 and %o1, %g1, %g1
202242c: 80 a0 40 02 cmp %g1, %g2
2022430: 12 80 00 05 bne 2022444 <rtems_rfs_rtems_set_handlers+0x40>
2022434: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
2022438: 03 00 81 a3 sethi %hi(0x2068c00), %g1
202243c: 10 80 00 0b b 2022468 <rtems_rfs_rtems_set_handlers+0x64>
2022440: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 2068fd0 <rtems_rfs_rtems_dir_handlers>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
2022444: 05 00 00 18 sethi %hi(0x6000), %g2
2022448: 80 a0 40 02 cmp %g1, %g2
202244c: 02 80 00 05 be 2022460 <rtems_rfs_rtems_set_handlers+0x5c><== NEVER TAKEN
2022450: 05 00 00 08 sethi %hi(0x2000), %g2
2022454: 80 a0 40 02 cmp %g1, %g2
2022458: 12 80 00 07 bne 2022474 <rtems_rfs_rtems_set_handlers+0x70><== ALWAYS TAKEN
202245c: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
2022460: 03 00 81 a3 sethi %hi(0x2068c00), %g1 <== NOT EXECUTED
2022464: 82 10 63 a4 or %g1, 0x3a4, %g1 ! 2068fa4 <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
2022468: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
202246c: 10 80 00 11 b 20224b0 <rtems_rfs_rtems_set_handlers+0xac>
2022470: 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))
2022474: 80 a0 40 02 cmp %g1, %g2
2022478: 12 80 00 05 bne 202248c <rtems_rfs_rtems_set_handlers+0x88>
202247c: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
2022480: 03 00 81 8a sethi %hi(0x2062800), %g1
2022484: 10 bf ff f9 b 2022468 <rtems_rfs_rtems_set_handlers+0x64>
2022488: 82 10 61 54 or %g1, 0x154, %g1 ! 2062954 <rtems_rfs_rtems_link_handlers>
else if (RTEMS_RFS_S_ISREG (mode))
202248c: 80 a0 40 02 cmp %g1, %g2
2022490: 32 80 00 05 bne,a 20224a4 <rtems_rfs_rtems_set_handlers+0xa0><== NEVER TAKEN
2022494: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
2022498: 03 00 81 a3 sethi %hi(0x2068c00), %g1
202249c: 10 bf ff f3 b 2022468 <rtems_rfs_rtems_set_handlers+0x64>
20224a0: 82 10 63 fc or %g1, 0x3fc, %g1 ! 2068ffc <rtems_rfs_rtems_file_handlers>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
20224a4: b0 10 20 00 clr %i0 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
20224a8: 40 00 90 37 call 2046584 <printf> <== NOT EXECUTED
20224ac: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
return false;
}
return true;
}
20224b0: b0 0e 20 01 and %i0, 1, %i0
20224b4: 81 c7 e0 08 ret
20224b8: 81 e8 00 00 restore
02021490 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
2021490: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2021494: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
2021498: 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);
202149c: fa 00 60 20 ld [ %g1 + 0x20 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
20214a0: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
20214a4: 40 00 67 86 call 203b2bc <rtems_rfs_group_usage> <== NOT EXECUTED
20214a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
20214ac: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
20214b0: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
20214b4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
20214b8: c4 00 60 24 ld [ %g1 + 0x24 ], %g2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
20214bc: 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);
20214c0: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
20214c4: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20214c8: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
20214cc: 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);
20214d0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20214d4: 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;
20214d8: 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;
20214dc: c2 26 60 14 st %g1, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
20214e0: c2 26 60 1c st %g1, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
20214e4: 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;
20214e8: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
20214ec: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
20214f0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
20214f4: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
20214f8: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
20214fc: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
2021500: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
2021504: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
2021508: 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;
202150c: 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);
2021510: c2 26 60 30 st %g1, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
2021514: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2021518: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED
return 0;
}
202151c: 81 c7 e0 08 ret <== NOT EXECUTED
2021520: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0202163c <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)
{
202163c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
2021640: c2 06 20 18 ld [ %i0 + 0x18 ], %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),
2021644: 90 10 00 1b mov %i3, %o0
2021648: 40 00 9d b3 call 2048d14 <strlen>
202164c: f8 00 60 20 ld [ %g1 + 0x20 ], %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);
2021650: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
2021654: 40 00 18 f3 call 2027a20 <geteuid>
2021658: ba 10 00 08 mov %o0, %i5
202165c: 40 00 18 ed call 2027a10 <getegid>
2021660: a0 10 00 08 mov %o0, %l0
2021664: 91 2a 20 10 sll %o0, 0x10, %o0
2021668: 91 32 20 10 srl %o0, 0x10, %o0
202166c: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
2021670: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
2021674: 98 10 00 1d mov %i5, %o4
2021678: 9b 2c 20 10 sll %l0, 0x10, %o5
202167c: 90 10 00 1c mov %i4, %o0
2021680: 92 10 00 19 mov %i1, %o1
2021684: 94 10 00 1a mov %i2, %o2
2021688: 96 10 00 1b mov %i3, %o3
202168c: 9b 33 60 10 srl %o5, 0x10, %o5
2021690: 40 00 6a fc call 203c280 <rtems_rfs_symlink>
2021694: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
2021698: 80 a2 20 00 cmp %o0, 0
202169c: 02 80 00 05 be 20216b0 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
20216a0: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
20216a4: 40 00 81 7f call 2041ca0 <__errno> <== NOT EXECUTED
20216a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20216ac: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20216b0: 81 c7 e0 08 ret
20216b4: 81 e8 00 00 restore
02021bd8 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
2021bd8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2021bdc: fa 06 20 80 ld [ %i0 + 0x80 ], %i5
rtems_rfs_buffers_release (fs);
2021be0: 40 00 55 e1 call 2037364 <rtems_rfs_buffers_release>
2021be4: 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);
2021be8: 7f ff ad 9f call 200d264 <rtems_semaphore_release>
2021bec: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021bf0: ba 92 20 00 orcc %o0, 0, %i5
2021bf4: 02 80 00 0e be 2021c2c <rtems_rfs_rtems_unlock+0x54> <== ALWAYS TAKEN
2021bf8: 01 00 00 00 nop
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021bfc: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
2021c00: 40 00 06 aa call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2021c04: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021c08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021c0c: 02 80 00 08 be 2021c2c <rtems_rfs_rtems_unlock+0x54> <== NOT EXECUTED
2021c10: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021c14: 7f ff 9a 42 call 200851c <rtems_status_text> <== NOT EXECUTED
2021c18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021c1c: 31 00 81 8a sethi %hi(0x2062800), %i0 <== NOT EXECUTED
2021c20: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
2021c24: 40 00 92 58 call 2046584 <printf> <== NOT EXECUTED
2021c28: 91 ee 20 70 restore %i0, 0x70, %o0 <== NOT EXECUTED
2021c2c: 81 c7 e0 08 ret
2021c30: 81 e8 00 00 restore
020216b8 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
20216b8: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20216bc: c2 06 20 18 ld [ %i0 + 0x18 ], %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);
20216c0: 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);
20216c4: fa 00 60 20 ld [ %g1 + 0x20 ], %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);
20216c8: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
20216cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20216d0: 40 00 67 5d call 203b444 <rtems_rfs_inode_open> <== NOT EXECUTED
20216d4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
20216d8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20216dc: 02 80 00 07 be 20216f8 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
20216e0: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
20216e4: 40 00 81 6f call 2041ca0 <__errno> <== NOT EXECUTED
20216e8: 01 00 00 00 nop <== NOT EXECUTED
20216ec: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
20216f0: 81 c7 e0 08 ret <== NOT EXECUTED
20216f4: 91 e8 3f ff restore %g0, -1, %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);
20216f8: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
20216fc: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
2021700: 85 36 60 10 srl %i1, 0x10, %g2 <== NOT EXECUTED
2021704: c4 28 60 11 stb %g2, [ %g1 + 0x11 ] <== NOT EXECUTED
2021708: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
202170c: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2021710: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
2021714: 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);
2021718: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
202171c: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
2021720: 85 36 a0 10 srl %i2, 0x10, %g2 <== NOT EXECUTED
2021724: c4 28 60 15 stb %g2, [ %g1 + 0x15 ] <== NOT EXECUTED
2021728: 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);
202172c: 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);
2021730: 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);
2021734: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
2021738: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
202173c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2021740: 40 00 67 b3 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
2021744: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
2021748: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202174c: 02 80 00 05 be 2021760 <rtems_rfs_rtems_utime+0xa8> <== NOT EXECUTED
2021750: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
2021754: 40 00 81 53 call 2041ca0 <__errno> <== NOT EXECUTED
2021758: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202175c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021760: 81 c7 e0 08 ret <== NOT EXECUTED
2021764: 81 e8 00 00 restore <== NOT EXECUTED
02036bf8 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
2036bf8: 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))
2036bfc: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
2036c00: fa 06 20 08 ld [ %i0 + 8 ], %i5
2036c04: 7f ff b2 a9 call 20236a8 <rtems_rfs_trace>
2036c08: 92 10 20 80 mov 0x80, %o1
2036c0c: 80 8a 20 ff btst 0xff, %o0
2036c10: 22 80 00 29 be,a 2036cb4 <rtems_rfs_scan_chain+0xbc> <== ALWAYS TAKEN
2036c14: 39 00 81 8a sethi %hi(0x2062800), %i4
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
2036c18: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2036c1c: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036c20: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2036c24: 40 00 3e 58 call 2046584 <printf> <== NOT EXECUTED
2036c28: 90 12 21 e0 or %o0, 0x1e0, %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));
2036c2c: 10 80 00 22 b 2036cb4 <rtems_rfs_scan_chain+0xbc> <== NOT EXECUTED
2036c30: 39 00 81 8a sethi %hi(0x2062800), %i4 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2036c34: 7f ff b2 9d call 20236a8 <rtems_rfs_trace>
2036c38: 01 00 00 00 nop
2036c3c: 80 8a 20 ff btst 0xff, %o0
2036c40: 22 80 00 06 be,a 2036c58 <rtems_rfs_scan_chain+0x60> <== ALWAYS TAKEN
2036c44: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
2036c48: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
2036c4c: 40 00 3e 4e call 2046584 <printf> <== NOT EXECUTED
2036c50: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
2036c54: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
2036c58: 80 a0 40 1a cmp %g1, %i2
2036c5c: 32 80 00 17 bne,a 2036cb8 <rtems_rfs_scan_chain+0xc0>
2036c60: fa 07 60 04 ld [ %i5 + 4 ], %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2036c64: 90 10 20 00 clr %o0
2036c68: 7f ff b2 90 call 20236a8 <rtems_rfs_trace>
2036c6c: 92 10 20 80 mov 0x80, %o1
2036c70: 80 8a 20 ff btst 0xff, %o0
2036c74: 22 80 00 07 be,a 2036c90 <rtems_rfs_scan_chain+0x98> <== ALWAYS TAKEN
2036c78: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
2036c7c: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
2036c80: 11 00 81 9b sethi %hi(0x2066c00), %o0 <== NOT EXECUTED
2036c84: 40 00 3e 40 call 2046584 <printf> <== NOT EXECUTED
2036c88: 90 12 22 10 or %o0, 0x210, %o0 ! 2066e10 <__FUNCTION__.7646+0x188><== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
2036c8c: 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 );
2036c90: 90 10 00 1d mov %i5, %o0
2036c94: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
2036c98: b0 10 00 1d mov %i5, %i0
2036c9c: 7f ff 5c 79 call 200de80 <_Chain_Extract>
2036ca0: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2036ca4: c0 27 60 04 clr [ %i5 + 4 ]
2036ca8: c0 27 40 00 clr [ %i5 ]
2036cac: 81 c7 e0 08 ret
2036cb0: 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));
2036cb4: b8 17 22 e8 or %i4, 0x2e8, %i4
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2036cb8: 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))
2036cbc: 80 a7 40 18 cmp %i5, %i0
2036cc0: 12 bf ff dd bne 2036c34 <rtems_rfs_scan_chain+0x3c>
2036cc4: 92 10 20 80 mov 0x80, %o1
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2036cc8: 7f ff b2 78 call 20236a8 <rtems_rfs_trace>
2036ccc: b0 10 20 00 clr %i0
2036cd0: 80 8a 20 ff btst 0xff, %o0
2036cd4: 02 bf ff f6 be 2036cac <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
2036cd8: 11 00 81 9b sethi %hi(0x2066c00), %o0
printf (": not found\n");
2036cdc: 40 00 3e c5 call 20467f0 <puts> <== NOT EXECUTED
2036ce0: 90 12 22 28 or %o0, 0x228, %o0 ! 2066e28 <__FUNCTION__.7646+0x1a0><== NOT EXECUTED
return NULL;
}
2036ce4: 81 c7 e0 08 ret <== NOT EXECUTED
2036ce8: 81 e8 00 00 restore <== NOT EXECUTED
02040e0c <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,
2040e0c: 9d e3 bf 88 save %sp, -120, %sp
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
2040e10: 90 10 00 18 mov %i0, %o0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2040e14: ba 10 00 18 mov %i0, %i5
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
2040e18: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
2040e1c: 7f ff ff e8 call 2040dbc <rtems_rfs_bitmap_load_map>
2040e20: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2040e24: b0 92 20 00 orcc %o0, 0, %i0
2040e28: 14 80 00 95 bg 204107c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x270><== NEVER TAKEN
2040e2c: 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;
2040e30: f8 06 40 00 ld [ %i1 ], %i4
end_bit = test_bit + (window * direction);
if (end_bit < 0)
2040e34: a0 84 00 1c addcc %l0, %i4, %l0
2040e38: 2c 80 00 08 bneg,a 2040e58 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
2040e3c: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
2040e40: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2040e44: 80 a4 00 01 cmp %l0, %g1
2040e48: 3a 80 00 04 bcc,a 2040e58 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c><== ALWAYS TAKEN
2040e4c: 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];
2040e50: 10 80 00 03 b 2040e5c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x50><== NOT EXECUTED
2040e54: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
2040e58: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
map_bits = &map[map_index];
2040e5c: e4 07 bf fc ld [ %fp + -4 ], %l2
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);
2040e60: a3 3f 20 05 sra %i4, 5, %l1
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
2040e64: a7 3f 20 0a sra %i4, 0xa, %l3
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
2040e68: a7 2c e0 02 sll %l3, 2, %l3
2040e6c: a6 00 40 13 add %g1, %l3, %l3
map_bits = &map[map_index];
2040e70: 83 2c 60 02 sll %l1, 2, %g1
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);
2040e74: b0 0f 20 1f and %i4, 0x1f, %i0
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];
2040e78: a4 04 80 01 add %l2, %g1, %l2
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);
2040e7c: 88 0c 60 1f and %l1, 0x1f, %g4
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
2040e80: 83 2e e0 02 sll %i3, 2, %g1
2040e84: 80 a6 e0 00 cmp %i3, 0
2040e88: 04 80 00 03 ble 2040e94 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x88>
2040e8c: a8 10 20 1f mov 0x1f, %l4
2040e90: 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)))
2040e94: ab 3e e0 1f sra %i3, 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;
2040e98: 86 10 20 20 mov 0x20, %g3
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)))
2040e9c: aa 25 40 1b sub %l5, %i3, %l5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2040ea0: 85 2e e0 05 sll %i3, 5, %g2
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
2040ea4: 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))
2040ea8: ad 36 e0 1f srl %i3, 0x1f, %l6
|| ((direction > 0) && (test_bit >= end_bit)))
2040eac: ab 35 60 1f srl %l5, 0x1f, %l5
/*
* 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))
2040eb0: d4 04 c0 00 ld [ %l3 ], %o2
2040eb4: 80 a2 a0 00 cmp %o2, 0
2040eb8: 02 80 00 43 be 2040fc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8><== NEVER TAKEN
2040ebc: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2040ec0: 9e 04 40 1b add %l1, %i3, %o7
2040ec4: 9f 2b e0 05 sll %o7, 5, %o7
2040ec8: 10 80 00 3a b 2040fb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a4>
2040ecc: 9e 03 c0 14 add %o7, %l4, %o7
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))
2040ed0: 80 8b 40 0a btst %o5, %o2
2040ed4: 22 80 00 20 be,a 2040f54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
2040ed8: a4 04 80 01 add %l2, %g1, %l2
{
/*
* 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)
2040edc: 10 80 00 1b b 2040f48 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x13c>
2040ee0: 80 a6 20 1f cmp %i0, 0x1f
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
2040ee4: 97 2d c0 18 sll %l7, %i0, %o3
* 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))
2040ee8: 80 8a c0 0c btst %o3, %o4
2040eec: 02 80 00 13 be 2040f38 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12c>
2040ef0: 80 a7 00 10 cmp %i4, %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);
2040ef4: 82 2b 00 0b andn %o4, %o3, %g1
&& (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,
2040ef8: 80 a0 60 00 cmp %g1, 0
2040efc: 12 80 00 05 bne 2040f10 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x104>
2040f00: c2 24 80 00 st %g1, [ %l2 ]
*/
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);
2040f04: c2 04 c0 00 ld [ %l3 ], %g1
2040f08: 9a 28 40 0d andn %g1, %o5, %o5
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,
2040f0c: da 24 c0 00 st %o5, [ %l3 ]
1 << search_offset);
control->free--;
2040f10: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
2040f14: c4 07 40 00 ld [ %i5 ], %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--;
2040f18: 82 00 7f ff add %g1, -1, %g1
2040f1c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
*bit = test_bit;
2040f20: f8 26 40 00 st %i4, [ %i1 ]
*found = true;
2040f24: 82 10 20 01 mov 1, %g1
2040f28: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
2040f2c: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
2040f30: 81 c7 e0 08 ret
2040f34: 91 e8 20 00 restore %g0, 0, %o0
}
if (test_bit == end_bit)
2040f38: 02 80 00 06 be 2040f50 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
2040f3c: b0 06 00 1b add %i0, %i3, %i0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2040f40: b8 07 00 1b add %i4, %i3, %i4
{
/*
* 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)
2040f44: 80 a6 20 1f cmp %i0, 0x1f
2040f48: 28 bf ff e7 bleu,a 2040ee4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xd8><== ALWAYS TAKEN
2040f4c: d8 04 80 00 ld [ %l2 ], %o4
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
2040f50: a4 04 80 01 add %l2, %g1, %l2
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2040f54: a2 04 40 1b add %l1, %i3, %l1
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
2040f58: b8 10 00 0f mov %o7, %i4
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2040f5c: 88 01 00 1b add %g4, %i3, %g4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
2040f60: 80 a3 c0 10 cmp %o7, %l0
2040f64: 04 80 00 03 ble 2040f70 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x164>
2040f68: b0 10 20 01 mov 1, %i0
2040f6c: b0 10 20 00 clr %i0
2040f70: 80 8e 20 ff btst 0xff, %i0
2040f74: 02 80 00 05 be 2040f88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c>
2040f78: 9e 03 c0 02 add %o7, %g2, %o7
2040f7c: 80 a5 a0 00 cmp %l6, 0
2040f80: 32 80 00 26 bne,a 2041018 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x20c>
2040f84: b0 10 00 14 mov %l4, %i0
|| ((direction > 0) && (test_bit >= end_bit)))
2040f88: 80 a7 00 10 cmp %i4, %l0
2040f8c: 16 80 00 03 bge 2040f98 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18c>
2040f90: b0 10 20 01 mov 1, %i0
2040f94: b0 10 20 00 clr %i0
2040f98: 80 8e 20 ff btst 0xff, %i0
2040f9c: 02 80 00 05 be 2040fb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a4>
2040fa0: b0 10 00 14 mov %l4, %i0
2040fa4: 80 a5 60 00 cmp %l5, 0
2040fa8: 32 80 00 1d bne,a 204101c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x210><== ALWAYS TAKEN
2040fac: a6 04 c0 01 add %l3, %g1, %l3
* 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)
2040fb0: 80 a1 20 1f cmp %g4, 0x1f
2040fb4: 28 bf ff c7 bleu,a 2040ed0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc4><== ALWAYS TAKEN
2040fb8: 9b 2d c0 04 sll %l7, %g4, %o5
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
2040fbc: 10 80 00 18 b 204101c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x210><== NOT EXECUTED
2040fc0: a6 04 c0 01 add %l3, %g1, %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)
2040fc4: 04 80 00 07 ble 2040fe0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4><== NOT EXECUTED
2040fc8: b8 0f 3f e0 and %i4, -32, %i4 <== NOT EXECUTED
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
2040fcc: 92 20 c0 04 sub %g3, %g4, %o1 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
2040fd0: b0 10 20 00 clr %i0 <== 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 ();
2040fd4: 89 2a 60 05 sll %o1, 5, %g4 <== NOT EXECUTED
2040fd8: 10 80 00 07 b 2040ff4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e8><== NOT EXECUTED
2040fdc: b8 01 00 1c add %g4, %i4, %i4 <== NOT EXECUTED
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
2040fe0: 92 01 20 01 add %g4, 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;
2040fe4: b0 10 20 1f mov 0x1f, %i0 <== 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;
2040fe8: 89 29 20 05 sll %g4, 5, %g4 <== NOT EXECUTED
2040fec: 88 38 00 04 xnor %g0, %g4, %g4 <== NOT EXECUTED
2040ff0: b8 01 00 1c add %g4, %i4, %i4 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
2040ff4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED
2040ff8: c4 3f bf e8 std %g2, [ %fp + -24 ] <== NOT EXECUTED
2040ffc: 7f ff 07 70 call 2002dbc <.umul> <== NOT EXECUTED
2041000: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2041004: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
2041008: 89 2a 20 02 sll %o0, 2, %g4 <== NOT EXECUTED
map_index += direction * bits_skipped;
204100c: a2 04 40 08 add %l1, %o0, %l1 <== 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;
2041010: a4 04 80 04 add %l2, %g4, %l2 <== NOT EXECUTED
2041014: c4 1f bf e8 ldd [ %fp + -24 ], %g2 <== NOT EXECUTED
map_index += direction * bits_skipped;
}
search_bits += direction;
2041018: a6 04 c0 01 add %l3, %g1, %l3
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
204101c: 80 a6 e0 00 cmp %i3, 0
2041020: 04 80 00 03 ble 204102c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x220>
2041024: 88 10 20 1f mov 0x1f, %g4
2041028: 88 10 20 00 clr %g4
}
while (((direction < 0) && (test_bit >= end_bit))
204102c: 80 a7 00 10 cmp %i4, %l0
2041030: 16 80 00 03 bge 204103c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x230>
2041034: 9e 10 20 01 mov 1, %o7
2041038: 9e 10 20 00 clr %o7
|| ((direction > 0) && (test_bit <= end_bit)));
204103c: 80 8b e0 ff btst 0xff, %o7
2041040: 02 80 00 06 be 2041058 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x24c>
2041044: 80 a7 00 10 cmp %i4, %l0
2041048: 80 a5 a0 00 cmp %l6, 0
204104c: 32 bf ff 9a bne,a 2040eb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa8><== NEVER TAKEN
2041050: d4 04 c0 00 ld [ %l3 ], %o2 <== NOT EXECUTED
2041054: 80 a7 00 10 cmp %i4, %l0
2041058: 04 80 00 03 ble 2041064 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x258>
204105c: 9e 10 20 01 mov 1, %o7
2041060: 9e 10 20 00 clr %o7
2041064: 80 8b e0 ff btst 0xff, %o7
2041068: 02 80 00 04 be 2041078 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x26c>
204106c: 80 a5 60 00 cmp %l5, 0
2041070: 32 bf ff 91 bne,a 2040eb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa8><== NEVER TAKEN
2041074: d4 04 c0 00 ld [ %l3 ], %o2 <== NOT EXECUTED
return 0;
2041078: b0 10 20 00 clr %i0
}
204107c: 81 c7 e0 08 ret
2041080: 81 e8 00 00 restore
02022e70 <rtems_rfs_shell_block>:
return 0;
}
static int
rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2022e70: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
uint8_t* data;
bool state;
int b;
int rc;
if (argc <= 1)
2022e74: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2022e78: 34 80 00 07 bg,a 2022e94 <rtems_rfs_shell_block+0x24> <== NOT EXECUTED
2022e7c: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
2022e80: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022e84: 40 00 8e 5b call 20467f0 <puts> <== NOT EXECUTED
2022e88: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 2062bc8 <rtems_rfs_rtems_eval_config+0x248><== 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;
2022e8c: 81 c7 e0 08 ret <== NOT EXECUTED
2022e90: 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);
2022e94: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022e98: 40 00 9e 1b call 204a704 <strtoul> <== NOT EXECUTED
2022e9c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022ea0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
2022ea4: 7f ff fd 9d call 2022518 <rtems_rfs_shell_lock_rfs> <== NOT EXECUTED
2022ea8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
2022eac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022eb0: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022eb4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2022eb8: 40 00 60 c5 call 203b1cc <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
2022ebc: 96 07 bf ff add %fp, -1, %o3 <== NOT EXECUTED
if (rc > 0)
2022ec0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2022ec4: 04 80 00 0a ble 2022eec <rtems_rfs_shell_block+0x7c> <== NOT EXECUTED
2022ec8: c2 0f bf ff ldub [ %fp + -1 ], %g1 <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
2022ecc: 7f ff fd aa call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022ed0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
2022ed4: 40 00 97 69 call 2048c78 <strerror> <== NOT EXECUTED
2022ed8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2022edc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022ee0: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022ee4: 10 80 00 24 b 2022f74 <rtems_rfs_shell_block+0x104> <== NOT EXECUTED
2022ee8: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 2062be8 <rtems_rfs_rtems_eval_config+0x268><== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
2022eec: 15 00 81 82 sethi %hi(0x2060800), %o2 <== NOT EXECUTED
2022ef0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2022ef4: 02 80 00 04 be 2022f04 <rtems_rfs_shell_block+0x94> <== NOT EXECUTED
2022ef8: 94 12 a0 48 or %o2, 0x48, %o2 <== NOT EXECUTED
2022efc: 15 00 81 8a sethi %hi(0x2062800), %o2 <== NOT EXECUTED
2022f00: 94 12 a3 b8 or %o2, 0x3b8, %o2 ! 2062bb8 <rtems_rfs_rtems_eval_config+0x238><== NOT EXECUTED
2022f04: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022f08: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022f0c: 40 00 8d 9e call 2046584 <printf> <== NOT EXECUTED
2022f10: 90 12 20 18 or %o0, 0x18, %o0 ! 2062c18 <rtems_rfs_rtems_eval_config+0x298><== 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);
2022f14: 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;
2022f18: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
2022f1c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
handle->buffer = NULL;
2022f20: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
2022f24: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2022f28: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2022f2c: 40 00 4f e2 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2022f30: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2022f34: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2022f38: 04 80 00 14 ble 2022f88 <rtems_rfs_shell_block+0x118> <== NOT EXECUTED
2022f3c: c2 07 bf f8 ld [ %fp + -8 ], %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);
2022f40: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2022f44: 40 00 4f 6a call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2022f48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
2022f4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2022f50: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
2022f54: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
2022f58: 7f ff fd 87 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022f5c: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
2022f60: 40 00 97 46 call 2048c78 <strerror> <== NOT EXECUTED
2022f64: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2022f68: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022f6c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022f70: 90 12 20 30 or %o0, 0x30, %o0 ! 2062c30 <rtems_rfs_rtems_eval_config+0x2b0><== NOT EXECUTED
2022f74: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022f78: 40 00 8d 83 call 2046584 <printf> <== NOT EXECUTED
2022f7c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
2022f80: 81 c7 e0 08 ret <== NOT EXECUTED
2022f84: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
int mod = b % 16;
if (mod == 0)
{
if (b)
printf ("\n");
printf ("%04x ", b);
2022f88: 37 00 81 8b sethi %hi(0x2062c00), %i3 <== NOT EXECUTED
}
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
2022f8c: 39 00 81 8b sethi %hi(0x2062c00), %i4 <== 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);
2022f90: f4 00 60 1c ld [ %g1 + 0x1c ], %i2 <== NOT EXECUTED
2022f94: ba 10 20 00 clr %i5 <== NOT EXECUTED
int mod = b % 16;
if (mod == 0)
{
if (b)
printf ("\n");
printf ("%04x ", b);
2022f98: 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);
2022f9c: 10 80 00 16 b 2022ff4 <rtems_rfs_shell_block+0x184> <== NOT EXECUTED
2022fa0: b8 17 21 00 or %i4, 0x100, %i4 <== NOT EXECUTED
b < rtems_rfs_fs_block_size (fs);
b++, data++)
{
int mod = b % 16;
if (mod == 0)
2022fa4: 12 80 00 0c bne 2022fd4 <rtems_rfs_shell_block+0x164> <== NOT EXECUTED
2022fa8: 80 a0 60 08 cmp %g1, 8 <== NOT EXECUTED
{
if (b)
2022fac: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2022fb0: 02 80 00 05 be 2022fc4 <rtems_rfs_shell_block+0x154> <== NOT EXECUTED
2022fb4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\n");
2022fb8: 40 00 8d e0 call 2046738 <putchar> <== NOT EXECUTED
2022fbc: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
printf ("%04x ", b);
2022fc0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2022fc4: 40 00 8d 70 call 2046584 <printf> <== NOT EXECUTED
2022fc8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
}
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
2022fcc: 10 80 00 07 b 2022fe8 <rtems_rfs_shell_block+0x178> <== NOT EXECUTED
2022fd0: d2 0e 80 1d ldub [ %i2 + %i5 ], %o1 <== NOT EXECUTED
{
if (b)
printf ("\n");
printf ("%04x ", b);
}
if (mod == 8)
2022fd4: 32 80 00 05 bne,a 2022fe8 <rtems_rfs_shell_block+0x178> <== NOT EXECUTED
2022fd8: d2 0e 80 1d ldub [ %i2 + %i5 ], %o1 <== NOT EXECUTED
printf (" ");
2022fdc: 40 00 8d d7 call 2046738 <putchar> <== NOT EXECUTED
2022fe0: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
printf ("%02x ", *data);
2022fe4: d2 0e 80 1d ldub [ %i2 + %i5 ], %o1 <== NOT EXECUTED
2022fe8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2022fec: 40 00 8d 66 call 2046584 <printf> <== NOT EXECUTED
2022ff0: 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);
2022ff4: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
2022ff8: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2022ffc: 0a bf ff ea bcs 2022fa4 <rtems_rfs_shell_block+0x134> <== NOT EXECUTED
2023000: 82 8f 60 0f andcc %i5, 0xf, %g1 <== NOT EXECUTED
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
}
printf ("\n");
2023004: 40 00 8d cd call 2046738 <putchar> <== NOT EXECUTED
2023008: 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);
202300c: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2023010: 40 00 4f 37 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2023014: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("error: closing buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rtems_rfs_shell_unlock_rfs (fs);
2023018: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
202301c: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
2023020: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
handle->buffer = NULL;
2023024: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
2023028: 7f ff fd 53 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
202302c: b0 10 20 00 clr %i0 <== NOT EXECUTED
return 0;
}
2023030: 81 c7 e0 08 ret <== NOT EXECUTED
2023034: 81 e8 00 00 restore <== NOT EXECUTED
02023038 <rtems_rfs_shell_data>:
return rc;
}
static int
rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2023038: 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");
202303c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023040: 40 00 8d ec call 20467f0 <puts> <== NOT EXECUTED
2023044: 90 12 21 08 or %o0, 0x108, %o0 ! 2062d08 <rtems_rfs_rtems_eval_config+0x388><== NOT EXECUTED
printf (" flags: %08" PRIx32 "\n", fs->flags);
2023048: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
202304c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023050: 40 00 8d 4d call 2046584 <printf> <== NOT EXECUTED
2023054: 90 12 21 20 or %o0, 0x120, %o0 ! 2062d20 <rtems_rfs_rtems_eval_config+0x3a0><== NOT EXECUTED
#if 0
printf (" device: %08lx\n", rtems_rfs_fs_device (fs));
#endif
printf (" blocks: %zu\n", rtems_rfs_fs_blocks (fs));
2023058: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== NOT EXECUTED
202305c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023060: 40 00 8d 49 call 2046584 <printf> <== NOT EXECUTED
2023064: 90 12 21 40 or %o0, 0x140, %o0 ! 2062d40 <rtems_rfs_rtems_eval_config+0x3c0><== NOT EXECUTED
printf (" block size: %zu\n", rtems_rfs_fs_block_size (fs));
2023068: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
202306c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023070: 40 00 8d 45 call 2046584 <printf> <== NOT EXECUTED
2023074: 90 12 21 60 or %o0, 0x160, %o0 ! 2062d60 <rtems_rfs_rtems_eval_config+0x3e0><== NOT EXECUTED
printf (" size: %" PRIu64 "\n", rtems_rfs_fs_size (fs));
2023078: 40 00 59 76 call 2039650 <rtems_rfs_fs_size> <== NOT EXECUTED
202307c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2023080: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2023084: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
2023088: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202308c: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2023090: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2023094: 40 00 8d 3c call 2046584 <printf> <== NOT EXECUTED
2023098: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED
printf (" media block size: %" PRIu32 "\n", rtems_rfs_fs_media_block_size (fs));
202309c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
20230a0: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
20230a4: d2 00 60 24 ld [ %g1 + 0x24 ], %o1 <== NOT EXECUTED
20230a8: 40 00 8d 37 call 2046584 <printf> <== NOT EXECUTED
20230ac: 90 12 21 a0 or %o0, 0x1a0, %o0 <== NOT EXECUTED
printf (" media size: %" PRIu64 "\n", rtems_rfs_fs_media_size (fs));
20230b0: 40 00 59 71 call 2039674 <rtems_rfs_fs_media_size> <== NOT EXECUTED
20230b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20230b8: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
20230bc: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
20230c0: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
20230c4: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
20230c8: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
20230cc: 40 00 8d 2e call 2046584 <printf> <== NOT EXECUTED
20230d0: 90 12 21 c0 or %o0, 0x1c0, %o0 <== NOT EXECUTED
printf (" inodes: %" PRIu32 "\n", rtems_rfs_fs_inodes (fs));
20230d4: d2 06 20 14 ld [ %i0 + 0x14 ], %o1 <== NOT EXECUTED
20230d8: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
20230dc: 40 00 8d 2a call 2046584 <printf> <== NOT EXECUTED
20230e0: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 2062de0 <rtems_rfs_rtems_eval_config+0x460><== NOT EXECUTED
printf (" bad blocks: %" PRIu32 "\n", fs->bad_blocks);
20230e4: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 <== NOT EXECUTED
20230e8: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
20230ec: 40 00 8d 26 call 2046584 <printf> <== NOT EXECUTED
20230f0: 90 12 22 00 or %o0, 0x200, %o0 ! 2062e00 <rtems_rfs_rtems_eval_config+0x480><== NOT EXECUTED
printf (" max. name length: %" PRIu32 "\n", rtems_rfs_fs_max_name (fs));
20230f4: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
20230f8: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
20230fc: 40 00 8d 22 call 2046584 <printf> <== NOT EXECUTED
2023100: 90 12 22 20 or %o0, 0x220, %o0 ! 2062e20 <rtems_rfs_rtems_eval_config+0x4a0><== NOT EXECUTED
printf (" groups: %d\n", fs->group_count);
2023104: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
2023108: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202310c: 40 00 8d 1e call 2046584 <printf> <== NOT EXECUTED
2023110: 90 12 22 40 or %o0, 0x240, %o0 ! 2062e40 <rtems_rfs_rtems_eval_config+0x4c0><== NOT EXECUTED
printf (" group blocks: %zd\n", fs->group_blocks);
2023114: d2 06 20 28 ld [ %i0 + 0x28 ], %o1 <== NOT EXECUTED
2023118: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202311c: 40 00 8d 1a call 2046584 <printf> <== NOT EXECUTED
2023120: 90 12 22 58 or %o0, 0x258, %o0 ! 2062e58 <rtems_rfs_rtems_eval_config+0x4d8><== NOT EXECUTED
printf (" group inodes: %zd\n", fs->group_inodes);
2023124: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 <== NOT EXECUTED
2023128: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202312c: 40 00 8d 16 call 2046584 <printf> <== NOT EXECUTED
2023130: 90 12 22 78 or %o0, 0x278, %o0 ! 2062e78 <rtems_rfs_rtems_eval_config+0x4f8><== NOT EXECUTED
printf (" inodes per block: %zd\n", fs->inodes_per_block);
2023134: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 <== NOT EXECUTED
2023138: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202313c: 40 00 8d 12 call 2046584 <printf> <== NOT EXECUTED
2023140: 90 12 22 98 or %o0, 0x298, %o0 ! 2062e98 <rtems_rfs_rtems_eval_config+0x518><== NOT EXECUTED
printf (" blocks per block: %zd\n", fs->blocks_per_block);
2023144: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
2023148: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202314c: 40 00 8d 0e call 2046584 <printf> <== NOT EXECUTED
2023150: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 2062eb8 <rtems_rfs_rtems_eval_config+0x538><== NOT EXECUTED
printf (" singly blocks: %zd\n", fs->block_map_singly_blocks);
2023154: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 <== NOT EXECUTED
2023158: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202315c: 40 00 8d 0a call 2046584 <printf> <== NOT EXECUTED
2023160: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 2062ed8 <rtems_rfs_rtems_eval_config+0x558><== NOT EXECUTED
printf (" doublly blocks: %zd\n", fs->block_map_doubly_blocks);
2023164: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 <== NOT EXECUTED
2023168: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202316c: 40 00 8d 06 call 2046584 <printf> <== NOT EXECUTED
2023170: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 2062ef8 <rtems_rfs_rtems_eval_config+0x578><== NOT EXECUTED
printf (" max. held buffers: %" PRId32 "\n", fs->max_held_buffers);
2023174: d2 06 20 40 ld [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
2023178: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202317c: 40 00 8d 02 call 2046584 <printf> <== NOT EXECUTED
2023180: 90 12 23 18 or %o0, 0x318, %o0 ! 2062f18 <rtems_rfs_rtems_eval_config+0x598><== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
2023184: 7f ff fc e5 call 2022518 <rtems_rfs_shell_lock_rfs> <== NOT EXECUTED
2023188: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
202318c: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
2023190: 92 07 bf f8 add %fp, -8, %o1 <== NOT EXECUTED
2023194: 40 00 60 4a call 203b2bc <rtems_rfs_group_usage> <== NOT EXECUTED
2023198: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_shell_unlock_rfs (fs);
202319c: 7f ff fc f6 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
20231a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
20231a4: f8 07 bf f8 ld [ %fp + -8 ], %i4 <== NOT EXECUTED
20231a8: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== NOT EXECUTED
20231ac: 83 2f 20 02 sll %i4, 2, %g1 <== NOT EXECUTED
20231b0: 91 2f 20 07 sll %i4, 7, %o0 <== NOT EXECUTED
20231b4: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
20231b8: 90 02 00 1c add %o0, %i4, %o0 <== NOT EXECUTED
20231bc: 40 00 e0 a5 call 205b450 <.udiv> <== NOT EXECUTED
20231c0: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
20231c4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
20231c8: d2 06 20 14 ld [ %i0 + 0x14 ], %o1 <== NOT EXECUTED
20231cc: 87 28 60 07 sll %g1, 7, %g3 <== NOT EXECUTED
20231d0: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED
20231d4: 84 20 c0 02 sub %g3, %g2, %g2 <== NOT EXECUTED
20231d8: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
rtems_rfs_shell_unlock_rfs (fs);
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
20231dc: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
20231e0: 40 00 e0 9c call 205b450 <.udiv> <== NOT EXECUTED
20231e4: 91 28 60 03 sll %g1, 3, %o0 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
20231e8: 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);
20231ec: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
20231f0: 40 00 e0 9a call 205b458 <.div> <== NOT EXECUTED
20231f4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20231f8: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
20231fc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
2023200: 40 00 e1 42 call 205b708 <.rem> <== NOT EXECUTED
2023204: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2023208: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
202320c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2023210: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2023214: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023218: 40 00 8c db call 2046584 <printf> <== NOT EXECUTED
202321c: 90 12 23 38 or %o0, 0x338, %o0 ! 2062f38 <rtems_rfs_rtems_eval_config+0x5b8><== NOT EXECUTED
blocks, bpcent / 10, bpcent % 10);
printf (" inodes used: %zd (%d.%d%%)\n",
2023220: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2023224: f6 07 bf fc ld [ %fp + -4 ], %i3 <== NOT EXECUTED
2023228: 40 00 e0 8c call 205b458 <.div> <== NOT EXECUTED
202322c: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2023230: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2023234: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
2023238: 40 00 e1 34 call 205b708 <.rem> <== NOT EXECUTED
202323c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2023240: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2023244: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2023248: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
202324c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
2023250: 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",
2023254: 40 00 8c cc call 2046584 <printf> <== NOT EXECUTED
2023258: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
202325c: 81 c7 e0 08 ret <== NOT EXECUTED
2023260: 81 e8 00 00 restore <== NOT EXECUTED
02022bb0 <rtems_rfs_shell_dir>:
return 0;
}
static int
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2022bb0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
bool state;
int entry;
int b;
int rc;
if (argc <= 1)
2022bb4: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2022bb8: 34 80 00 07 bg,a 2022bd4 <rtems_rfs_shell_dir+0x24> <== NOT EXECUTED
2022bbc: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
2022bc0: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022bc4: 40 00 8f 0b call 20467f0 <puts> <== NOT EXECUTED
2022bc8: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 2062bc8 <rtems_rfs_rtems_eval_config+0x248><== 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;
2022bcc: 81 c7 e0 08 ret <== NOT EXECUTED
2022bd0: 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);
2022bd4: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022bd8: 40 00 9e cb call 204a704 <strtoul> <== NOT EXECUTED
2022bdc: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022be0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
2022be4: 7f ff fe 4d call 2022518 <rtems_rfs_shell_lock_rfs> <== NOT EXECUTED
2022be8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
2022bec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022bf0: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022bf4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2022bf8: 40 00 61 75 call 203b1cc <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
2022bfc: 96 07 bf ff add %fp, -1, %o3 <== NOT EXECUTED
if (rc > 0)
2022c00: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2022c04: 04 80 00 0a ble 2022c2c <rtems_rfs_shell_dir+0x7c> <== NOT EXECUTED
2022c08: c2 0f bf ff ldub [ %fp + -1 ], %g1 <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
2022c0c: 7f ff fe 5a call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022c10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
2022c14: 40 00 98 19 call 2048c78 <strerror> <== NOT EXECUTED
2022c18: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2022c1c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022c20: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022c24: 10 80 00 24 b 2022cb4 <rtems_rfs_shell_dir+0x104> <== NOT EXECUTED
2022c28: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 2062be8 <rtems_rfs_rtems_eval_config+0x268><== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
2022c2c: 15 00 81 82 sethi %hi(0x2060800), %o2 <== NOT EXECUTED
2022c30: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2022c34: 02 80 00 04 be 2022c44 <rtems_rfs_shell_dir+0x94> <== NOT EXECUTED
2022c38: 94 12 a0 48 or %o2, 0x48, %o2 <== NOT EXECUTED
2022c3c: 15 00 81 8a sethi %hi(0x2062800), %o2 <== NOT EXECUTED
2022c40: 94 12 a3 b8 or %o2, 0x3b8, %o2 ! 2062bb8 <rtems_rfs_rtems_eval_config+0x238><== NOT EXECUTED
2022c44: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022c48: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022c4c: 40 00 8e 4e call 2046584 <printf> <== NOT EXECUTED
2022c50: 90 12 20 18 or %o0, 0x18, %o0 ! 2062c18 <rtems_rfs_rtems_eval_config+0x298><== 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);
2022c54: 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;
2022c58: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
2022c5c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
handle->buffer = NULL;
2022c60: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
2022c64: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2022c68: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2022c6c: 40 00 50 92 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2022c70: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2022c74: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2022c78: 04 80 00 14 ble 2022cc8 <rtems_rfs_shell_dir+0x118> <== NOT EXECUTED
2022c7c: c2 07 bf f8 ld [ %fp + -8 ], %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);
2022c80: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2022c84: 40 00 50 1a call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2022c88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
2022c8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2022c90: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
2022c94: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
2022c98: 7f ff fe 37 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022c9c: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
2022ca0: 40 00 97 f6 call 2048c78 <strerror> <== NOT EXECUTED
2022ca4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2022ca8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022cac: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022cb0: 90 12 20 30 or %o0, 0x30, %o0 ! 2062c30 <rtems_rfs_rtems_eval_config+0x2b0><== NOT EXECUTED
2022cb4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022cb8: 40 00 8e 33 call 2046584 <printf> <== NOT EXECUTED
2022cbc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
2022cc0: 81 c7 e0 08 ret <== NOT EXECUTED
2022cc4: 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)
2022cc8: 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]=",
2022ccc: 23 00 81 8b sethi %hi(0x2062c00), %l1 <== 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 ("...");
2022cd0: 21 00 81 8b sethi %hi(0x2062c00), %l0 <== NOT EXECUTED
return 1;
}
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
2022cd4: 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;
2022cd8: b4 10 20 00 clr %i2 <== NOT EXECUTED
entry = 1;
2022cdc: 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)
2022ce0: 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]=",
2022ce4: a2 14 60 c0 or %l1, 0xc0, %l1 <== 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))
2022ce8: 10 80 00 52 b 2022e30 <rtems_rfs_shell_dir+0x280> <== NOT EXECUTED
2022cec: a0 14 20 f0 or %l0, 0xf0, %l0 <== NOT EXECUTED
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
elength = rtems_rfs_dir_entry_length (data);
2022cf0: c8 0f 60 09 ldub [ %i5 + 9 ], %g4 <== NOT EXECUTED
2022cf4: 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);
2022cf8: d6 0f 40 00 ldub [ %i5 ], %o3 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
2022cfc: b8 17 00 04 or %i4, %g4, %i4 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
2022d00: c6 0f 60 01 ldub [ %i5 + 1 ], %g3 <== NOT EXECUTED
2022d04: c2 0f 60 02 ldub [ %i5 + 2 ], %g1 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2022d08: 80 a7 00 12 cmp %i4, %l2 <== NOT EXECUTED
2022d0c: 02 80 00 4e be 2022e44 <rtems_rfs_shell_dir+0x294> <== NOT EXECUTED
2022d10: c4 0f 60 03 ldub [ %i5 + 3 ], %g2 <== NOT EXECUTED
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
2022d14: 80 a7 20 09 cmp %i4, 9 <== NOT EXECUTED
2022d18: 04 80 00 07 ble 2022d34 <rtems_rfs_shell_dir+0x184> <== NOT EXECUTED
2022d1c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022d20: c8 06 20 1c ld [ %i0 + 0x1c ], %g4 <== NOT EXECUTED
2022d24: 80 a7 00 04 cmp %i4, %g4 <== NOT EXECUTED
2022d28: 0a 80 00 07 bcs 2022d44 <rtems_rfs_shell_dir+0x194> <== NOT EXECUTED
2022d2c: 97 2a e0 18 sll %o3, 0x18, %o3 <== NOT EXECUTED
(elength >= rtems_rfs_fs_max_name (fs)))
{
printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
2022d30: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022d34: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2022d38: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED
2022d3c: 10 80 00 14 b 2022d8c <rtems_rfs_shell_dir+0x1dc> <== NOT EXECUTED
2022d40: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
2022d44: 86 08 e0 ff and %g3, 0xff, %g3 <== NOT EXECUTED
2022d48: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED
2022d4c: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
2022d50: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
2022d54: 96 12 c0 03 or %o3, %g3, %o3 <== NOT EXECUTED
2022d58: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
2022d5c: 96 12 c0 02 or %o3, %g2, %o3 <== 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)))
2022d60: 96 92 c0 01 orcc %o3, %g1, %o3 <== NOT EXECUTED
2022d64: 02 80 00 07 be 2022d80 <rtems_rfs_shell_dir+0x1d0> <== NOT EXECUTED
2022d68: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022d6c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
2022d70: 80 a2 c0 01 cmp %o3, %g1 <== NOT EXECUTED
2022d74: 2a 80 00 0a bcs,a 2022d9c <rtems_rfs_shell_dir+0x1ec> <== NOT EXECUTED
2022d78: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
2022d7c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022d80: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2022d84: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
2022d88: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
2022d8c: 40 00 8d fe call 2046584 <printf> <== NOT EXECUTED
2022d90: 01 00 00 00 nop <== NOT EXECUTED
break;
2022d94: 10 80 00 2d b 2022e48 <rtems_rfs_shell_dir+0x298> <== NOT EXECUTED
2022d98: 92 07 bf f0 add %fp, -16, %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),
2022d9c: d8 0f 60 04 ldub [ %i5 + 4 ], %o4 <== NOT EXECUTED
2022da0: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
2022da4: 99 2b 20 18 sll %o4, 0x18, %o4 <== NOT EXECUTED
2022da8: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
2022dac: 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;
2022db0: 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),
2022db4: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
2022db8: 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]=",
2022dbc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
entry, b,
rtems_rfs_dir_entry_ino (data),
rtems_rfs_dir_entry_hash (data),
2022dc0: 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]=",
2022dc4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2022dc8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2022dcc: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
2022dd0: 40 00 8d ed call 2046584 <printf> <== NOT EXECUTED
2022dd4: 9a 10 00 19 mov %i1, %o5 <== NOT EXECUTED
2022dd8: 80 a6 60 32 cmp %i1, 0x32 <== NOT EXECUTED
2022ddc: 04 80 00 03 ble 2022de8 <rtems_rfs_shell_dir+0x238> <== NOT EXECUTED
2022de0: a8 10 00 19 mov %i1, %l4 <== NOT EXECUTED
2022de4: a8 10 20 32 mov 0x32, %l4 <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
2022de8: 10 80 00 05 b 2022dfc <rtems_rfs_shell_dir+0x24c> <== NOT EXECUTED
2022dec: a6 10 20 00 clr %l3 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
2022df0: d0 08 60 0a ldub [ %g1 + 0xa ], %o0 <== NOT EXECUTED
2022df4: 40 00 8e 51 call 2046738 <putchar> <== NOT EXECUTED
2022df8: a6 04 e0 01 inc %l3 <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
2022dfc: 80 a4 c0 14 cmp %l3, %l4 <== NOT EXECUTED
2022e00: 06 bf ff fc bl 2022df0 <rtems_rfs_shell_dir+0x240> <== NOT EXECUTED
2022e04: 82 07 40 13 add %i5, %l3, %g1 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
2022e08: 80 a5 00 19 cmp %l4, %i1 <== NOT EXECUTED
2022e0c: 16 80 00 05 bge 2022e20 <rtems_rfs_shell_dir+0x270> <== NOT EXECUTED
2022e10: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
printf ("...");
2022e14: 40 00 8d dc call 2046584 <printf> <== NOT EXECUTED
2022e18: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
printf ("\n");
2022e1c: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
2022e20: 40 00 8e 46 call 2046738 <putchar> <== NOT EXECUTED
2022e24: b4 06 80 1c add %i2, %i4, %i2 <== NOT EXECUTED
b += elength;
data += elength;
2022e28: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
entry++;
2022e2c: 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))
2022e30: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
2022e34: 82 00 7f f5 add %g1, -11, %g1 <== NOT EXECUTED
2022e38: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2022e3c: 2a bf ff ad bcs,a 2022cf0 <rtems_rfs_shell_dir+0x140> <== NOT EXECUTED
2022e40: f8 0f 60 08 ldub [ %i5 + 8 ], %i4 <== 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);
2022e44: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
2022e48: 40 00 4f a9 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2022e4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("error: closing buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rtems_rfs_shell_unlock_rfs (fs);
2022e50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2022e54: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
2022e58: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
handle->buffer = NULL;
2022e5c: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
2022e60: 7f ff fd c5 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022e64: b0 10 20 00 clr %i0 <== NOT EXECUTED
return 0;
}
2022e68: 81 c7 e0 08 ret <== NOT EXECUTED
2022e6c: 81 e8 00 00 restore <== NOT EXECUTED
02022a1c <rtems_rfs_shell_group>:
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2022a1c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int g;
start = 0;
end = fs->group_count - 1;
switch (argc)
2022a20: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED
2022a24: 02 80 00 09 be 2022a48 <rtems_rfs_shell_group+0x2c> <== NOT EXECUTED
2022a28: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
2022a2c: 80 a6 60 03 cmp %i1, 3 <== NOT EXECUTED
2022a30: 02 80 00 0d be 2022a64 <rtems_rfs_shell_group+0x48> <== NOT EXECUTED
2022a34: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2022a38: 12 80 00 16 bne 2022a90 <rtems_rfs_shell_group+0x74> <== NOT EXECUTED
2022a3c: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
2022a40: 10 80 00 18 b 2022aa0 <rtems_rfs_shell_group+0x84> <== NOT EXECUTED
2022a44: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
switch (argc)
{
case 1:
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
2022a48: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
2022a4c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022a50: 40 00 9f 2d call 204a704 <strtoul> <== NOT EXECUTED
2022a54: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022a58: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
break;
2022a5c: 10 80 00 12 b 2022aa4 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
2022a60: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
case 3:
start = strtoul (argv[1], 0, 0);
2022a64: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
2022a68: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022a6c: 40 00 9f 26 call 204a704 <strtoul> <== NOT EXECUTED
2022a70: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022a74: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
end = strtoul (argv[2], 0, 0);
2022a78: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
2022a7c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022a80: 40 00 9f 21 call 204a704 <strtoul> <== NOT EXECUTED
2022a84: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2022a88: 10 80 00 07 b 2022aa4 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
2022a8c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
2022a90: 40 00 8f 58 call 20467f0 <puts> <== NOT EXECUTED
2022a94: 90 12 23 28 or %o0, 0x328, %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;
2022a98: 81 c7 e0 08 ret <== NOT EXECUTED
2022a9c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
{
int start;
int end;
int g;
start = 0;
2022aa0: ba 10 20 00 clr %i5 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
2022aa4: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2022aa8: 06 80 00 09 bl 2022acc <rtems_rfs_shell_group+0xb0> <== NOT EXECUTED
2022aac: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
2022ab0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2022ab4: 06 80 00 06 bl 2022acc <rtems_rfs_shell_group+0xb0> <== NOT EXECUTED
2022ab8: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED
2022abc: 16 80 00 04 bge 2022acc <rtems_rfs_shell_group+0xb0> <== NOT EXECUTED
2022ac0: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
2022ac4: 06 80 00 07 bl 2022ae0 <rtems_rfs_shell_group+0xc4> <== NOT EXECUTED
2022ac8: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: group out of range (0->%d).\n", fs->group_count);
2022acc: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022ad0: 40 00 8e ad call 2046584 <printf> <== NOT EXECUTED
2022ad4: 90 12 23 48 or %o0, 0x348, %o0 ! 2062b48 <rtems_rfs_rtems_eval_config+0x1c8><== NOT EXECUTED
return 1;
2022ad8: 81 c7 e0 08 ret <== NOT EXECUTED
2022adc: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
}
rtems_rfs_shell_lock_rfs (fs);
2022ae0: 7f ff fe 8e call 2022518 <rtems_rfs_shell_lock_rfs> <== NOT EXECUTED
2022ae4: 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[])
2022ae8: b3 2f 60 04 sll %i5, 4, %i1 <== NOT EXECUTED
2022aec: 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",
2022af0: 35 00 81 8a sethi %hi(0x2062800), %i2 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
2022af4: b6 10 20 00 clr %i3 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
2022af8: b2 06 40 01 add %i1, %g1, %i1 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
2022afc: 10 80 00 25 b 2022b90 <rtems_rfs_shell_group+0x174> <== NOT EXECUTED
2022b00: b4 16 a3 70 or %i2, 0x370, %i2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
2022b04: 84 06 c0 19 add %i3, %i1, %g2 <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
{
rtems_rfs_group* group = &fs->groups[g];
2022b08: 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);
2022b0c: e4 00 60 04 ld [ %g1 + 4 ], %l2 <== NOT EXECUTED
2022b10: e2 00 60 18 ld [ %g1 + 0x18 ], %l1 <== 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",
2022b14: 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);
2022b18: e8 06 20 2c ld [ %i0 + 0x2c ], %l4 <== NOT EXECUTED
2022b1c: e6 00 60 3c ld [ %g1 + 0x3c ], %l3 <== 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);
2022b20: a2 24 80 11 sub %l2, %l1, %l1 <== 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,
2022b24: 85 2c 60 02 sll %l1, 2, %g2 <== NOT EXECUTED
2022b28: 83 2c 60 04 sll %l1, 4, %g1 <== NOT EXECUTED
2022b2c: 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",
2022b30: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
2022b34: 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",
2022b38: 40 00 e2 46 call 205b450 <.udiv> <== NOT EXECUTED
2022b3c: 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);
2022b40: a6 25 00 13 sub %l4, %l3, %l3 <== 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);
2022b44: 83 2c e0 02 sll %l3, 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",
2022b48: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
2022b4c: e6 23 a0 5c st %l3, [ %sp + 0x5c ] <== NOT EXECUTED
2022b50: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
inodes, (inodes * 100) / fs->group_inodes);
2022b54: a7 2c e0 04 sll %l3, 4, %l3 <== NOT EXECUTED
2022b58: a6 00 40 13 add %g1, %l3, %l3 <== NOT EXECUTED
2022b5c: 91 2c e0 02 sll %l3, 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",
2022b60: 40 00 e2 3c call 205b450 <.udiv> <== NOT EXECUTED
2022b64: 90 04 c0 08 add %l3, %o0, %o0 <== NOT EXECUTED
2022b68: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022b6c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2022b70: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2022b74: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2022b78: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
2022b7c: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
2022b80: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
2022b84: 40 00 8e 80 call 2046584 <printf> <== NOT EXECUTED
2022b88: ba 07 60 01 inc %i5 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
2022b8c: b6 06 e0 50 add %i3, 0x50, %i3 <== NOT EXECUTED
2022b90: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
2022b94: 24 bf ff dc ble,a 2022b04 <rtems_rfs_shell_group+0xe8> <== NOT EXECUTED
2022b98: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
inodes, (inodes * 100) / fs->group_inodes);
}
rtems_rfs_shell_unlock_rfs (fs);
2022b9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022ba0: 7f ff fe 75 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022ba4: b0 10 20 00 clr %i0 <== NOT EXECUTED
return 0;
}
2022ba8: 81 c7 e0 08 ret <== NOT EXECUTED
2022bac: 81 e8 00 00 restore <== NOT EXECUTED
020225d0 <rtems_rfs_shell_inode>:
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
20225d0: 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;
20225d4: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
20225d8: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 <== NOT EXECUTED
20225dc: 7f ff 81 f8 call 2002dbc <.umul> <== NOT EXECUTED
20225e0: 2b 00 81 8a sethi %hi(0x2062800), %l5 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
20225e4: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
int b;
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
20225e8: 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;
20225ec: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
20225f0: b8 10 00 14 mov %l4, %i4 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
20225f4: ae 10 20 00 clr %l7 <== NOT EXECUTED
20225f8: ac 10 20 00 clr %l6 <== 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;
20225fc: a2 10 20 00 clr %l1 <== NOT EXECUTED
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
show_all = false;
error_check_only = false;
2022600: 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;
2022604: b6 10 20 00 clr %i3 <== NOT EXECUTED
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
2022608: 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++)
202260c: 10 80 00 2e b 20226c4 <rtems_rfs_shell_inode+0xf4> <== NOT EXECUTED
2022610: aa 15 61 e0 or %l5, 0x1e0, %l5 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2022614: d2 06 80 01 ld [ %i2 + %g1 ], %o1 <== NOT EXECUTED
2022618: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
202261c: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2022620: 12 80 00 0e bne 2022658 <rtems_rfs_shell_inode+0x88> <== NOT EXECUTED
2022624: 80 8d e0 ff btst 0xff, %l7 <== NOT EXECUTED
{
switch (argv[arg][1])
2022628: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
202262c: 80 a0 60 65 cmp %g1, 0x65 <== NOT EXECUTED
2022630: 02 80 00 23 be 20226bc <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
2022634: 80 a0 60 66 cmp %g1, 0x66 <== NOT EXECUTED
2022638: 02 80 00 06 be 2022650 <rtems_rfs_shell_inode+0x80> <== NOT EXECUTED
202263c: 80 a0 60 61 cmp %g1, 0x61 <== NOT EXECUTED
2022640: 12 80 00 0b bne 202266c <rtems_rfs_shell_inode+0x9c> <== NOT EXECUTED
2022644: 01 00 00 00 nop <== NOT EXECUTED
{
case 'a':
show_all = true;
2022648: 10 80 00 1e b 20226c0 <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
202264c: b6 10 20 01 mov 1, %i3 ! 1 <PROM_START+0x1> <== NOT EXECUTED
case 'e':
error_check_only = true;
break;
case 'f':
forced = true;
break;
2022650: 10 80 00 1c b 20226c0 <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
2022654: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
2022658: 02 80 00 09 be 202267c <rtems_rfs_shell_inode+0xac> <== NOT EXECUTED
202265c: 82 0d a0 ff and %l6, 0xff, %g1 <== NOT EXECUTED
2022660: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2022664: 02 80 00 09 be 2022688 <rtems_rfs_shell_inode+0xb8> <== NOT EXECUTED
2022668: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
printf ("warning: option ignored: %s\n", argv[arg]);
202266c: 40 00 8f c6 call 2046584 <printf> <== NOT EXECUTED
2022670: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
2022674: 10 80 00 14 b 20226c4 <rtems_rfs_shell_inode+0xf4> <== NOT EXECUTED
2022678: a4 04 a0 01 inc %l2 <== NOT EXECUTED
else if (!have_start)
202267c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2022680: 12 80 00 09 bne 20226a4 <rtems_rfs_shell_inode+0xd4> <== NOT EXECUTED
2022684: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
{
start = end = strtoul (argv[arg], 0, 0);
2022688: 94 10 20 00 clr %o2 <== NOT EXECUTED
202268c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022690: 40 00 a0 1d call 204a704 <strtoul> <== NOT EXECUTED
2022694: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED
2022698: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
202269c: 10 80 00 09 b 20226c0 <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
20226a0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
have_start = true;
}
else
{
end = strtoul (argv[arg], 0, 0);
20226a4: 94 10 20 00 clr %o2 <== NOT EXECUTED
20226a8: 92 10 20 00 clr %o1 <== NOT EXECUTED
20226ac: 40 00 a0 16 call 204a704 <strtoul> <== NOT EXECUTED
20226b0: ae 10 20 01 mov 1, %l7 <== NOT EXECUTED
20226b4: 10 80 00 03 b 20226c0 <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
20226b8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
case 'a':
show_all = true;
break;
case 'e':
error_check_only = true;
20226bc: 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++)
20226c0: a4 04 a0 01 inc %l2 <== NOT EXECUTED
20226c4: 80 a4 80 19 cmp %l2, %i1 <== NOT EXECUTED
20226c8: 06 bf ff d3 bl 2022614 <rtems_rfs_shell_inode+0x44> <== NOT EXECUTED
20226cc: 83 2c a0 02 sll %l2, 2, %g1 <== NOT EXECUTED
have_end = true;
}
}
}
if ((start >= total) || (end >= total))
20226d0: 80 a7 00 13 cmp %i4, %l3 <== NOT EXECUTED
20226d4: 1a 80 00 04 bcc 20226e4 <rtems_rfs_shell_inode+0x114> <== NOT EXECUTED
20226d8: 80 a7 40 13 cmp %i5, %l3 <== NOT EXECUTED
20226dc: 2a 80 00 08 bcs,a 20226fc <rtems_rfs_shell_inode+0x12c> <== NOT EXECUTED
20226e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
printf ("error: inode out of range (0->%" PRId32 ").\n", total - 1);
20226e4: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
20226e8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
20226ec: 40 00 8f a6 call 2046584 <printf> <== NOT EXECUTED
20226f0: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: closing inode handle: ino=%" PRIu32 ": (%d) %s\n",
ino, rc, strerror (rc));
return 1;
20226f4: 81 c7 e0 08 ret <== NOT EXECUTED
20226f8: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
}
}
if (!error_check_only || error)
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
20226fc: 27 00 81 8a sethi %hi(0x2062800), %l3 <== 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)
2022700: 25 00 00 3f sethi %hi(0xfc00), %l2 <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "LNK";
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
2022704: 33 00 81 8a sethi %hi(0x2062800), %i1 <== NOT EXECUTED
{
printf ("error: inode out of range (0->%" PRId32 ").\n", total - 1);
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
2022708: 7f ff ff 84 call 2022518 <rtems_rfs_shell_lock_rfs> <== NOT EXECUTED
202270c: 35 00 81 8a sethi %hi(0x2062800), %i2 <== NOT EXECUTED
}
}
if (!error_check_only || error)
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
2022710: a6 14 e2 88 or %l3, 0x288, %l3 <== NOT EXECUTED
2022714: a4 14 a3 ff or %l2, 0x3ff, %l2 <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "LNK";
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
2022718: b2 16 62 b0 or %i1, 0x2b0, %i1 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
202271c: 10 80 00 b9 b 2022a00 <rtems_rfs_shell_inode+0x430> <== NOT EXECUTED
2022720: b4 16 a2 e8 or %i2, 0x2e8, %i2 <== NOT EXECUTED
{
rtems_rfs_inode_handle inode;
bool allocated;
rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);
2022724: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2022728: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
202272c: 40 00 62 a8 call 203b1cc <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
2022730: 96 07 bf ff add %fp, -1, %o3 <== NOT EXECUTED
if (rc > 0)
2022734: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
2022738: 04 80 00 0a ble 2022760 <rtems_rfs_shell_inode+0x190> <== NOT EXECUTED
202273c: 80 8e e0 ff btst 0xff, %i3 <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
2022740: 7f ff ff 8d call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022744: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("error: testing inode state: ino=%" PRIu32 ": (%d) %s\n",
2022748: 40 00 99 4c call 2048c78 <strerror> <== NOT EXECUTED
202274c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2022750: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022754: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022758: 10 80 00 a5 b 20229ec <rtems_rfs_shell_inode+0x41c> <== NOT EXECUTED
202275c: 90 12 22 28 or %o0, 0x228, %o0 ! 2062a28 <rtems_rfs_rtems_eval_config+0xa8><== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
}
if (show_all || allocated)
2022760: 12 80 00 05 bne 2022774 <rtems_rfs_shell_inode+0x1a4> <== NOT EXECUTED
2022764: c2 0f bf ff ldub [ %fp + -1 ], %g1 <== NOT EXECUTED
2022768: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
202276c: 22 80 00 a5 be,a 2022a00 <rtems_rfs_shell_inode+0x430> <== NOT EXECUTED
2022770: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
uint16_t mode;
bool error;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2022774: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022778: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
202277c: 94 07 bf d4 add %fp, -44, %o2 <== NOT EXECUTED
2022780: 40 00 63 31 call 203b444 <rtems_rfs_inode_open> <== NOT EXECUTED
2022784: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2022788: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
202278c: 04 80 00 0a ble 20227b4 <rtems_rfs_shell_inode+0x1e4> <== NOT EXECUTED
2022790: c2 07 bf e0 ld [ %fp + -32 ], %g1 <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
2022794: 7f ff ff 78 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022798: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("error: opening inode handle: ino=%" PRIu32 ": (%d) %s\n",
202279c: 40 00 99 37 call 2048c78 <strerror> <== NOT EXECUTED
20227a0: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
20227a4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20227a8: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
20227ac: 10 80 00 90 b 20229ec <rtems_rfs_shell_inode+0x41c> <== NOT EXECUTED
20227b0: 90 12 22 58 or %o0, 0x258, %o0 ! 2062a58 <rtems_rfs_rtems_eval_config+0xd8><== NOT EXECUTED
error = false;
mode = rtems_rfs_inode_get_mode (&inode);
if (error_check_only)
20227b4: 80 8c 20 ff btst 0xff, %l0 <== 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);
20227b8: e8 08 60 02 ldub [ %g1 + 2 ], %l4 <== NOT EXECUTED
20227bc: c2 08 60 03 ldub [ %g1 + 3 ], %g1 <== NOT EXECUTED
20227c0: a9 2d 20 08 sll %l4, 8, %l4 <== NOT EXECUTED
20227c4: 02 80 00 15 be 2022818 <rtems_rfs_shell_inode+0x248> <== NOT EXECUTED
20227c8: a8 15 00 01 or %l4, %g1, %l4 <== NOT EXECUTED
{
if (!RTEMS_RFS_S_ISDIR (mode) &&
20227cc: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
20227d0: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
20227d4: 82 0d 00 01 and %l4, %g1, %g1 <== NOT EXECUTED
20227d8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20227dc: 02 80 00 78 be 20229bc <rtems_rfs_shell_inode+0x3ec> <== NOT EXECUTED
20227e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20227e4: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
20227e8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20227ec: 02 80 00 74 be 20229bc <rtems_rfs_shell_inode+0x3ec> <== NOT EXECUTED
20227f0: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
!RTEMS_RFS_S_ISCHR (mode) &&
20227f4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20227f8: 02 80 00 71 be 20229bc <rtems_rfs_shell_inode+0x3ec> <== NOT EXECUTED
20227fc: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
!RTEMS_RFS_S_ISBLK (mode) &&
2022800: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022804: 02 80 00 6e be 20229bc <rtems_rfs_shell_inode+0x3ec> <== NOT EXECUTED
2022808: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
}
#endif
}
}
if (!error_check_only || error)
202280c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022810: 02 80 00 6b be 20229bc <rtems_rfs_shell_inode+0x3ec> <== NOT EXECUTED
2022814: 01 00 00 00 nop <== NOT EXECUTED
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
2022818: d6 07 bf f4 ld [ %fp + -12 ], %o3 <== NOT EXECUTED
202281c: c4 0f bf ff ldub [ %fp + -1 ], %g2 <== NOT EXECUTED
2022820: d4 07 bf e8 ld [ %fp + -24 ], %o2 <== NOT EXECUTED
2022824: 83 2a e0 03 sll %o3, 3, %g1 <== NOT EXECUTED
2022828: 80 a0 00 02 cmp %g0, %g2 <== NOT EXECUTED
202282c: 97 2a e0 06 sll %o3, 6, %o3 <== NOT EXECUTED
2022830: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
2022834: 96 22 c0 01 sub %o3, %g1, %o3 <== NOT EXECUTED
2022838: 98 0b 20 05 and %o4, 5, %o4 <== NOT EXECUTED
202283c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
2022840: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022844: 40 00 8f 50 call 2046584 <printf> <== NOT EXECUTED
2022848: 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)
202284c: c2 0f bf ff ldub [ %fp + -1 ], %g1 <== NOT EXECUTED
2022850: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2022854: 12 80 00 0a bne 202287c <rtems_rfs_shell_inode+0x2ac> <== NOT EXECUTED
2022858: a9 2d 20 10 sll %l4, 0x10, %l4 <== NOT EXECUTED
202285c: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
2022860: 12 80 00 08 bne 2022880 <rtems_rfs_shell_inode+0x2b0> <== NOT EXECUTED
2022864: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
printf (" --\n");
2022868: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
202286c: 40 00 8f e1 call 20467f0 <puts> <== NOT EXECUTED
2022870: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 2062aa8 <rtems_rfs_rtems_eval_config+0x128><== NOT EXECUTED
2022874: 10 80 00 52 b 20229bc <rtems_rfs_shell_inode+0x3ec> <== NOT EXECUTED
2022878: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
else
{
const char* type;
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
202287c: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
2022880: 95 35 20 10 srl %l4, 0x10, %o2 <== NOT EXECUTED
type = "DIR";
2022884: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
printf (" --\n");
else
{
const char* type;
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
2022888: 82 0a 80 01 and %o2, %g1, %g1 <== NOT EXECUTED
202288c: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
2022890: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022894: 02 80 00 18 be 20228f4 <rtems_rfs_shell_inode+0x324> <== NOT EXECUTED
2022898: 96 12 e1 b0 or %o3, 0x1b0, %o3 <== NOT EXECUTED
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "CHR";
202289c: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
{
const char* type;
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
20228a0: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
20228a4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20228a8: 02 80 00 13 be 20228f4 <rtems_rfs_shell_inode+0x324> <== NOT EXECUTED
20228ac: 96 12 e1 b8 or %o3, 0x1b8, %o3 <== NOT EXECUTED
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "BLK";
20228b0: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
20228b4: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
20228b8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20228bc: 02 80 00 0e be 20228f4 <rtems_rfs_shell_inode+0x324> <== NOT EXECUTED
20228c0: 96 12 e1 c0 or %o3, 0x1c0, %o3 <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
type = "REG";
20228c4: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
20228c8: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
20228cc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20228d0: 02 80 00 09 be 20228f4 <rtems_rfs_shell_inode+0x324> <== NOT EXECUTED
20228d4: 96 12 e1 c8 or %o3, 0x1c8, %o3 <== NOT EXECUTED
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "LNK";
20228d8: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
20228dc: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
20228e0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20228e4: 02 80 00 04 be 20228f4 <rtems_rfs_shell_inode+0x324> <== NOT EXECUTED
20228e8: 96 12 e1 d8 or %o3, 0x1d8, %o3 <== NOT EXECUTED
if (!allocated && !forced)
printf (" --\n");
else
{
const char* type;
type = "UKN";
20228ec: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
20228f0: 96 12 e1 d0 or %o3, 0x1d0, %o3 ! 20629d0 <rtems_rfs_rtems_eval_config+0x50><== 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);
20228f4: c4 07 bf e0 ld [ %fp + -32 ], %g2 <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "LNK";
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
20228f8: 90 10 00 19 mov %i1, %o0 <== 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);
20228fc: c6 08 a0 0d ldub [ %g2 + 0xd ], %g3 <== 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);
2022900: c2 08 a0 01 ldub [ %g2 + 1 ], %g1 <== NOT EXECUTED
2022904: d2 08 80 00 ldub [ %g2 ], %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);
2022908: c8 08 a0 0c ldub [ %g2 + 0xc ], %g4 <== NOT EXECUTED
202290c: 87 28 e0 10 sll %g3, 0x10, %g3 <== 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);
2022910: 93 2a 60 08 sll %o1, 8, %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);
2022914: 89 29 20 18 sll %g4, 0x18, %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);
2022918: 92 12 40 01 or %o1, %g1, %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);
202291c: 88 11 00 03 or %g4, %g3, %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);
if (links == 0xffff)
2022920: 83 2a 60 10 sll %o1, 0x10, %g1 <== 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);
2022924: c6 08 a0 0f ldub [ %g2 + 0xf ], %g3 <== 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)
2022928: 83 30 60 10 srl %g1, 0x10, %g1 <== NOT EXECUTED
links = 0;
202292c: 82 18 40 12 xor %g1, %l2, %g1 <== NOT EXECUTED
2022930: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2022934: 82 60 20 00 subx %g0, 0, %g1 <== 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);
2022938: 88 11 00 03 or %g4, %g3, %g4 <== NOT EXECUTED
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
links = 0;
202293c: 92 0a 40 01 and %o1, %g1, %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);
2022940: c6 08 a0 0e ldub [ %g2 + 0xe ], %g3 <== 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);
2022944: c2 08 a0 0a ldub [ %g2 + 0xa ], %g1 <== NOT EXECUTED
2022948: da 08 a0 0b ldub [ %g2 + 0xb ], %o5 <== NOT EXECUTED
202294c: 83 28 60 08 sll %g1, 8, %g1 <== 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);
2022950: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2022954: 84 11 00 03 or %g4, %g3, %g2 <== NOT EXECUTED
2022958: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
202295c: c4 23 a0 5c st %g2, [ %sp + 0x5c ] <== NOT EXECUTED
2022960: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
2022964: 98 0a a3 ff and %o2, 0x3ff, %o4 <== NOT EXECUTED
2022968: 9a 13 40 01 or %o5, %g1, %o5 <== NOT EXECUTED
202296c: 40 00 8f 06 call 2046584 <printf> <== NOT EXECUTED
2022970: 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));
2022974: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2022978: 7f ff fe d6 call 20224d0 <rtems_rfs_inode_get_block> <== NOT EXECUTED
202297c: 90 07 bf d4 add %fp, -44, %o0 <== NOT EXECUTED
2022980: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2022984: 40 00 8f 00 call 2046584 <printf> <== NOT EXECUTED
2022988: 90 10 00 1a mov %i2, %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++)
202298c: a8 05 20 01 inc %l4 <== NOT EXECUTED
2022990: 80 a5 20 04 cmp %l4, 4 <== NOT EXECUTED
2022994: 32 bf ff f9 bne,a 2022978 <rtems_rfs_shell_inode+0x3a8> <== NOT EXECUTED
2022998: 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));
202299c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20229a0: 7f ff fe cc call 20224d0 <rtems_rfs_inode_get_block> <== NOT EXECUTED
20229a4: 90 07 bf d4 add %fp, -44, %o0 <== NOT EXECUTED
20229a8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
20229ac: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
20229b0: 40 00 8e f5 call 2046584 <printf> <== NOT EXECUTED
20229b4: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 2062af0 <rtems_rfs_rtems_eval_config+0x170><== NOT EXECUTED
}
}
rc = rtems_rfs_inode_close (fs, &inode);
20229b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20229bc: 40 00 63 14 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
20229c0: 92 07 bf d4 add %fp, -44, %o1 <== NOT EXECUTED
if (rc > 0)
20229c4: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
20229c8: 24 80 00 0e ble,a 2022a00 <rtems_rfs_shell_inode+0x430> <== NOT EXECUTED
20229cc: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
20229d0: 7f ff fe e9 call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
20229d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("error: closing inode handle: ino=%" PRIu32 ": (%d) %s\n",
20229d8: 40 00 98 a8 call 2048c78 <strerror> <== NOT EXECUTED
20229dc: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
20229e0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20229e4: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
20229e8: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 2062af8 <rtems_rfs_rtems_eval_config+0x178><== NOT EXECUTED
20229ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20229f0: 40 00 8e e5 call 2046584 <printf> <== NOT EXECUTED
20229f4: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
20229f8: 81 c7 e0 08 ret <== NOT EXECUTED
20229fc: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
2022a00: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
2022a04: 08 bf ff 48 bleu 2022724 <rtems_rfs_shell_inode+0x154> <== NOT EXECUTED
2022a08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return 1;
}
}
}
rtems_rfs_shell_unlock_rfs (fs);
2022a0c: 7f ff fe da call 2022574 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2022a10: b0 10 20 00 clr %i0 <== NOT EXECUTED
return 0;
}
2022a14: 81 c7 e0 08 ret <== NOT EXECUTED
2022a18: 81 e8 00 00 restore <== NOT EXECUTED
02022518 <rtems_rfs_shell_lock_rfs>:
/**
* Lock the file system.
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
2022518: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
202251c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== 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);
2022520: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022524: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
2022528: 7f ff ab 05 call 200d13c <rtems_semaphore_obtain> <== NOT EXECUTED
202252c: 94 10 20 00 clr %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2022530: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2022534: 02 80 00 0e be 202256c <rtems_rfs_shell_lock_rfs+0x54> <== NOT EXECUTED
2022538: 01 00 00 00 nop <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
202253c: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
2022540: 40 00 04 5a call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
2022544: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2022548: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
202254c: 02 80 00 08 be 202256c <rtems_rfs_shell_lock_rfs+0x54> <== NOT EXECUTED
2022550: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2022554: 7f ff 97 f2 call 200851c <rtems_status_text> <== NOT EXECUTED
2022558: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
202255c: 31 00 81 8a sethi %hi(0x2062800), %i0 <== NOT EXECUTED
2022560: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
2022564: 40 00 90 08 call 2046584 <printf> <== NOT EXECUTED
2022568: 91 ee 20 98 restore %i0, 0x98, %o0 <== NOT EXECUTED
202256c: 81 c7 e0 08 ret <== NOT EXECUTED
2022570: 81 e8 00 00 restore <== NOT EXECUTED
02022574 <rtems_rfs_shell_unlock_rfs>:
/**
* Unlock the file system.
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
2022574: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2022578: fa 06 20 80 ld [ %i0 + 0x80 ], %i5 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
202257c: 40 00 53 7a call 2037364 <rtems_rfs_buffers_release> <== NOT EXECUTED
2022580: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2022584: 7f ff ab 38 call 200d264 <rtems_semaphore_release> <== NOT EXECUTED
2022588: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
202258c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2022590: 02 80 00 0e be 20225c8 <rtems_rfs_shell_unlock_rfs+0x54> <== NOT EXECUTED
2022594: 01 00 00 00 nop <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2022598: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
202259c: 40 00 04 43 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
20225a0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20225a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20225a8: 02 80 00 08 be 20225c8 <rtems_rfs_shell_unlock_rfs+0x54> <== NOT EXECUTED
20225ac: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
20225b0: 7f ff 97 db call 200851c <rtems_status_text> <== NOT EXECUTED
20225b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20225b8: 31 00 81 8a sethi %hi(0x2062800), %i0 <== NOT EXECUTED
20225bc: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
20225c0: 40 00 8f f1 call 2046584 <printf> <== NOT EXECUTED
20225c4: 91 ee 20 70 restore %i0, 0x70, %o0 <== NOT EXECUTED
20225c8: 81 c7 e0 08 ret <== NOT EXECUTED
20225cc: 81 e8 00 00 restore <== NOT EXECUTED
02023264 <rtems_rfs_shell_usage>:
}
void
rtems_rfs_shell_usage (const char* arg)
{
2023264: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
2023268: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202326c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2023270: 40 00 8c c5 call 2046584 <printf> <== NOT EXECUTED
2023274: 90 12 23 88 or %o0, 0x388, %o0 <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
2023278: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
202327c: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023280: 40 00 8c c1 call 2046584 <printf> <== NOT EXECUTED
2023284: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 2062fa0 <rtems_rfs_rtems_eval_config+0x620><== NOT EXECUTED
printf (" where:\n");
2023288: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
202328c: 40 00 8d 59 call 20467f0 <puts> <== NOT EXECUTED
2023290: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 2062fc0 <rtems_rfs_rtems_eval_config+0x640><== NOT EXECUTED
printf (" path: Path to the mounted RFS file system\n");
2023294: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023298: 40 00 8d 56 call 20467f0 <puts> <== NOT EXECUTED
202329c: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 2062fd0 <rtems_rfs_rtems_eval_config+0x650><== NOT EXECUTED
printf (" command: A debugger command. See -l for a list plus help.\n");
20232a0: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20232a4: 40 00 8d 53 call 20467f0 <puts> <== NOT EXECUTED
20232a8: 90 12 20 08 or %o0, 8, %o0 ! 2063008 <rtems_rfs_rtems_eval_config+0x688><== NOT EXECUTED
printf (" -h: This help\n");
20232ac: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20232b0: 40 00 8d 50 call 20467f0 <puts> <== NOT EXECUTED
20232b4: 90 12 20 48 or %o0, 0x48, %o0 ! 2063048 <rtems_rfs_rtems_eval_config+0x6c8><== NOT EXECUTED
printf (" -l: The debugger command list.\n");
20232b8: 31 00 81 8c sethi %hi(0x2063000), %i0 <== NOT EXECUTED
20232bc: 40 00 8d 4d call 20467f0 <puts> <== NOT EXECUTED
20232c0: 91 ee 20 60 restore %i0, 0x60, %o0 <== NOT EXECUTED
0203c280 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
203c280: 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))
203c284: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
203c288: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
203c28c: e2 17 a0 5e lduh [ %fp + 0x5e ], %l1
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
203c290: 7f ff 9d 06 call 20236a8 <rtems_rfs_trace>
203c294: 92 10 20 00 clr %o1
203c298: 80 8a 20 ff btst 0xff, %o0
203c29c: 22 80 00 1a be,a 203c304 <rtems_rfs_symlink+0x84> <== ALWAYS TAKEN
203c2a0: c2 06 20 08 ld [ %i0 + 8 ], %g1
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
203c2a4: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c2a8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203c2ac: 90 12 23 00 or %o0, 0x300, %o0 <== NOT EXECUTED
203c2b0: 40 00 28 b5 call 2046584 <printf> <== NOT EXECUTED
203c2b4: a4 10 20 00 clr %l2 <== NOT EXECUTED
for (c = 0; c < length; c++)
203c2b8: 10 80 00 05 b 203c2cc <rtems_rfs_symlink+0x4c> <== NOT EXECUTED
203c2bc: 80 a4 80 1a cmp %l2, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
203c2c0: 40 00 29 1e call 2046738 <putchar> <== NOT EXECUTED
203c2c4: a4 04 a0 01 inc %l2 <== 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++)
203c2c8: 80 a4 80 1a cmp %l2, %i2 <== NOT EXECUTED
203c2cc: 26 bf ff fd bl,a 203c2c0 <rtems_rfs_symlink+0x40> <== NOT EXECUTED
203c2d0: d0 4e 40 12 ldsb [ %i1 + %l2 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
203c2d4: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
203c2d8: 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:");
203c2dc: 40 00 28 aa call 2046584 <printf> <== NOT EXECUTED
203c2e0: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
203c2e4: 10 80 00 05 b 203c2f8 <rtems_rfs_symlink+0x78> <== NOT EXECUTED
203c2e8: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
printf ("%c", link[c]);
203c2ec: 40 00 29 13 call 2046738 <putchar> <== NOT EXECUTED
203c2f0: 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++)
203c2f4: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
203c2f8: 26 bf ff fd bl,a 203c2ec <rtems_rfs_symlink+0x6c> <== NOT EXECUTED
203c2fc: d0 4e c0 1a ldsb [ %i3 + %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
203c300: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
203c304: 80 a7 00 01 cmp %i4, %g1
203c308: 1a 80 00 72 bcc 203c4d0 <rtems_rfs_symlink+0x250> <== NEVER TAKEN
203c30c: b4 10 20 5b mov 0x5b, %i2
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
203c310: 40 00 32 81 call 2048d14 <strlen>
203c314: 90 10 00 19 mov %i1, %o0
203c318: 82 07 bf f8 add %fp, -8, %g1
203c31c: 96 10 00 08 mov %o0, %o3
203c320: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
203c324: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
203c328: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
203c32c: 90 10 00 18 mov %i0, %o0
203c330: 92 10 00 10 mov %l0, %o1
203c334: 94 10 00 19 mov %i1, %o2
203c338: 19 00 00 28 sethi %hi(0xa000), %o4
203c33c: 9a 10 20 01 mov 1, %o5
203c340: 7f ff fd 89 call 203b964 <rtems_rfs_inode_create>
203c344: 98 13 21 ff or %o4, 0x1ff, %o4
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
203c348: b4 92 20 00 orcc %o0, 0, %i2
203c34c: 34 80 00 62 bg,a 203c4d4 <rtems_rfs_symlink+0x254> <== NEVER TAKEN
203c350: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203c354: d2 07 bf f8 ld [ %fp + -8 ], %o1
203c358: 90 10 00 18 mov %i0, %o0
203c35c: 94 07 bf c4 add %fp, -60, %o2
203c360: 7f ff fc 39 call 203b444 <rtems_rfs_inode_open>
203c364: 96 10 20 01 mov 1, %o3
if (rc > 0)
203c368: b4 92 20 00 orcc %o0, 0, %i2
203c36c: 34 80 00 5a bg,a 203c4d4 <rtems_rfs_symlink+0x254> <== NEVER TAKEN
203c370: 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)
203c374: 80 a7 20 13 cmp %i4, 0x13
203c378: 38 80 00 15 bgu,a 203c3cc <rtems_rfs_symlink+0x14c> <== NEVER TAKEN
203c37c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
203c380: d0 07 bf d0 ld [ %fp + -48 ], %o0
203c384: 92 10 20 00 clr %o1
203c388: 94 10 20 14 mov 0x14, %o2
203c38c: 40 00 24 12 call 20453d4 <memset>
203c390: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
203c394: d0 07 bf d0 ld [ %fp + -48 ], %o0
203c398: 92 10 00 1b mov %i3, %o1
203c39c: 90 02 20 1c add %o0, 0x1c, %o0
203c3a0: 40 00 23 81 call 20451a4 <memcpy>
203c3a4: 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);
203c3a8: c2 07 bf d0 ld [ %fp + -48 ], %g1
203c3ac: c0 28 60 0c clrb [ %g1 + 0xc ]
203c3b0: c2 07 bf d0 ld [ %fp + -48 ], %g1
203c3b4: c0 28 60 0d clrb [ %g1 + 0xd ]
203c3b8: c2 07 bf d0 ld [ %fp + -48 ], %g1
203c3bc: c0 28 60 0e clrb [ %g1 + 0xe ]
203c3c0: c2 07 bf d0 ld [ %fp + -48 ], %g1
203c3c4: 10 80 00 38 b 203c4a4 <rtems_rfs_symlink+0x224>
203c3c8: 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);
203c3cc: 92 07 bf c4 add %fp, -60, %o1 <== NOT EXECUTED
203c3d0: 7f ff e6 ca call 2035ef8 <rtems_rfs_block_map_open> <== NOT EXECUTED
203c3d4: 94 07 bf 74 add %fp, -140, %o2 <== NOT EXECUTED
203c3d8: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
203c3dc: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
203c3e0: 14 80 00 18 bg 203c440 <rtems_rfs_symlink+0x1c0> <== NOT EXECUTED
203c3e4: 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);
203c3e8: 92 07 bf 74 add %fp, -140, %o1 <== NOT EXECUTED
203c3ec: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203c3f0: 7f ff e8 1f call 203646c <rtems_rfs_block_map_grow> <== NOT EXECUTED
203c3f4: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
if (rc > 0)
203c3f8: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203c3fc: 14 80 00 0e bg 203c434 <rtems_rfs_symlink+0x1b4> <== NOT EXECUTED
203c400: 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);
203c404: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203c408: c0 2f bf ec clrb [ %fp + -20 ] <== NOT EXECUTED
handle->bnum = 0;
203c40c: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
handle->buffer = NULL;
203c410: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
203c414: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c418: 92 07 bf ec add %fp, -20, %o1 <== NOT EXECUTED
203c41c: 7f ff ea a6 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
203c420: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
203c424: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203c428: 04 80 00 0a ble 203c450 <rtems_rfs_symlink+0x1d0> <== NOT EXECUTED
203c42c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
203c430: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c434: 7f ff e7 13 call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
203c438: 92 07 bf 74 add %fp, -140, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
203c43c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c440: 7f ff fc 73 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203c444: 92 07 bf c4 add %fp, -60, %o1 <== NOT EXECUTED
return rc;
203c448: 81 c7 e0 08 ret <== NOT EXECUTED
203c44c: 91 e8 00 1a restore %g0, %i2, %o0 <== NOT EXECUTED
}
data = rtems_rfs_buffer_data (&buffer);
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
203c450: 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);
203c454: f4 00 60 1c ld [ %g1 + 0x1c ], %i2 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
203c458: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
203c45c: 40 00 23 de call 20453d4 <memset> <== NOT EXECUTED
203c460: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
203c464: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203c468: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203c46c: 40 00 23 4e call 20451a4 <memcpy> <== NOT EXECUTED
203c470: 92 10 00 1b mov %i3, %o1 <== 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);
203c474: 92 07 bf ec add %fp, -20, %o1 <== NOT EXECUTED
203c478: 7f ff ea 1d call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203c47c: 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);
203c480: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
203c484: c0 2f bf ec clrb [ %fp + -20 ] <== NOT EXECUTED
handle->bnum = 0;
203c488: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
handle->buffer = NULL;
203c48c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
203c490: 7f ff e6 fc call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
203c494: 92 07 bf 74 add %fp, -140, %o1 <== NOT EXECUTED
if (rc > 0)
203c498: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203c49c: 14 bf ff e9 bg 203c440 <rtems_rfs_symlink+0x1c0> <== NOT EXECUTED
203c4a0: 90 10 00 18 mov %i0, %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);
203c4a4: c2 07 bf d0 ld [ %fp + -48 ], %g1
203c4a8: 85 37 20 08 srl %i4, 8, %g2
203c4ac: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
203c4b0: c2 07 bf d0 ld [ %fp + -48 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
203c4b4: 90 10 00 18 mov %i0, %o0
203c4b8: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203c4bc: 82 10 20 01 mov 1, %g1
203c4c0: 92 07 bf c4 add %fp, -60, %o1
203c4c4: 7f ff fc 52 call 203b60c <rtems_rfs_inode_close>
203c4c8: c2 2f bf d4 stb %g1, [ %fp + -44 ]
203c4cc: b4 10 00 08 mov %o0, %i2
return rc;
}
203c4d0: b0 10 00 1a mov %i2, %i0
203c4d4: 81 c7 e0 08 ret
203c4d8: 81 e8 00 00 restore
0203c4dc <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)
{
203c4dc: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
203c4e0: 90 10 20 04 mov 4, %o0
203c4e4: 92 10 20 00 clr %o1
203c4e8: 7f ff 9c 70 call 20236a8 <rtems_rfs_trace>
203c4ec: ba 10 00 18 mov %i0, %i5
203c4f0: 80 8a 20 ff btst 0xff, %o0
203c4f4: 22 80 00 07 be,a 203c510 <rtems_rfs_symlink_read+0x34> <== ALWAYS TAKEN
203c4f8: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
203c4fc: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c500: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203c504: 40 00 28 20 call 2046584 <printf> <== NOT EXECUTED
203c508: 90 12 23 30 or %o0, 0x330, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
203c50c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c510: 92 10 00 19 mov %i1, %o1
203c514: 94 07 bf c8 add %fp, -56, %o2
203c518: 7f ff fb cb call 203b444 <rtems_rfs_inode_open>
203c51c: 96 10 20 01 mov 1, %o3
if (rc)
203c520: b0 92 20 00 orcc %o0, 0, %i0
203c524: 12 80 00 0d bne 203c558 <rtems_rfs_symlink_read+0x7c> <== NEVER TAKEN
203c528: d2 07 bf d4 ld [ %fp + -44 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
203c52c: 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);
203c530: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
203c534: 85 28 a0 08 sll %g2, 8, %g2
203c538: 84 08 80 01 and %g2, %g1, %g2
203c53c: 03 00 00 28 sethi %hi(0xa000), %g1
203c540: 80 a0 80 01 cmp %g2, %g1
203c544: 02 80 00 07 be 203c560 <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
203c548: 90 10 00 1d mov %i5, %o0
{
rtems_rfs_inode_close (fs, &inode);
203c54c: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
203c550: 7f ff fc 2f call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203c554: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
203c558: 81 c7 e0 08 ret <== NOT EXECUTED
203c55c: 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);
203c560: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
}
*length = rtems_rfs_inode_get_block_offset (&inode);
203c564: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
203c568: 95 2a a0 08 sll %o2, 8, %o2
203c56c: 94 10 40 0a or %g1, %o2, %o2
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
203c570: 80 a2 80 1b cmp %o2, %i3
203c574: 38 80 00 02 bgu,a 203c57c <rtems_rfs_symlink_read+0xa0>
203c578: 94 10 00 1b mov %i3, %o2
203c57c: 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);
203c580: c2 0a 60 0d ldub [ %o1 + 0xd ], %g1
203c584: c4 0a 60 0c ldub [ %o1 + 0xc ], %g2
203c588: 83 28 60 10 sll %g1, 0x10, %g1
203c58c: 85 28 a0 18 sll %g2, 0x18, %g2
203c590: 84 10 80 01 or %g2, %g1, %g2
203c594: c2 0a 60 0f ldub [ %o1 + 0xf ], %g1
203c598: 84 10 80 01 or %g2, %g1, %g2
203c59c: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
203c5a0: 83 28 60 08 sll %g1, 8, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
203c5a4: 80 90 80 01 orcc %g2, %g1, %g0
203c5a8: 32 80 00 07 bne,a 203c5c4 <rtems_rfs_symlink_read+0xe8> <== NEVER TAKEN
203c5ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
203c5b0: 90 10 00 1a mov %i2, %o0
203c5b4: 40 00 22 fc call 20451a4 <memcpy>
203c5b8: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
203c5bc: 10 80 00 35 b 203c690 <rtems_rfs_symlink_read+0x1b4>
203c5c0: 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);
203c5c4: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
203c5c8: 7f ff e6 4c call 2035ef8 <rtems_rfs_block_map_open> <== NOT EXECUTED
203c5cc: 94 07 bf 78 add %fp, -136, %o2 <== NOT EXECUTED
203c5d0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
if (rc > 0)
203c5d4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
203c5d8: 14 80 00 2a bg 203c680 <rtems_rfs_symlink_read+0x1a4> <== NOT EXECUTED
203c5dc: 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);
203c5e0: 92 07 bf 78 add %fp, -136, %o1 <== NOT EXECUTED
203c5e4: 94 10 20 00 clr %o2 <== NOT EXECUTED
203c5e8: 96 10 20 00 clr %o3 <== NOT EXECUTED
203c5ec: 7f ff e7 76 call 20363c4 <rtems_rfs_block_map_seek> <== NOT EXECUTED
203c5f0: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
if (rc > 0)
203c5f4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203c5f8: 14 80 00 0d bg 203c62c <rtems_rfs_symlink_read+0x150> <== NOT EXECUTED
203c5fc: 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);
203c600: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203c604: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
203c608: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
handle->buffer = NULL;
203c60c: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
203c610: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c614: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
203c618: 7f ff ea 27 call 2036eb4 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
203c61c: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
203c620: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203c624: 04 80 00 06 ble 203c63c <rtems_rfs_symlink_read+0x160> <== NOT EXECUTED
203c628: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
203c62c: 7f ff e6 95 call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
203c630: 92 07 bf 78 add %fp, -136, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
203c634: 10 80 00 13 b 203c680 <rtems_rfs_symlink_read+0x1a4> <== NOT EXECUTED
203c638: 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);
203c63c: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
203c640: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
203c644: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
203c648: 40 00 22 d7 call 20451a4 <memcpy> <== NOT EXECUTED
203c64c: 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);
203c650: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED
203c654: 7f ff e9 a6 call 2036cec <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203c658: 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);
203c65c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
203c660: c0 2f bf f0 clrb [ %fp + -16 ] <== NOT EXECUTED
handle->bnum = 0;
203c664: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
handle->buffer = NULL;
203c668: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
203c66c: 7f ff e6 85 call 2036080 <rtems_rfs_block_map_close> <== NOT EXECUTED
203c670: 92 07 bf 78 add %fp, -136, %o1 <== NOT EXECUTED
if (rc > 0)
203c674: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203c678: 04 80 00 06 ble 203c690 <rtems_rfs_symlink_read+0x1b4> <== NOT EXECUTED
203c67c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
203c680: 7f ff fb e3 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203c684: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
return rc;
203c688: 81 c7 e0 08 ret <== NOT EXECUTED
203c68c: 81 e8 00 00 restore <== NOT EXECUTED
}
}
rc = rtems_rfs_inode_close (fs, &inode);
203c690: 7f ff fb df call 203b60c <rtems_rfs_inode_close>
203c694: 92 07 bf c8 add %fp, -56, %o1
203c698: b0 10 00 08 mov %o0, %i0
return rc;
}
203c69c: 81 c7 e0 08 ret
203c6a0: 81 e8 00 00 restore
020236ec <rtems_rfs_trace_clear_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
20236ec: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
20236f0: 03 00 81 ba sethi %hi(0x206e800), %g1 <== NOT EXECUTED
20236f4: c4 18 63 50 ldd [ %g1 + 0x350 ], %g2 ! 206eb50 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
20236f8: 98 28 80 18 andn %g2, %i0, %o4 <== NOT EXECUTED
20236fc: 9a 28 c0 19 andn %g3, %i1, %o5 <== NOT EXECUTED
return state;
}
2023700: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
2023704: d8 38 63 50 std %o4, [ %g1 + 0x350 ] <== NOT EXECUTED
return state;
}
2023708: 81 c7 e0 08 ret <== NOT EXECUTED
202370c: 93 e8 00 03 restore %g0, %g3, %o1 <== NOT EXECUTED
020236c8 <rtems_rfs_trace_set_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
20236c8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
20236cc: 03 00 81 ba sethi %hi(0x206e800), %g1 <== NOT EXECUTED
20236d0: c4 18 63 50 ldd [ %g1 + 0x350 ], %g2 ! 206eb50 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
20236d4: 98 16 00 02 or %i0, %g2, %o4 <== NOT EXECUTED
20236d8: 9a 16 40 03 or %i1, %g3, %o5 <== NOT EXECUTED
return state;
}
20236dc: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags |= mask;
20236e0: d8 38 63 50 std %o4, [ %g1 + 0x350 ] <== NOT EXECUTED
return state;
}
20236e4: 81 c7 e0 08 ret <== NOT EXECUTED
20236e8: 93 e8 00 03 restore %g0, %g3, %o1 <== NOT EXECUTED
02023710 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
2023710: 9d e3 be f8 save %sp, -264, %sp <== NOT EXECUTED
const char* table[] =
2023714: 13 00 81 8d sethi %hi(0x2063400), %o1 <== NOT EXECUTED
2023718: 90 07 bf 64 add %fp, -156, %o0 <== NOT EXECUTED
202371c: 92 12 63 04 or %o1, 0x304, %o1 <== NOT EXECUTED
2023720: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2023724: 35 00 81 8d sethi %hi(0x2063400), %i2 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2023728: 21 00 81 8d sethi %hi(0x2063400), %l0 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
202372c: 40 00 86 9e call 20451a4 <memcpy> <== NOT EXECUTED
2023730: 23 00 81 8d sethi %hi(0x2063400), %l1 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2023734: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
2023738: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
202373c: a4 10 20 00 clr %l2 <== NOT EXECUTED
2023740: a6 10 20 00 clr %l3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
2023744: a8 10 20 00 clr %l4 <== NOT EXECUTED
2023748: aa 10 20 00 clr %l5 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
202374c: b4 16 a0 90 or %i2, 0x90, %i2 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2023750: a0 14 20 98 or %l0, 0x98, %l0 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
2023754: a2 14 60 a0 or %l1, 0xa0, %l1 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2023758: 10 80 00 68 b 20238f8 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
202375c: 37 00 81 ba sethi %hi(0x206e800), %i3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2023760: ec 06 40 01 ld [ %i1 + %g1 ], %l6 <== NOT EXECUTED
2023764: c2 4d 80 00 ldsb [ %l6 ], %g1 <== NOT EXECUTED
2023768: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
202376c: 12 80 00 25 bne 2023800 <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
2023770: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
switch (argv[arg][1])
2023774: c2 4d a0 01 ldsb [ %l6 + 1 ], %g1 <== NOT EXECUTED
2023778: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
202377c: 02 80 00 06 be 2023794 <rtems_rfs_trace_shell_command+0x84><== NOT EXECUTED
2023780: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
2023784: 32 80 00 1a bne,a 20237ec <rtems_rfs_trace_shell_command+0xdc><== NOT EXECUTED
2023788: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
202378c: 10 80 00 08 b 20237ac <rtems_rfs_trace_shell_command+0x9c><== NOT EXECUTED
2023790: 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]);
2023794: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2023798: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
202379c: 40 00 8b 7a call 2046584 <printf> <== NOT EXECUTED
20237a0: 90 12 20 20 or %o0, 0x20, %o0 ! 2063420 <rtems_rfs_rtems_eval_config+0xaa0><== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
20237a4: 81 c7 e0 08 ret <== NOT EXECUTED
20237a8: 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]);
20237ac: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
20237b0: 39 00 81 8d sethi %hi(0x2063400), %i4 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
20237b4: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
20237b8: 40 00 8b 73 call 2046584 <printf> <== NOT EXECUTED
20237bc: ba 10 20 00 clr %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
20237c0: b8 17 20 70 or %i4, 0x70, %i4 <== NOT EXECUTED
20237c4: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
20237c8: d2 00 40 1d ld [ %g1 + %i5 ], %o1 <== NOT EXECUTED
20237cc: 40 00 8b 6e call 2046584 <printf> <== NOT EXECUTED
20237d0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20237d4: 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++)
20237d8: 80 a7 60 9c cmp %i5, 0x9c <== NOT EXECUTED
20237dc: 12 bf ff fb bne 20237c8 <rtems_rfs_trace_shell_command+0xb8><== NOT EXECUTED
20237e0: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
20237e4: 81 c7 e0 08 ret <== NOT EXECUTED
20237e8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
default:
printf ("error: unknown option\n");
return 1;
20237ec: 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");
20237f0: 40 00 8c 00 call 20467f0 <puts> <== NOT EXECUTED
20237f4: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
return 1;
20237f8: 81 c7 e0 08 ret <== NOT EXECUTED
20237fc: 81 e8 00 00 restore <== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2023800: 40 00 93 35 call 20484d4 <strcmp> <== NOT EXECUTED
2023804: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2023808: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202380c: 22 80 00 02 be,a 2023814 <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
2023810: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2023814: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2023818: 40 00 93 2f call 20484d4 <strcmp> <== NOT EXECUTED
202381c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2023820: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023824: 22 80 00 2e be,a 20238dc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2023828: ba 10 20 00 clr %i5 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
202382c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2023830: 40 00 93 29 call 20484d4 <strcmp> <== NOT EXECUTED
2023834: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2023838: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202383c: 12 80 00 09 bne 2023860 <rtems_rfs_trace_shell_command+0x150><== NOT EXECUTED
2023840: 94 10 20 00 clr %o2 <== NOT EXECUTED
{
if (set)
2023844: 80 8f 60 ff btst 0xff, %i5 <== NOT EXECUTED
2023848: 22 80 00 23 be,a 20238d4 <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED
202384c: 25 3f ff ff sethi %hi(0xfffffc00), %l2 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
2023850: 29 3f ff ff sethi %hi(0xfffffc00), %l4 <== NOT EXECUTED
2023854: a8 15 23 ff or %l4, 0x3ff, %l4 ! ffffffff <RAM_END+0xfdbfffff><== NOT EXECUTED
2023858: 10 80 00 21 b 20238dc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
202385c: aa 10 00 14 mov %l4, %l5 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
2023860: 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)
2023864: 84 07 bf 64 add %fp, -156, %g2 <== NOT EXECUTED
2023868: d2 00 80 01 ld [ %g2 + %g1 ], %o1 <== NOT EXECUTED
202386c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2023870: 40 00 93 19 call 20484d4 <strcmp> <== NOT EXECUTED
2023874: d4 27 bf 5c st %o2, [ %fp + -164 ] <== NOT EXECUTED
2023878: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202387c: 12 80 00 10 bne 20238bc <rtems_rfs_trace_shell_command+0x1ac><== NOT EXECUTED
2023880: d4 07 bf 5c ld [ %fp + -164 ], %o2 <== NOT EXECUTED
{
if (set)
set_value = 1ULL << t;
2023884: 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)
2023888: 80 8f 60 ff btst 0xff, %i5 <== NOT EXECUTED
202388c: 02 80 00 07 be 20238a8 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
2023890: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
set_value = 1ULL << t;
2023894: 40 00 e0 8b call 205bac0 <__ashldi3> <== NOT EXECUTED
2023898: 01 00 00 00 nop <== NOT EXECUTED
202389c: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
20238a0: 10 80 00 0f b 20238dc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
20238a4: aa 10 00 09 mov %o1, %l5 <== NOT EXECUTED
else
clear_value = 1ULL << t;
20238a8: 40 00 e0 86 call 205bac0 <__ashldi3> <== NOT EXECUTED
20238ac: 01 00 00 00 nop <== NOT EXECUTED
20238b0: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
20238b4: 10 80 00 0a b 20238dc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
20238b8: a6 10 00 09 mov %o1, %l3 <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
20238bc: 94 02 a0 01 inc %o2 <== NOT EXECUTED
20238c0: 80 a2 a0 27 cmp %o2, 0x27 <== NOT EXECUTED
20238c4: 12 bf ff e8 bne 2023864 <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
20238c8: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
20238cc: 10 80 00 05 b 20238e0 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
20238d0: c4 1e e3 50 ldd [ %i3 + 0x350 ], %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;
20238d4: a4 14 a3 ff or %l2, 0x3ff, %l2 <== NOT EXECUTED
20238d8: a6 10 00 12 mov %l2, %l3 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
20238dc: c4 1e e3 50 ldd [ %i3 + 0x350 ], %g2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
20238e0: b8 07 20 01 inc %i4 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
20238e4: 84 15 00 02 or %l4, %g2, %g2 <== NOT EXECUTED
20238e8: 86 15 40 03 or %l5, %g3, %g3 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
20238ec: 84 28 80 12 andn %g2, %l2, %g2 <== NOT EXECUTED
20238f0: 86 28 c0 13 andn %g3, %l3, %g3 <== NOT EXECUTED
20238f4: c4 3e e3 50 std %g2, [ %i3 + 0x350 ] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
20238f8: 80 a7 00 18 cmp %i4, %i0 <== NOT EXECUTED
20238fc: 06 bf ff 99 bl 2023760 <rtems_rfs_trace_shell_command+0x50><== NOT EXECUTED
2023900: 83 2f 20 02 sll %i4, 2, %g1 <== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
2023904: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
2023908: 81 c7 e0 08 ret <== NOT EXECUTED
202390c: 81 e8 00 00 restore <== NOT EXECUTED
0203bed4 <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)
{
203bed4: 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))
203bed8: 90 10 20 00 clr %o0
203bedc: 13 00 80 00 sethi %hi(0x2000000), %o1
203bee0: 7f ff 9d f2 call 20236a8 <rtems_rfs_trace>
203bee4: ba 10 00 18 mov %i0, %i5
203bee8: 80 8a 20 ff btst 0xff, %o0
203beec: 02 80 00 08 be 203bf0c <rtems_rfs_unlink+0x38> <== ALWAYS TAKEN
203bef0: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
203bef4: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203bef8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203befc: 90 12 21 30 or %o0, 0x130, %o0 <== NOT EXECUTED
203bf00: 40 00 29 a1 call 2046584 <printf> <== NOT EXECUTED
203bf04: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
203bf08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203bf0c: 92 10 00 1a mov %i2, %o1
203bf10: 94 07 bf d8 add %fp, -40, %o2
203bf14: 7f ff fd 4c call 203b444 <rtems_rfs_inode_open>
203bf18: 96 10 20 01 mov 1, %o3
if (rc)
203bf1c: b0 92 20 00 orcc %o0, 0, %i0
203bf20: 12 80 00 1f bne 203bf9c <rtems_rfs_unlink+0xc8> <== NEVER TAKEN
203bf24: 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));
203bf28: 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);
203bf2c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
203bf30: 83 28 60 08 sll %g1, 8, %g1
203bf34: 82 08 40 02 and %g1, %g2, %g1
203bf38: 05 00 00 10 sethi %hi(0x4000), %g2
203bf3c: 82 18 40 02 xor %g1, %g2, %g1
203bf40: 80 a0 00 01 cmp %g0, %g1
203bf44: a0 60 3f ff subx %g0, -1, %l0
if (dir)
203bf48: 80 8c 20 ff btst 0xff, %l0
203bf4c: 02 80 00 26 be 203bfe4 <rtems_rfs_unlink+0x110>
203bf50: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
203bf54: 22 80 00 06 be,a 203bf6c <rtems_rfs_unlink+0x98> <== NEVER TAKEN
203bf58: 90 10 20 00 clr %o0 <== NOT EXECUTED
203bf5c: 80 a7 20 01 cmp %i4, 1
203bf60: 12 80 00 22 bne 203bfe8 <rtems_rfs_unlink+0x114> <== NEVER TAKEN
203bf64: 90 10 00 1d mov %i5, %o0
203bf68: 30 80 00 0f b,a 203bfa4 <rtems_rfs_unlink+0xd0>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203bf6c: 7f ff 9d cf call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203bf70: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203bf74: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203bf78: 22 80 00 06 be,a 203bf90 <rtems_rfs_unlink+0xbc> <== NOT EXECUTED
203bf7c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
203bf80: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203bf84: 40 00 2a 1b call 20467f0 <puts> <== NOT EXECUTED
203bf88: 90 12 21 60 or %o0, 0x160, %o0 ! 2068d60 <__FUNCTION__.7646+0x20d8><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
203bf8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203bf90: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203bf94: 7f ff fd 9e call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203bf98: b0 10 20 15 mov 0x15, %i0 <== NOT EXECUTED
return EISDIR;
203bf9c: 81 c7 e0 08 ret
203bfa0: 81 e8 00 00 restore
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
203bfa4: 7f ff f1 87 call 20385c0 <rtems_rfs_dir_empty>
203bfa8: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
203bfac: b0 92 20 00 orcc %o0, 0, %i0
203bfb0: 04 80 00 0d ble 203bfe4 <rtems_rfs_unlink+0x110>
203bfb4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203bfb8: 7f ff 9d bc call 20236a8 <rtems_rfs_trace>
203bfbc: 13 00 80 00 sethi %hi(0x2000000), %o1
203bfc0: 80 8a 20 ff btst 0xff, %o0
203bfc4: 22 80 00 97 be,a 203c220 <rtems_rfs_unlink+0x34c> <== ALWAYS TAKEN
203bfc8: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
203bfcc: 40 00 33 2b call 2048c78 <strerror> <== NOT EXECUTED
203bfd0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203bfd4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203bfd8: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203bfdc: 10 80 00 8e b 203c214 <rtems_rfs_unlink+0x340> <== NOT EXECUTED
203bfe0: 90 12 21 80 or %o0, 0x180, %o0 ! 2068d80 <__FUNCTION__.7646+0x20f8><== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
203bfe4: 90 10 00 1d mov %i5, %o0
203bfe8: 92 10 00 19 mov %i1, %o1
203bfec: 94 07 bf b0 add %fp, -80, %o2
203bff0: 7f ff fd 15 call 203b444 <rtems_rfs_inode_open>
203bff4: 96 10 20 01 mov 1, %o3
if (rc)
203bff8: b0 92 20 00 orcc %o0, 0, %i0
203bffc: 02 80 00 0e be 203c034 <rtems_rfs_unlink+0x160> <== ALWAYS TAKEN
203c000: 90 10 00 1d mov %i5, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c004: 90 10 20 00 clr %o0 <== NOT EXECUTED
203c008: 7f ff 9d a8 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c00c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c010: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c014: 22 80 00 83 be,a 203c220 <rtems_rfs_unlink+0x34c> <== NOT EXECUTED
203c018: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
203c01c: 40 00 33 17 call 2048c78 <strerror> <== NOT EXECUTED
203c020: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c024: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c028: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c02c: 10 80 00 7a b 203c214 <rtems_rfs_unlink+0x340> <== NOT EXECUTED
203c030: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 2068da0 <__FUNCTION__.7646+0x2118><== 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);
203c034: 92 07 bf b0 add %fp, -80, %o1
203c038: 94 10 00 1a mov %i2, %o2
203c03c: 7f ff ef 81 call 2037e40 <rtems_rfs_dir_del_entry>
203c040: 96 10 00 1b mov %i3, %o3
if (rc > 0)
203c044: b0 92 20 00 orcc %o0, 0, %i0
203c048: 04 80 00 0e ble 203c080 <rtems_rfs_unlink+0x1ac> <== ALWAYS TAKEN
203c04c: 01 00 00 00 nop
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c050: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
203c054: 7f ff 9d 95 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c058: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c05c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c060: 22 80 00 59 be,a 203c1c4 <rtems_rfs_unlink+0x2f0> <== NOT EXECUTED
203c064: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
203c068: 40 00 33 04 call 2048c78 <strerror> <== NOT EXECUTED
203c06c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c070: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c074: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c078: 10 80 00 50 b 203c1b8 <rtems_rfs_unlink+0x2e4> <== NOT EXECUTED
203c07c: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 2068dd0 <__FUNCTION__.7646+0x2148><== 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);
203c080: 7f ff ff 1f call 203bcfc <rtems_rfs_inode_get_links>
203c084: 90 07 bf d8 add %fp, -40, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c088: 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);
203c08c: b8 10 00 08 mov %o0, %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c090: 7f ff 9d 86 call 20236a8 <rtems_rfs_trace>
203c094: 90 10 20 00 clr %o0
203c098: 80 8a 20 ff btst 0xff, %o0
203c09c: 02 80 00 09 be 203c0c0 <rtems_rfs_unlink+0x1ec> <== ALWAYS TAKEN
203c0a0: 83 2f 20 10 sll %i4, 0x10, %g1
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
203c0a4: 95 2f 20 10 sll %i4, 0x10, %o2 <== NOT EXECUTED
203c0a8: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c0ac: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
203c0b0: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
203c0b4: 40 00 29 34 call 2046584 <printf> <== NOT EXECUTED
203c0b8: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
if (links > 1)
203c0bc: 83 2f 20 10 sll %i4, 0x10, %g1 <== NOT EXECUTED
203c0c0: 83 30 60 10 srl %g1, 0x10, %g1
203c0c4: 80 a0 60 01 cmp %g1, 1
203c0c8: 08 80 00 0a bleu 203c0f0 <rtems_rfs_unlink+0x21c>
203c0cc: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
203c0d0: b8 07 3f ff add %i4, -1, %i4
* @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);
203c0d4: 85 37 20 08 srl %i4, 8, %g2
203c0d8: c4 28 40 00 stb %g2, [ %g1 ]
203c0dc: c2 07 bf e4 ld [ %fp + -28 ], %g1
203c0e0: f8 28 60 01 stb %i4, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203c0e4: 82 10 20 01 mov 1, %g1
203c0e8: 10 80 00 23 b 203c174 <rtems_rfs_unlink+0x2a0>
203c0ec: 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);
203c0f0: 90 10 00 1d mov %i5, %o0
203c0f4: 7f ff fd 69 call 203b698 <rtems_rfs_inode_delete>
203c0f8: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
203c0fc: b0 92 20 00 orcc %o0, 0, %i0
203c100: 04 80 00 0d ble 203c134 <rtems_rfs_unlink+0x260> <== ALWAYS TAKEN
203c104: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c108: 7f ff 9d 68 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c10c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c110: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c114: 22 80 00 2c be,a 203c1c4 <rtems_rfs_unlink+0x2f0> <== NOT EXECUTED
203c118: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
203c11c: 40 00 32 d7 call 2048c78 <strerror> <== NOT EXECUTED
203c120: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c124: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c128: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c12c: 10 80 00 23 b 203c1b8 <rtems_rfs_unlink+0x2e4> <== NOT EXECUTED
203c130: 90 12 22 28 or %o0, 0x228, %o0 ! 2068e28 <__FUNCTION__.7646+0x21a0><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
203c134: 80 8c 20 ff btst 0xff, %l0
203c138: 02 80 00 10 be 203c178 <rtems_rfs_unlink+0x2a4>
203c13c: 90 07 bf b0 add %fp, -80, %o0
{
links = rtems_rfs_inode_get_links (&parent_inode);
203c140: 7f ff fe ef call 203bcfc <rtems_rfs_inode_get_links>
203c144: 90 07 bf b0 add %fp, -80, %o0
if (links > 1)
203c148: 80 a2 20 01 cmp %o0, 1
203c14c: 08 80 00 03 bleu 203c158 <rtems_rfs_unlink+0x284>
203c150: 82 10 00 08 mov %o0, %g1
links--;
203c154: 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);
203c158: c4 07 bf bc ld [ %fp + -68 ], %g2
203c15c: 87 30 60 08 srl %g1, 8, %g3
203c160: c6 28 80 00 stb %g3, [ %g2 ]
203c164: c4 07 bf bc ld [ %fp + -68 ], %g2
203c168: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203c16c: 82 10 20 01 mov 1, %g1
203c170: 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);
203c174: 90 07 bf b0 add %fp, -80, %o0
203c178: 92 10 20 01 mov 1, %o1
203c17c: 7f ff fd 7b call 203b768 <rtems_rfs_inode_time_stamp_now>
203c180: 94 10 20 01 mov 1, %o2
if (rc > 0)
203c184: b0 92 20 00 orcc %o0, 0, %i0
203c188: 04 80 00 13 ble 203c1d4 <rtems_rfs_unlink+0x300> <== ALWAYS TAKEN
203c18c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c190: 7f ff 9d 46 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c194: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c198: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c19c: 22 80 00 0a be,a 203c1c4 <rtems_rfs_unlink+0x2f0> <== NOT EXECUTED
203c1a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
203c1a4: 40 00 32 b5 call 2048c78 <strerror> <== NOT EXECUTED
203c1a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c1ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c1b0: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c1b4: 90 12 22 58 or %o0, 0x258, %o0 ! 2068e58 <__FUNCTION__.7646+0x21d0><== NOT EXECUTED
203c1b8: 40 00 28 f3 call 2046584 <printf> <== NOT EXECUTED
203c1bc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
203c1c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c1c4: 7f ff fd 12 call 203b60c <rtems_rfs_inode_close> <== NOT EXECUTED
203c1c8: 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);
203c1cc: 10 80 00 15 b 203c220 <rtems_rfs_unlink+0x34c> <== NOT EXECUTED
203c1d0: 90 10 00 1d mov %i5, %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);
203c1d4: 90 10 00 1d mov %i5, %o0
203c1d8: 7f ff fd 0d call 203b60c <rtems_rfs_inode_close>
203c1dc: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
203c1e0: b0 92 20 00 orcc %o0, 0, %i0
203c1e4: 04 80 00 13 ble 203c230 <rtems_rfs_unlink+0x35c> <== ALWAYS TAKEN
203c1e8: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c1ec: 7f ff 9d 2f call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c1f0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c1f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c1f8: 02 80 00 0a be 203c220 <rtems_rfs_unlink+0x34c> <== NOT EXECUTED
203c1fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
203c200: 40 00 32 9e call 2048c78 <strerror> <== NOT EXECUTED
203c204: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c208: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c20c: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c210: 90 12 22 90 or %o0, 0x290, %o0 ! 2068e90 <__FUNCTION__.7646+0x2208><== NOT EXECUTED
203c214: 40 00 28 dc call 2046584 <printf> <== NOT EXECUTED
203c218: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
203c21c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c220: 7f ff fc fb call 203b60c <rtems_rfs_inode_close>
203c224: 92 07 bf d8 add %fp, -40, %o1
return rc;
203c228: 81 c7 e0 08 ret
203c22c: 81 e8 00 00 restore
}
rc = rtems_rfs_inode_close (fs, &target_inode);
203c230: 90 10 00 1d mov %i5, %o0
203c234: 7f ff fc f6 call 203b60c <rtems_rfs_inode_close>
203c238: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c23c: b0 92 20 00 orcc %o0, 0, %i0
203c240: 04 bf ff 57 ble 203bf9c <rtems_rfs_unlink+0xc8> <== ALWAYS TAKEN
203c244: 90 10 20 00 clr %o0
203c248: 7f ff 9d 18 call 20236a8 <rtems_rfs_trace> <== NOT EXECUTED
203c24c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c250: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c254: 02 80 00 09 be 203c278 <rtems_rfs_unlink+0x3a4> <== NOT EXECUTED
203c258: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
203c25c: 40 00 32 87 call 2048c78 <strerror> <== NOT EXECUTED
203c260: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c264: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
203c268: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c26c: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203c270: 40 00 28 c5 call 2046584 <printf> <== NOT EXECUTED
203c274: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 2068ec8 <__FUNCTION__.7646+0x2240><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
203c278: 81 c7 e0 08 ret <== NOT EXECUTED
203c27c: 81 e8 00 00 restore <== NOT EXECUTED
020232c4 <rtems_shell_debugrfs>:
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
20232c4: 9d e3 be f0 save %sp, -272, %sp <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
20232c8: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
20232cc: b8 07 bf 50 add %fp, -176, %i4 <== NOT EXECUTED
20232d0: 92 12 63 e0 or %o1, 0x3e0, %o1 <== NOT EXECUTED
20232d4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20232d8: 40 00 87 b3 call 20451a4 <memcpy> <== NOT EXECUTED
20232dc: 94 10 20 3c mov 0x3c, %o2 <== NOT EXECUTED
};
int arg;
int t;
for (arg = 1; arg < argc; arg++)
20232e0: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
20232e4: 04 80 00 27 ble 2023380 <rtems_shell_debugrfs+0xbc> <== NOT EXECUTED
20232e8: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
{
if (argv[arg][0] != '-')
20232ec: f6 06 60 04 ld [ %i1 + 4 ], %i3 <== NOT EXECUTED
20232f0: c2 4e c0 00 ldsb [ %i3 ], %g1 <== NOT EXECUTED
20232f4: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
20232f8: 12 80 00 20 bne 2023378 <rtems_shell_debugrfs+0xb4> <== NOT EXECUTED
20232fc: 80 a6 20 02 cmp %i0, 2 <== NOT EXECUTED
break;
switch (argv[arg][1])
2023300: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1 <== NOT EXECUTED
2023304: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
2023308: 02 80 00 07 be 2023324 <rtems_shell_debugrfs+0x60> <== NOT EXECUTED
202330c: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
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;
default:
printf ("error: unknown option: %s\n", argv[arg]);
2023310: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] != '-')
break;
switch (argv[arg][1])
2023314: 12 80 00 39 bne 20233f8 <rtems_shell_debugrfs+0x134> <== NOT EXECUTED
2023318: 90 12 20 b8 or %o0, 0xb8, %o0 ! 20630b8 <rtems_rfs_rtems_eval_config+0x738><== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
202331c: 10 80 00 06 b 2023334 <rtems_shell_debugrfs+0x70> <== NOT EXECUTED
2023320: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
break;
switch (argv[arg][1])
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
2023324: 7f ff ff d0 call 2023264 <rtems_rfs_shell_usage> <== NOT EXECUTED
2023328: 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;
202332c: 10 80 00 5d b 20234a0 <rtems_shell_debugrfs+0x1dc> <== NOT EXECUTED
2023330: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
2023334: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
printf (" %s\t\t%s\n", table[t].name, table[t].help);
2023338: 33 00 81 8c sethi %hi(0x2063000), %i1 <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
202333c: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
2023340: 40 00 8c 91 call 2046584 <printf> <== NOT EXECUTED
2023344: 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);
2023348: b2 16 60 a8 or %i1, 0xa8, %i1 <== NOT EXECUTED
printf (" -h: This help\n");
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
202334c: 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);
2023350: d2 07 00 1d ld [ %i4 + %i5 ], %o1 <== NOT EXECUTED
2023354: d4 00 60 08 ld [ %g1 + 8 ], %o2 <== NOT EXECUTED
2023358: 40 00 8c 8b call 2046584 <printf> <== NOT EXECUTED
202335c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2023360: 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++)
2023364: 80 a7 60 3c cmp %i5, 0x3c <== NOT EXECUTED
2023368: 12 bf ff fa bne 2023350 <rtems_shell_debugrfs+0x8c> <== NOT EXECUTED
202336c: 82 07 00 1d add %i4, %i5, %g1 <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
return 0;
2023370: 10 80 00 4c b 20234a0 <rtems_shell_debugrfs+0x1dc> <== NOT EXECUTED
2023374: 90 10 20 00 clr %o0 <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
return 1;
}
}
if ((argc - arg) < 2)
2023378: 32 80 00 06 bne,a 2023390 <rtems_shell_debugrfs+0xcc> <== NOT EXECUTED
202337c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
2023380: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023384: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2023388: 10 80 00 43 b 2023494 <rtems_shell_debugrfs+0x1d0> <== NOT EXECUTED
202338c: 90 12 20 d8 or %o0, 0xd8, %o0 <== NOT EXECUTED
rtems_rfs_get_fs (const char* path, rtems_rfs_file_system** fs)
{
struct statvfs sb;
int rc;
rc = statvfs (path, &sb);
2023390: 40 00 16 ab call 2028e3c <statvfs> <== NOT EXECUTED
2023394: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
if (rc < 0)
2023398: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
202339c: 16 80 00 10 bge 20233dc <rtems_shell_debugrfs+0x118> <== NOT EXECUTED
20233a0: c4 07 bf f4 ld [ %fp + -12 ], %g2 <== NOT EXECUTED
{
printf ("error: cannot statvfs path: %s: (%d) %s\n",
path, errno, strerror (errno));
20233a4: 40 00 7a 3f call 2041ca0 <__errno> <== NOT EXECUTED
20233a8: 01 00 00 00 nop <== NOT EXECUTED
20233ac: 40 00 7a 3d call 2041ca0 <__errno> <== NOT EXECUTED
20233b0: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
int rc;
rc = statvfs (path, &sb);
if (rc < 0)
{
printf ("error: cannot statvfs path: %s: (%d) %s\n",
20233b4: 40 00 96 31 call 2048c78 <strerror> <== NOT EXECUTED
20233b8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20233bc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20233c0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20233c4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
20233c8: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20233cc: 40 00 8c 6e call 2046584 <printf> <== NOT EXECUTED
20233d0: 90 12 21 10 or %o0, 0x110, %o0 ! 2063110 <rtems_rfs_rtems_eval_config+0x790><== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
printf ("error: command not found: %s\n", argv[arg + 1]);
}
}
return 1;
20233d4: 10 80 00 33 b 20234a0 <rtems_shell_debugrfs+0x1dc> <== NOT EXECUTED
20233d8: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
printf ("error: cannot statvfs path: %s: (%d) %s\n",
path, errno, strerror (errno));
return -1;
}
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
20233dc: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
20233e0: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
20233e4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20233e8: 22 80 00 06 be,a 2023400 <rtems_shell_debugrfs+0x13c> <== NOT EXECUTED
20233ec: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
{
printf ("error: path '%s' is not on an RFS file system\n", path);
20233f0: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20233f4: 90 12 21 40 or %o0, 0x140, %o0 ! 2063140 <rtems_rfs_rtems_eval_config+0x7c0><== NOT EXECUTED
20233f8: 10 80 00 27 b 2023494 <rtems_shell_debugrfs+0x1d0> <== NOT EXECUTED
20233fc: 92 10 00 1b mov %i3, %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 =
2023400: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
2023404: 7f ff 9b 86 call 200a21c <rtems_filesystem_eval_path_start><== NOT EXECUTED
2023408: 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);
202340c: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 <== NOT EXECUTED
rtems_filesystem_eval_path_cleanup (&ctx);
2023410: 90 07 bf 8c add %fp, -116, %o0 <== NOT EXECUTED
2023414: 7f ff 9b 88 call 200a234 <rtems_filesystem_eval_path_cleanup><== NOT EXECUTED
2023418: e0 00 60 20 ld [ %g1 + 0x20 ], %l0 <== 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)
202341c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2023420: 12 80 00 20 bne 20234a0 <rtems_shell_debugrfs+0x1dc> <== NOT EXECUTED
2023424: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
2023428: b6 10 20 00 clr %i3 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
202342c: 82 07 bf 50 add %fp, -176, %g1 <== NOT EXECUTED
2023430: f4 06 60 08 ld [ %i1 + 8 ], %i2 <== NOT EXECUTED
2023434: d2 00 40 1b ld [ %g1 + %i3 ], %o1 <== NOT EXECUTED
2023438: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
202343c: 40 00 94 26 call 20484d4 <strcmp> <== NOT EXECUTED
2023440: b6 06 e0 0c add %i3, 0xc, %i3 <== NOT EXECUTED
2023444: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023448: 32 80 00 0d bne,a 202347c <rtems_shell_debugrfs+0x1b8> <== NOT EXECUTED
202344c: b8 07 20 01 inc %i4 <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
2023450: 83 2f 20 02 sll %i4, 2, %g1 <== NOT EXECUTED
2023454: b9 2f 20 04 sll %i4, 4, %i4 <== NOT EXECUTED
2023458: b8 27 00 01 sub %i4, %g1, %i4 <== NOT EXECUTED
202345c: b8 07 80 1c add %fp, %i4, %i4 <== NOT EXECUTED
2023460: c2 07 3f 54 ld [ %i4 + -172 ], %g1 <== NOT EXECUTED
2023464: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2023468: 92 07 7f fe add %i5, -2, %o1 <== NOT EXECUTED
202346c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2023470: 94 06 60 08 add %i1, 8, %o2 <== NOT EXECUTED
2023474: 81 c7 e0 08 ret <== NOT EXECUTED
2023478: 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++)
202347c: 80 a7 20 05 cmp %i4, 5 <== NOT EXECUTED
2023480: 12 bf ff ec bne 2023430 <rtems_shell_debugrfs+0x16c> <== NOT EXECUTED
2023484: 82 07 bf 50 add %fp, -176, %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]);
2023488: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
202348c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2023490: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
2023494: 40 00 8c 3c call 2046584 <printf> <== NOT EXECUTED
2023498: 01 00 00 00 nop <== NOT EXECUTED
}
}
return 1;
202349c: 90 10 20 01 mov 1, %o0 ! 1 <PROM_START+0x1> <== NOT EXECUTED
}
20234a0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
20234a4: 81 c7 e0 08 ret <== NOT EXECUTED
20234a8: 81 e8 00 00 restore <== NOT EXECUTED
020234ac <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
20234ac: 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));
20234b0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20234b4: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
20234b8: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
20234bc: 40 00 87 c6 call 20453d4 <memset> <== NOT EXECUTED
20234c0: 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;
20234c4: b8 10 20 00 clr %i4 <== NOT EXECUTED
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
20234c8: 10 80 00 5b b 2023634 <rtems_shell_rfs_format+0x188> <== NOT EXECUTED
20234cc: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
20234d0: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
20234d4: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
20234d8: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
20234dc: 12 80 00 4e bne 2023614 <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
20234e0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
20234e4: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
20234e8: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED
20234ec: 22 80 00 2e be,a 20235a4 <rtems_shell_rfs_format+0xf8> <== NOT EXECUTED
20234f0: ba 07 60 01 inc %i5 <== NOT EXECUTED
20234f4: 14 80 00 09 bg 2023518 <rtems_shell_rfs_format+0x6c> <== NOT EXECUTED
20234f8: 80 a0 60 73 cmp %g1, 0x73 <== NOT EXECUTED
20234fc: 80 a0 60 49 cmp %g1, 0x49 <== NOT EXECUTED
2023500: 02 80 00 35 be 20235d4 <rtems_shell_rfs_format+0x128> <== NOT EXECUTED
2023504: 80 a0 60 62 cmp %g1, 0x62 <== NOT EXECUTED
2023508: 12 80 00 41 bne 202360c <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
202350c: 11 00 81 77 sethi %hi(0x205dc00), %o0 <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
2023510: 10 80 00 19 b 2023574 <rtems_shell_rfs_format+0xc8> <== NOT EXECUTED
2023514: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
2023518: 02 80 00 0a be 2023540 <rtems_shell_rfs_format+0x94> <== NOT EXECUTED
202351c: 80 a0 60 76 cmp %g1, 0x76 <== NOT EXECUTED
2023520: 02 80 00 06 be 2023538 <rtems_shell_rfs_format+0x8c> <== NOT EXECUTED
2023524: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED
2023528: 12 80 00 39 bne 202360c <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
202352c: 11 00 81 77 sethi %hi(0x205dc00), %o0 <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
2023530: 10 80 00 2b b 20235dc <rtems_shell_rfs_format+0x130> <== NOT EXECUTED
2023534: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
break;
2023538: 10 80 00 3e b 2023630 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
202353c: f6 2f bf fd stb %i3, [ %fp + -3 ] <== NOT EXECUTED
case 's':
arg++;
2023540: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
2023544: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2023548: 06 80 00 05 bl 202355c <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED
202354c: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
2023550: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023554: 10 80 00 40 b 2023654 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2023558: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 20632e0 <rtems_rfs_rtems_eval_config+0x960><== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
202355c: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2023560: 92 10 20 00 clr %o1 <== NOT EXECUTED
2023564: 40 00 9c 68 call 204a704 <strtoul> <== NOT EXECUTED
2023568: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
202356c: 10 80 00 31 b 2023630 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2023570: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
2023574: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2023578: 06 80 00 05 bl 202358c <rtems_shell_rfs_format+0xe0> <== NOT EXECUTED
202357c: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
2023580: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023584: 10 80 00 34 b 2023654 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2023588: 90 12 23 08 or %o0, 0x308, %o0 ! 2063308 <rtems_rfs_rtems_eval_config+0x988><== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
202358c: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2023590: 92 10 20 00 clr %o1 <== NOT EXECUTED
2023594: 40 00 9c 5c call 204a704 <strtoul> <== NOT EXECUTED
2023598: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
202359c: 10 80 00 25 b 2023630 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
20235a0: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
20235a4: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
20235a8: 06 80 00 05 bl 20235bc <rtems_shell_rfs_format+0x110> <== NOT EXECUTED
20235ac: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
20235b0: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20235b4: 10 80 00 28 b 2023654 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
20235b8: 90 12 23 38 or %o0, 0x338, %o0 ! 2063338 <rtems_rfs_rtems_eval_config+0x9b8><== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
20235bc: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
20235c0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20235c4: 40 00 9c 50 call 204a704 <strtoul> <== NOT EXECUTED
20235c8: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
20235cc: 10 80 00 19 b 2023630 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
20235d0: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
20235d4: 10 80 00 17 b 2023630 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
20235d8: f6 2f bf fc stb %i3, [ %fp + -4 ] <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
20235dc: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
20235e0: 06 80 00 05 bl 20235f4 <rtems_shell_rfs_format+0x148> <== NOT EXECUTED
20235e4: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
20235e8: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20235ec: 10 80 00 1a b 2023654 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
20235f0: 90 12 23 68 or %o0, 0x368, %o0 ! 2063368 <rtems_rfs_rtems_eval_config+0x9e8><== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
20235f4: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
20235f8: 92 10 20 00 clr %o1 <== NOT EXECUTED
20235fc: 40 00 9c 42 call 204a704 <strtoul> <== NOT EXECUTED
2023600: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2023604: 10 80 00 0b b 2023630 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2023608: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
default:
printf ("error: invalid option: %s\n", argv[arg]);
202360c: 10 80 00 06 b 2023624 <rtems_shell_rfs_format+0x178> <== NOT EXECUTED
2023610: 90 12 20 a0 or %o0, 0xa0, %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
2023614: 22 80 00 07 be,a 2023630 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2023618: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
202361c: 11 00 81 77 sethi %hi(0x205dc00), %o0 <== NOT EXECUTED
2023620: 90 12 20 c0 or %o0, 0xc0, %o0 ! 205dcc0 <_rodata_start+0x790><== NOT EXECUTED
2023624: 40 00 8b d8 call 2046584 <printf> <== NOT EXECUTED
2023628: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
202362c: 30 80 00 1d b,a 20236a0 <rtems_shell_rfs_format+0x1f4> <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2023630: ba 07 60 01 inc %i5 <== NOT EXECUTED
2023634: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2023638: 06 bf ff a6 bl 20234d0 <rtems_shell_rfs_format+0x24> <== NOT EXECUTED
202363c: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
2023640: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2023644: 12 80 00 08 bne 2023664 <rtems_shell_rfs_format+0x1b8> <== NOT EXECUTED
2023648: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
printf ("error: no driver name provided\n");
202364c: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023650: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 20633a0 <rtems_rfs_rtems_eval_config+0xa20><== NOT EXECUTED
2023654: 40 00 8c 67 call 20467f0 <puts> <== NOT EXECUTED
2023658: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
202365c: 81 c7 e0 08 ret <== NOT EXECUTED
2023660: 81 e8 00 00 restore <== NOT EXECUTED
}
if (rtems_rfs_format (driver, &config) < 0)
2023664: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
2023668: 40 00 5a 64 call 2039ff8 <rtems_rfs_format> <== NOT EXECUTED
202366c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2023670: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023674: 16 80 00 0b bge 20236a0 <rtems_shell_rfs_format+0x1f4> <== NOT EXECUTED
2023678: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
202367c: 40 00 79 89 call 2041ca0 <__errno> <== NOT EXECUTED
2023680: 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",
2023684: 40 00 95 7d call 2048c78 <strerror> <== NOT EXECUTED
2023688: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
202368c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2023690: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2023694: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023698: 40 00 8b bb call 2046584 <printf> <== NOT EXECUTED
202369c: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 20633c0 <rtems_rfs_rtems_eval_config+0xa40><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
20236a0: 81 c7 e0 08 ret <== NOT EXECUTED
20236a4: 81 e8 00 00 restore <== NOT EXECUTED
020177d8 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
20177d8: 9d e3 bf 98 save %sp, -104, %sp
20177dc: 90 10 00 18 mov %i0, %o0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
20177e0: 80 a6 60 00 cmp %i1, 0
20177e4: 02 80 00 2e be 201789c <rtems_signal_send+0xc4>
20177e8: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
20177ec: 40 00 12 9a call 201c254 <_Thread_Get>
20177f0: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
20177f4: c2 07 bf fc ld [ %fp + -4 ], %g1
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
20177f8: b8 10 00 08 mov %o0, %i4
switch ( location ) {
20177fc: 80 a0 60 00 cmp %g1, 0
2017800: 12 80 00 27 bne 201789c <rtems_signal_send+0xc4>
2017804: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
2017808: fa 02 21 58 ld [ %o0 + 0x158 ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
201780c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2017810: 80 a0 60 00 cmp %g1, 0
2017814: 02 80 00 24 be 20178a4 <rtems_signal_send+0xcc>
2017818: 01 00 00 00 nop
if ( asr->is_enabled ) {
201781c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
2017820: 80 a0 60 00 cmp %g1, 0
2017824: 02 80 00 15 be 2017878 <rtems_signal_send+0xa0>
2017828: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
201782c: 7f ff e3 49 call 2010550 <sparc_disable_interrupts>
2017830: 01 00 00 00 nop
*signal_set |= signals;
2017834: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2017838: b2 10 40 19 or %g1, %i1, %i1
201783c: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
2017840: 7f ff e3 48 call 2010560 <sparc_enable_interrupts>
2017844: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
2017848: 03 00 80 f4 sethi %hi(0x203d000), %g1
201784c: 82 10 61 90 or %g1, 0x190, %g1 ! 203d190 <_Per_CPU_Information>
2017850: c4 00 60 08 ld [ %g1 + 8 ], %g2
2017854: 80 a0 a0 00 cmp %g2, 0
2017858: 02 80 00 0f be 2017894 <rtems_signal_send+0xbc>
201785c: 01 00 00 00 nop
2017860: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2017864: 80 a7 00 02 cmp %i4, %g2
2017868: 12 80 00 0b bne 2017894 <rtems_signal_send+0xbc> <== NEVER TAKEN
201786c: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
2017870: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
2017874: 30 80 00 08 b,a 2017894 <rtems_signal_send+0xbc>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2017878: 7f ff e3 36 call 2010550 <sparc_disable_interrupts>
201787c: 01 00 00 00 nop
*signal_set |= signals;
2017880: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2017884: b2 10 40 19 or %g1, %i1, %i1
2017888: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
201788c: 7f ff e3 35 call 2010560 <sparc_enable_interrupts>
2017890: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
2017894: 40 00 12 63 call 201c220 <_Thread_Enable_dispatch>
2017898: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return RTEMS_SUCCESSFUL;
201789c: 81 c7 e0 08 ret
20178a0: 81 e8 00 00 restore
}
_Thread_Enable_dispatch();
20178a4: 40 00 12 5f call 201c220 <_Thread_Enable_dispatch>
20178a8: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
20178ac: 81 c7 e0 08 ret
20178b0: 81 e8 00 00 restore
02006fd4 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
2006fd4: 9d e3 bf a0 save %sp, -96, %sp
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
2006fd8: c2 06 20 08 ld [ %i0 + 8 ], %g1
2006fdc: 80 a0 60 00 cmp %g1, 0
2006fe0: 02 80 00 07 be 2006ffc <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
2006fe4: 13 00 81 bc sethi %hi(0x206f000), %o1
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
2006fe8: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
2006fec: 90 02 20 08 add %o0, 8, %o0
2006ff0: 92 12 61 2c or %o1, 0x12c, %o1
2006ff4: 40 00 f8 6c call 20451a4 <memcpy>
2006ff8: 94 10 20 10 mov 0x10, %o2
2006ffc: 81 c7 e0 08 ret
2007000: 81 e8 00 00 restore
02006f18 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
2006f18: 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 )
2006f1c: 03 00 81 b0 sethi %hi(0x206c000), %g1
2006f20: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 206c3d0 <Stack_check_Initialized>
2006f24: 80 a0 60 00 cmp %g1, 0
2006f28: 12 80 00 23 bne 2006fb4 <rtems_stack_checker_create_extension+0x9c>
2006f2c: 80 a6 60 00 cmp %i1, 0
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
2006f30: 05 00 81 bc sethi %hi(0x206f000), %g2
2006f34: 07 3f bb 7c sethi %hi(0xfeedf000), %g3
2006f38: 82 10 a1 2c or %g2, 0x12c, %g1
2006f3c: 86 10 e0 0d or %g3, 0xd, %g3
2006f40: c6 20 a1 2c st %g3, [ %g2 + 0x12c ]
2006f44: 05 02 eb 43 sethi %hi(0xbad0c00), %g2
2006f48: 84 10 a1 06 or %g2, 0x106, %g2 ! bad0d06 <RAM_END+0x96d0d06>
2006f4c: c4 20 60 04 st %g2, [ %g1 + 4 ]
2006f50: 05 37 ab 7c sethi %hi(0xdeadf000), %g2
2006f54: 84 10 a0 0d or %g2, 0xd, %g2 ! deadf00d <RAM_END+0xdc6df00d>
2006f58: c4 20 60 08 st %g2, [ %g1 + 8 ]
2006f5c: 05 18 03 43 sethi %hi(0x600d0c00), %g2
2006f60: 84 10 a1 06 or %g2, 0x106, %g2 ! 600d0d06 <RAM_END+0x5dcd0d06>
2006f64: 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) {
2006f68: 03 00 81 be sethi %hi(0x206f800), %g1
2006f6c: d0 00 60 00 ld [ %g1 ], %o0
2006f70: 80 a2 20 00 cmp %o0, 0
2006f74: 02 80 00 0c be 2006fa4 <rtems_stack_checker_create_extension+0x8c><== NEVER TAKEN
2006f78: 84 10 60 00 mov %g1, %g2
2006f7c: d4 00 a0 04 ld [ %g2 + 4 ], %o2
2006f80: 80 a2 a0 00 cmp %o2, 0
2006f84: 02 80 00 08 be 2006fa4 <rtems_stack_checker_create_extension+0x8c><== NEVER TAKEN
2006f88: 03 00 81 bc sethi %hi(0x206f000), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
2006f8c: 84 10 61 3c or %g1, 0x13c, %g2 ! 206f13c <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
2006f90: 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;
2006f94: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
2006f98: d4 20 61 3c st %o2, [ %g1 + 0x13c ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
2006f9c: 40 00 f9 0e call 20453d4 <memset>
2006fa0: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
2006fa4: 84 10 20 01 mov 1, %g2
2006fa8: 03 00 81 b0 sethi %hi(0x206c000), %g1
2006fac: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] ! 206c3d0 <Stack_check_Initialized>
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
2006fb0: 80 a6 60 00 cmp %i1, 0
2006fb4: 02 80 00 06 be 2006fcc <rtems_stack_checker_create_extension+0xb4><== NEVER TAKEN
2006fb8: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
2006fbc: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
2006fc0: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
2006fc4: 40 00 f9 04 call 20453d4 <memset>
2006fc8: 92 10 20 a5 mov 0xa5, %o1
return true;
}
2006fcc: 81 c7 e0 08 ret
2006fd0: 91 e8 20 01 restore %g0, 1, %o0
02007110 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
2007110: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
2007114: 03 00 81 be sethi %hi(0x206f800), %g1
2007118: c2 00 60 0c ld [ %g1 + 0xc ], %g1 ! 206f80c <_Per_CPU_Information+0xc>
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
200711c: d0 00 60 b8 ld [ %g1 + 0xb8 ], %o0
2007120: 80 a7 80 08 cmp %fp, %o0
2007124: 0a 80 00 06 bcs 200713c <rtems_stack_checker_is_blown+0x2c><== NEVER TAKEN
2007128: ba 10 20 00 clr %i5
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
200712c: c2 00 60 b4 ld [ %g1 + 0xb4 ], %g1
2007130: 82 02 00 01 add %o0, %g1, %g1
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
2007134: 80 a0 40 1e cmp %g1, %fp
2007138: ba 60 3f ff subx %g0, -1, %i5
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
200713c: 03 00 81 b0 sethi %hi(0x206c000), %g1
2007140: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 206c3d0 <Stack_check_Initialized>
2007144: 80 a0 60 00 cmp %g1, 0
2007148: 02 80 00 09 be 200716c <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
200714c: 92 10 20 01 mov 1, %o1
pattern_ok = (!memcmp(
2007150: 90 02 20 08 add %o0, 8, %o0
2007154: 13 00 81 bc sethi %hi(0x206f000), %o1
2007158: 94 10 20 10 mov 0x10, %o2
200715c: 40 00 f7 e4 call 20450ec <memcmp>
2007160: 92 12 61 2c or %o1, 0x12c, %o1
2007164: 80 a0 00 08 cmp %g0, %o0
2007168: 92 60 3f ff subx %g0, -1, %o1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
200716c: 80 8f 60 ff btst 0xff, %i5
2007170: 02 80 00 04 be 2007180 <rtems_stack_checker_is_blown+0x70><== NEVER TAKEN
2007174: 80 8a 60 ff btst 0xff, %o1
2007178: 12 80 00 06 bne 2007190 <rtems_stack_checker_is_blown+0x80><== ALWAYS TAKEN
200717c: 01 00 00 00 nop
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
2007180: 03 00 81 be sethi %hi(0x206f800), %g1 <== NOT EXECUTED
2007184: d0 00 60 0c ld [ %g1 + 0xc ], %o0 ! 206f80c <_Per_CPU_Information+0xc><== NOT EXECUTED
2007188: 7f ff ff 9f call 2007004 <Stack_check_report_blown_task> <== NOT EXECUTED
200718c: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
2007190: 81 c7 e0 08 ret
2007194: 91 e8 20 00 restore %g0, 0, %o0
02007198 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2007198: 9d e3 bf a0 save %sp, -96, %sp
if ( !print )
200719c: 80 a6 60 00 cmp %i1, 0
20071a0: 02 80 00 14 be 20071f0 <rtems_stack_checker_report_usage_with_plugin+0x58><== NEVER TAKEN
20071a4: 39 00 81 b0 sethi %hi(0x206c000), %i4
return;
print_context = context;
print_handler = print;
20071a8: 3b 00 81 b0 sethi %hi(0x206c000), %i5
)
{
if ( !print )
return;
print_context = context;
20071ac: f0 27 23 d4 st %i0, [ %i4 + 0x3d4 ]
print_handler = print;
20071b0: f2 27 63 d8 st %i1, [ %i5 + 0x3d8 ]
(*print)( context, "Stack usage by thread\n");
20071b4: 90 10 00 18 mov %i0, %o0
20071b8: 13 00 81 7b sethi %hi(0x205ec00), %o1
20071bc: 9f c6 40 00 call %i1
20071c0: 92 12 62 40 or %o1, 0x240, %o1 ! 205ee40 <write_block_string.9313+0x6b8>
(*print)( context,
20071c4: 90 10 00 18 mov %i0, %o0
20071c8: 13 00 81 7b sethi %hi(0x205ec00), %o1
20071cc: 9f c6 40 00 call %i1
20071d0: 92 12 62 58 or %o1, 0x258, %o1 ! 205ee58 <write_block_string.9313+0x6d0>
" 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 );
20071d4: 11 00 80 1b sethi %hi(0x2006c00), %o0
20071d8: 40 00 1d c0 call 200e8d8 <rtems_iterate_over_all_threads>
20071dc: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2006da8 <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);
20071e0: 7f ff fe f2 call 2006da8 <Stack_check_Dump_threads_usage>
20071e4: 90 10 3f ff mov -1, %o0
#endif
print_context = NULL;
20071e8: c0 27 23 d4 clr [ %i4 + 0x3d4 ]
print_handler = NULL;
20071ec: c0 27 63 d8 clr [ %i5 + 0x3d8 ]
20071f0: 81 c7 e0 08 ret
20071f4: 81 e8 00 00 restore
020070ac <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
20070ac: 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);
20070b0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
20070b4: ba 10 20 00 clr %i5
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
20070b8: 80 a7 80 01 cmp %fp, %g1
20070bc: 0a 80 00 06 bcs 20070d4 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
20070c0: 90 00 60 08 add %g1, 8, %o0
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
20070c4: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
20070c8: 82 00 40 02 add %g1, %g2, %g1
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
20070cc: 80 a0 40 1e cmp %g1, %fp
20070d0: 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,
20070d4: 13 00 81 bc sethi %hi(0x206f000), %o1
20070d8: 94 10 20 10 mov 0x10, %o2
20070dc: 40 00 f8 04 call 20450ec <memcmp>
20070e0: 92 12 61 2c or %o1, 0x12c, %o1
20070e4: 80 a0 00 08 cmp %g0, %o0
20070e8: 92 60 3f ff subx %g0, -1, %o1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
20070ec: 80 8f 60 ff btst 0xff, %i5
20070f0: 02 80 00 04 be 2007100 <rtems_stack_checker_switch_extension+0x54><== NEVER TAKEN
20070f4: 80 a2 60 00 cmp %o1, 0
20070f8: 12 80 00 04 bne 2007108 <rtems_stack_checker_switch_extension+0x5c>
20070fc: 01 00 00 00 nop
Stack_check_report_blown_task( running, pattern_ok );
2007100: 7f ff ff c1 call 2007004 <Stack_check_report_blown_task>
2007104: 90 10 00 18 mov %i0, %o0
2007108: 81 c7 e0 08 ret
200710c: 81 e8 00 00 restore
0201f23c <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
201f23c: 9d e3 bf 98 save %sp, -104, %sp
201f240: ba 10 00 18 mov %i0, %i5
long result;
char *end;
if ( !n )
201f244: 80 a6 60 00 cmp %i1, 0
201f248: 02 80 00 25 be 201f2dc <rtems_string_to_int+0xa0>
201f24c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
errno = 0;
201f250: 40 00 8a 94 call 2041ca0 <__errno>
201f254: 01 00 00 00 nop
201f258: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtol( s, &end, base );
201f25c: 94 10 00 1b mov %i3, %o2
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
201f260: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
201f264: 90 10 00 1d mov %i5, %o0
201f268: 40 00 ab ce call 204a1a0 <strtol>
201f26c: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
201f270: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
201f274: b6 10 00 08 mov %o0, %i3
if ( endptr )
201f278: 02 80 00 03 be 201f284 <rtems_string_to_int+0x48>
201f27c: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
201f280: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
201f284: 80 a0 40 1d cmp %g1, %i5
201f288: 02 80 00 15 be 201f2dc <rtems_string_to_int+0xa0>
201f28c: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f290: 40 00 8a 84 call 2041ca0 <__errno>
201f294: 01 00 00 00 nop
201f298: c2 02 00 00 ld [ %o0 ], %g1
201f29c: 80 a0 60 22 cmp %g1, 0x22
201f2a0: 32 80 00 0e bne,a 201f2d8 <rtems_string_to_int+0x9c>
201f2a4: f6 26 40 00 st %i3, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201f2a8: 03 20 00 00 sethi %hi(0x80000000), %g1
201f2ac: 82 38 40 1b xnor %g1, %i3, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f2b0: 80 a0 60 00 cmp %g1, 0
201f2b4: 02 80 00 0a be 201f2dc <rtems_string_to_int+0xa0>
201f2b8: b0 10 20 0a mov 0xa, %i0
201f2bc: 80 a6 e0 00 cmp %i3, 0
201f2c0: 02 80 00 07 be 201f2dc <rtems_string_to_int+0xa0> <== NEVER TAKEN
201f2c4: 03 20 00 00 sethi %hi(0x80000000), %g1
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201f2c8: 80 a6 c0 01 cmp %i3, %g1
201f2cc: 02 80 00 04 be 201f2dc <rtems_string_to_int+0xa0> <== ALWAYS TAKEN
201f2d0: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
201f2d4: f6 26 40 00 st %i3, [ %i1 ] <== NOT EXECUTED
201f2d8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
201f2dc: 81 c7 e0 08 ret
201f2e0: 81 e8 00 00 restore
0200d9a4 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
200d9a4: 9d e3 bf 98 save %sp, -104, %sp
200d9a8: ba 10 00 18 mov %i0, %i5
long result;
char *end;
if ( !n )
200d9ac: 80 a6 60 00 cmp %i1, 0
200d9b0: 02 80 00 25 be 200da44 <rtems_string_to_long+0xa0>
200d9b4: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
errno = 0;
200d9b8: 40 00 0b c2 call 20108c0 <__errno>
200d9bc: 01 00 00 00 nop
200d9c0: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtol( s, &end, base );
200d9c4: 94 10 00 1b mov %i3, %o2
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
200d9c8: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
200d9cc: 90 10 00 1d mov %i5, %o0
200d9d0: 40 00 17 93 call 201381c <strtol>
200d9d4: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
200d9d8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
200d9dc: b6 10 00 08 mov %o0, %i3
if ( endptr )
200d9e0: 02 80 00 03 be 200d9ec <rtems_string_to_long+0x48>
200d9e4: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
200d9e8: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
200d9ec: 80 a0 40 1d cmp %g1, %i5
200d9f0: 02 80 00 15 be 200da44 <rtems_string_to_long+0xa0>
200d9f4: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200d9f8: 40 00 0b b2 call 20108c0 <__errno>
200d9fc: 01 00 00 00 nop
200da00: c2 02 00 00 ld [ %o0 ], %g1
200da04: 80 a0 60 22 cmp %g1, 0x22
200da08: 32 80 00 0e bne,a 200da40 <rtems_string_to_long+0x9c>
200da0c: f6 26 40 00 st %i3, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200da10: 03 20 00 00 sethi %hi(0x80000000), %g1
200da14: 82 38 40 1b xnor %g1, %i3, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200da18: 80 a0 60 00 cmp %g1, 0
200da1c: 02 80 00 0a be 200da44 <rtems_string_to_long+0xa0>
200da20: b0 10 20 0a mov 0xa, %i0
200da24: 80 a6 e0 00 cmp %i3, 0
200da28: 02 80 00 07 be 200da44 <rtems_string_to_long+0xa0> <== NEVER TAKEN
200da2c: 03 20 00 00 sethi %hi(0x80000000), %g1
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200da30: 80 a6 c0 01 cmp %i3, %g1
200da34: 02 80 00 04 be 200da44 <rtems_string_to_long+0xa0> <== ALWAYS TAKEN
200da38: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
200da3c: f6 26 40 00 st %i3, [ %i1 ] <== NOT EXECUTED
200da40: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
200da44: 81 c7 e0 08 ret
200da48: 81 e8 00 00 restore
0200d8d8 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
200d8d8: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
200d8dc: 80 a6 60 00 cmp %i1, 0
200d8e0: 02 80 00 2f be 200d99c <rtems_string_to_long_long+0xc4>
200d8e4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200d8e8: 40 00 0b f6 call 20108c0 <__errno>
200d8ec: 01 00 00 00 nop
200d8f0: c0 22 00 00 clr [ %o0 ]
*n = 0;
200d8f4: c0 26 40 00 clr [ %i1 ]
200d8f8: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
200d8fc: 90 10 00 18 mov %i0, %o0
200d900: 92 07 bf fc add %fp, -4, %o1
200d904: 40 00 17 cf call 2013840 <strtoll>
200d908: 94 10 00 1b mov %i3, %o2
if ( endptr )
200d90c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
200d910: b8 10 00 08 mov %o0, %i4
200d914: ba 10 00 09 mov %o1, %i5
if ( endptr )
200d918: 02 80 00 03 be 200d924 <rtems_string_to_long_long+0x4c>
200d91c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200d920: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200d924: 80 a0 80 18 cmp %g2, %i0
200d928: 02 80 00 1d be 200d99c <rtems_string_to_long_long+0xc4>
200d92c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200d930: 40 00 0b e4 call 20108c0 <__errno>
200d934: 01 00 00 00 nop
200d938: c2 02 00 00 ld [ %o0 ], %g1
200d93c: 80 a0 60 22 cmp %g1, 0x22
200d940: 32 80 00 16 bne,a 200d998 <rtems_string_to_long_long+0xc0>
200d944: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200d948: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
200d94c: 07 3f ff ff sethi %hi(0xfffffc00), %g3
200d950: 84 10 a3 ff or %g2, 0x3ff, %g2
200d954: 86 10 e3 ff or %g3, 0x3ff, %g3
200d958: 84 1f 00 02 xor %i4, %g2, %g2
200d95c: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200d960: 80 90 80 03 orcc %g2, %g3, %g0
200d964: 02 80 00 0e be 200d99c <rtems_string_to_long_long+0xc4>
200d968: 82 10 20 0a mov 0xa, %g1
200d96c: 80 97 00 1d orcc %i4, %i5, %g0
200d970: 02 80 00 0b be 200d99c <rtems_string_to_long_long+0xc4> <== NEVER TAKEN
200d974: 01 00 00 00 nop
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200d978: 03 20 00 00 sethi %hi(0x80000000), %g1
200d97c: 80 a7 00 01 cmp %i4, %g1
200d980: 32 80 00 06 bne,a 200d998 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
200d984: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200d988: 80 a7 60 00 cmp %i5, 0
200d98c: 22 80 00 04 be,a 200d99c <rtems_string_to_long_long+0xc4><== ALWAYS TAKEN
200d990: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
200d994: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200d998: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
}
200d99c: 81 c7 e0 08 ret
200d9a0: 91 e8 00 01 restore %g0, %g1, %o0
0201f2f4 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
201f2f4: 9d e3 bf 98 save %sp, -104, %sp
201f2f8: ba 10 00 18 mov %i0, %i5
unsigned long result;
char *end;
if ( !n )
201f2fc: 80 a6 60 00 cmp %i1, 0
201f300: 02 80 00 23 be 201f38c <rtems_string_to_unsigned_char+0x98>
201f304: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
errno = 0;
201f308: 40 00 8a 66 call 2041ca0 <__errno>
201f30c: 01 00 00 00 nop
201f310: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
201f314: 94 10 00 1b mov %i3, %o2
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
201f318: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
201f31c: 90 10 00 1d mov %i5, %o0
201f320: 40 00 ac f9 call 204a704 <strtoul>
201f324: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
201f328: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
201f32c: b6 10 00 08 mov %o0, %i3
if ( endptr )
201f330: 02 80 00 03 be 201f33c <rtems_string_to_unsigned_char+0x48>
201f334: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
201f338: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
201f33c: 80 a0 40 1d cmp %g1, %i5
201f340: 02 80 00 13 be 201f38c <rtems_string_to_unsigned_char+0x98>
201f344: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f348: 40 00 8a 56 call 2041ca0 <__errno>
201f34c: 01 00 00 00 nop
201f350: c2 02 00 00 ld [ %o0 ], %g1
201f354: 80 a0 60 22 cmp %g1, 0x22
201f358: 12 80 00 07 bne 201f374 <rtems_string_to_unsigned_char+0x80>
201f35c: 80 a6 e0 ff cmp %i3, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
201f360: 82 06 ff ff add %i3, -1, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f364: 80 a0 7f fd cmp %g1, -3
201f368: 18 80 00 09 bgu 201f38c <rtems_string_to_unsigned_char+0x98><== ALWAYS TAKEN
201f36c: b0 10 20 0a mov 0xa, %i0
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
201f370: 80 a6 e0 ff cmp %i3, 0xff <== NOT EXECUTED
201f374: 28 80 00 08 bleu,a 201f394 <rtems_string_to_unsigned_char+0xa0>
201f378: f6 2e 40 00 stb %i3, [ %i1 ]
errno = ERANGE;
201f37c: 40 00 8a 49 call 2041ca0 <__errno>
201f380: b0 10 20 0a mov 0xa, %i0
201f384: 82 10 20 22 mov 0x22, %g1
201f388: c2 22 00 00 st %g1, [ %o0 ]
return RTEMS_INVALID_NUMBER;
201f38c: 81 c7 e0 08 ret
201f390: 81 e8 00 00 restore
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
201f394: b0 10 20 00 clr %i0
}
201f398: 81 c7 e0 08 ret
201f39c: 81 e8 00 00 restore
0200db08 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
200db08: 9d e3 bf 98 save %sp, -104, %sp
200db0c: ba 10 00 18 mov %i0, %i5
unsigned long result;
char *end;
if ( !n )
200db10: 80 a6 60 00 cmp %i1, 0
200db14: 02 80 00 1e be 200db8c <rtems_string_to_unsigned_int+0x84>
200db18: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
errno = 0;
200db1c: 40 00 0b 69 call 20108c0 <__errno>
200db20: 01 00 00 00 nop
200db24: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
200db28: 94 10 00 1b mov %i3, %o2
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
200db2c: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200db30: 90 10 00 1d mov %i5, %o0
200db34: 40 00 18 93 call 2013d80 <strtoul>
200db38: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
200db3c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
200db40: b6 10 00 08 mov %o0, %i3
if ( endptr )
200db44: 02 80 00 03 be 200db50 <rtems_string_to_unsigned_int+0x48>
200db48: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
200db4c: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
200db50: 80 a0 40 1d cmp %g1, %i5
200db54: 02 80 00 0e be 200db8c <rtems_string_to_unsigned_int+0x84>
200db58: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200db5c: 40 00 0b 59 call 20108c0 <__errno>
200db60: 01 00 00 00 nop
200db64: c2 02 00 00 ld [ %o0 ], %g1
200db68: 80 a0 60 22 cmp %g1, 0x22
200db6c: 32 80 00 07 bne,a 200db88 <rtems_string_to_unsigned_int+0x80>
200db70: f6 26 40 00 st %i3, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
200db74: 82 06 ff ff add %i3, -1, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200db78: 80 a0 7f fd cmp %g1, -3
200db7c: 18 80 00 04 bgu 200db8c <rtems_string_to_unsigned_int+0x84><== ALWAYS TAKEN
200db80: b0 10 20 0a mov 0xa, %i0
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
200db84: f6 26 40 00 st %i3, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200db88: b0 10 20 00 clr %i0
}
200db8c: 81 c7 e0 08 ret
200db90: 81 e8 00 00 restore
0201f3a0 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
201f3a0: 9d e3 bf 98 save %sp, -104, %sp
201f3a4: ba 10 00 18 mov %i0, %i5
unsigned long result;
char *end;
if ( !n )
201f3a8: 80 a6 60 00 cmp %i1, 0
201f3ac: 02 80 00 1e be 201f424 <rtems_string_to_unsigned_long+0x84>
201f3b0: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
errno = 0;
201f3b4: 40 00 8a 3b call 2041ca0 <__errno>
201f3b8: 01 00 00 00 nop
201f3bc: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
201f3c0: 94 10 00 1b mov %i3, %o2
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
201f3c4: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
201f3c8: 90 10 00 1d mov %i5, %o0
201f3cc: 40 00 ac ce call 204a704 <strtoul>
201f3d0: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
201f3d4: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
201f3d8: b6 10 00 08 mov %o0, %i3
if ( endptr )
201f3dc: 02 80 00 03 be 201f3e8 <rtems_string_to_unsigned_long+0x48>
201f3e0: c2 07 bf fc ld [ %fp + -4 ], %g1
*endptr = end;
201f3e4: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
201f3e8: 80 a0 40 1d cmp %g1, %i5
201f3ec: 02 80 00 0e be 201f424 <rtems_string_to_unsigned_long+0x84>
201f3f0: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f3f4: 40 00 8a 2b call 2041ca0 <__errno>
201f3f8: 01 00 00 00 nop
201f3fc: c2 02 00 00 ld [ %o0 ], %g1
201f400: 80 a0 60 22 cmp %g1, 0x22
201f404: 32 80 00 07 bne,a 201f420 <rtems_string_to_unsigned_long+0x80>
201f408: f6 26 40 00 st %i3, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
201f40c: 82 06 ff ff add %i3, -1, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f410: 80 a0 7f fd cmp %g1, -3
201f414: 18 80 00 04 bgu 201f424 <rtems_string_to_unsigned_long+0x84><== ALWAYS TAKEN
201f418: b0 10 20 0a mov 0xa, %i0
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
201f41c: f6 26 40 00 st %i3, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
201f420: b0 10 20 00 clr %i0
}
201f424: 81 c7 e0 08 ret
201f428: 81 e8 00 00 restore
0200db94 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
200db94: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
200db98: 80 a6 60 00 cmp %i1, 0
200db9c: 02 80 00 23 be 200dc28 <rtems_string_to_unsigned_long_long+0x94>
200dba0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dba4: 40 00 0b 47 call 20108c0 <__errno>
200dba8: 01 00 00 00 nop
200dbac: c0 22 00 00 clr [ %o0 ]
*n = 0;
200dbb0: c0 26 40 00 clr [ %i1 ]
200dbb4: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
200dbb8: 90 10 00 18 mov %i0, %o0
200dbbc: 92 07 bf fc add %fp, -4, %o1
200dbc0: 40 00 18 79 call 2013da4 <strtoull>
200dbc4: 94 10 00 1b mov %i3, %o2
if ( endptr )
200dbc8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
200dbcc: b8 10 00 08 mov %o0, %i4
200dbd0: ba 10 00 09 mov %o1, %i5
if ( endptr )
200dbd4: 02 80 00 03 be 200dbe0 <rtems_string_to_unsigned_long_long+0x4c>
200dbd8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200dbdc: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200dbe0: 80 a0 80 18 cmp %g2, %i0
200dbe4: 02 80 00 11 be 200dc28 <rtems_string_to_unsigned_long_long+0x94>
200dbe8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dbec: 40 00 0b 35 call 20108c0 <__errno>
200dbf0: 01 00 00 00 nop
200dbf4: c2 02 00 00 ld [ %o0 ], %g1
200dbf8: 80 a0 60 22 cmp %g1, 0x22
200dbfc: 32 80 00 0a bne,a 200dc24 <rtems_string_to_unsigned_long_long+0x90>
200dc00: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
200dc04: 86 87 7f ff addcc %i5, -1, %g3
200dc08: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dc0c: 80 a0 bf ff cmp %g2, -1
200dc10: 12 80 00 04 bne 200dc20 <rtems_string_to_unsigned_long_long+0x8c><== NEVER TAKEN
200dc14: 80 a0 ff fd cmp %g3, -3
200dc18: 18 80 00 04 bgu 200dc28 <rtems_string_to_unsigned_long_long+0x94><== ALWAYS TAKEN
200dc1c: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200dc20: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200dc24: 82 10 20 00 clr %g1
}
200dc28: 81 c7 e0 08 ret
200dc2c: 91 e8 00 01 restore %g0, %g1, %o0
0200301c <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
200301c: 9d e3 bd e0 save %sp, -544, %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 =
2003020: 94 10 20 18 mov 0x18, %o2
2003024: 92 10 00 18 mov %i0, %o1
2003028: 40 00 08 ca call 2005350 <rtems_filesystem_eval_path_start>
200302c: 90 07 bf a8 add %fp, -88, %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(
2003030: 92 07 bf c0 add %fp, -64, %o1
2003034: b8 10 00 08 mov %o0, %i4
2003038: 40 00 09 80 call 2005638 <rtems_filesystem_location_copy_and_detach>
200303c: 90 07 bf e4 add %fp, -28, %o0
static inline void rtems_filesystem_eval_path_set_flags(
rtems_filesystem_eval_path_context_t *ctx,
int flags
)
{
ctx->flags = flags;
2003040: 82 10 20 60 mov 0x60, %g1
2003044: c2 27 bf b8 st %g1, [ %fp + -72 ]
rtems_filesystem_eval_path_extract_currentloc( &ctx, &rootloc );
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (rootloc.ops != &IMFS_ops && rootloc.ops != &fifoIMFS_ops) {
2003048: c2 07 bf f8 ld [ %fp + -8 ], %g1
200304c: 05 00 80 7e sethi %hi(0x201f800), %g2
2003050: 84 10 a3 08 or %g2, 0x308, %g2 ! 201fb08 <IMFS_ops>
2003054: 80 a0 40 02 cmp %g1, %g2
2003058: 02 80 00 07 be 2003074 <rtems_tarfs_load+0x58>
200305c: ba 10 00 18 mov %i0, %i5
2003060: 05 00 80 81 sethi %hi(0x2020400), %g2
2003064: 84 10 a0 78 or %g2, 0x78, %g2 ! 2020478 <fifoIMFS_ops>
2003068: 80 a0 40 02 cmp %g1, %g2
200306c: 12 80 00 66 bne 2003204 <rtems_tarfs_load+0x1e8> <== ALWAYS TAKEN
2003070: 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))
2003074: 27 00 80 7e sethi %hi(0x201f800), %l3
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
2003078: 25 00 80 80 sethi %hi(0x2020000), %l2
* - 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, "/");
200307c: 23 00 80 72 sethi %hi(0x201c800), %l1
rtems_filesystem_eval_path_extract_currentloc( &ctx, &rootloc );
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (rootloc.ops != &IMFS_ops && rootloc.ops != &fifoIMFS_ops) {
2003080: a8 10 20 00 clr %l4
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
2003084: a6 14 e3 90 or %l3, 0x390, %l3
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
2003088: b0 07 bf 40 add %fp, -192, %i0
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
200308c: a4 14 a1 d4 or %l2, 0x1d4, %l2
* - 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, "/");
2003090: a2 14 62 b0 or %l1, 0x2b0, %l1
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
2003094: b6 05 22 00 add %l4, 0x200, %i3
2003098: 80 a6 c0 1a cmp %i3, %i2
200309c: 18 80 00 59 bgu 2003200 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
20030a0: a8 06 40 14 add %i1, %l4, %l4
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
20030a4: 92 10 00 13 mov %l3, %o1
20030a8: 90 05 21 01 add %l4, 0x101, %o0
20030ac: 40 00 44 44 call 20141bc <strncmp>
20030b0: 94 10 20 05 mov 5, %o2
20030b4: 80 a2 20 00 cmp %o0, 0
20030b8: 12 80 00 52 bne 2003200 <rtems_tarfs_load+0x1e4>
20030bc: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
20030c0: 92 10 00 14 mov %l4, %o1
20030c4: 40 00 44 93 call 2014310 <strncpy>
20030c8: 90 10 00 18 mov %i0, %o0
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
20030cc: 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';
20030d0: c0 2f bf a3 clrb [ %fp + -93 ]
linkflag = hdr_ptr[156];
20030d4: ec 0d 20 9c ldub [ %l4 + 0x9c ], %l6
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
20030d8: 40 00 22 3a call 200b9c0 <_rtems_octal2ulong>
20030dc: 90 05 20 64 add %l4, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
20030e0: 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);
20030e4: aa 10 00 08 mov %o0, %l5
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
20030e8: 40 00 22 36 call 200b9c0 <_rtems_octal2ulong>
20030ec: 90 05 20 7c add %l4, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
20030f0: 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);
20030f4: a0 10 00 08 mov %o0, %l0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
20030f8: 40 00 22 32 call 200b9c0 <_rtems_octal2ulong>
20030fc: 90 05 20 94 add %l4, 0x94, %o0
2003100: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
2003104: 40 00 22 42 call 200ba0c <_rtems_tar_header_checksum>
2003108: 90 10 00 14 mov %l4, %o0
200310c: 80 a2 00 17 cmp %o0, %l7
2003110: 12 80 00 3c bne 2003200 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
2003114: ac 0d a0 ff and %l6, 0xff, %l6
* 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) {
2003118: 80 a5 a0 35 cmp %l6, 0x35
200311c: 12 80 00 16 bne 2003174 <rtems_tarfs_load+0x158>
2003120: 80 a5 a0 30 cmp %l6, 0x30
strcpy(full_filename, mountpoint);
2003124: 92 10 00 1d mov %i5, %o1
2003128: 40 00 42 30 call 20139e8 <strcpy>
200312c: 90 07 be 40 add %fp, -448, %o0
if (full_filename[strlen(full_filename)-1] != '/')
2003130: 40 00 43 f2 call 20140f8 <strlen>
2003134: 90 07 be 40 add %fp, -448, %o0
2003138: 90 07 80 08 add %fp, %o0, %o0
200313c: c2 4a 3e 3f ldsb [ %o0 + -449 ], %g1
2003140: 80 a0 60 2f cmp %g1, 0x2f
2003144: 02 80 00 04 be 2003154 <rtems_tarfs_load+0x138> <== ALWAYS TAKEN
2003148: 90 07 be 40 add %fp, -448, %o0
strcat(full_filename, "/");
200314c: 40 00 41 d3 call 2013898 <strcat> <== NOT EXECUTED
2003150: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
strcat(full_filename, filename);
2003154: 92 10 00 18 mov %i0, %o1
2003158: 40 00 41 d0 call 2013898 <strcat>
200315c: 90 07 be 40 add %fp, -448, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
2003160: 90 07 be 40 add %fp, -448, %o0
2003164: 40 00 04 69 call 2004308 <mkdir>
2003168: 92 10 21 ff mov 0x1ff, %o1
rtems_filesystem_eval_path_extract_currentloc( &ctx, &rootloc );
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (rootloc.ops != &IMFS_ops && rootloc.ops != &fifoIMFS_ops) {
200316c: 10 bf ff ca b 2003094 <rtems_tarfs_load+0x78>
2003170: a8 10 00 1b mov %i3, %l4
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
2003174: 12 bf ff c8 bne 2003094 <rtems_tarfs_load+0x78>
2003178: a8 10 00 1b mov %i3, %l4
rtems_filesystem_location_free( currentloc );
200317c: 40 00 02 4b call 2003aa8 <rtems_filesystem_location_free>
2003180: 90 10 00 1c mov %i4, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
2003184: 92 07 bf e4 add %fp, -28, %o1
2003188: 40 00 01 7d call 200377c <rtems_filesystem_location_clone>
200318c: 90 10 00 1c mov %i4, %o0
rtems_filesystem_eval_path_set_path(
2003190: 40 00 43 da call 20140f8 <strlen>
2003194: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
2003198: f0 27 bf a8 st %i0, [ %fp + -88 ]
ctx->pathlen = pathlen;
200319c: d0 27 bf ac st %o0, [ %fp + -84 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
20031a0: 40 00 07 f3 call 200516c <rtems_filesystem_eval_path_continue>
20031a4: 90 07 bf a8 add %fp, -88, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
20031a8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
20031ac: 80 a0 40 12 cmp %g1, %l2
20031b0: 02 80 00 0f be 20031ec <rtems_tarfs_load+0x1d0> <== NEVER TAKEN
20031b4: d4 1f bf b0 ldd [ %fp + -80 ], %o2
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
20031b8: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
20031bc: c2 00 60 20 ld [ %g1 + 0x20 ], %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,
20031c0: 98 0d 61 ff and %l5, 0x1ff, %o4
20031c4: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
20031c8: 03 00 00 20 sethi %hi(0x8000), %g1
20031cc: 90 10 00 1c mov %i4, %o0
20031d0: 98 13 00 01 or %o4, %g1, %o4
20031d4: 40 00 23 a6 call 200c06c <IMFS_create_node_with_control>
20031d8: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
20031dc: 82 06 40 1b add %i1, %i3, %g1
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;
20031e0: c0 22 20 50 clr [ %o0 + 0x50 ]
20031e4: e0 22 20 54 st %l0, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
20031e8: c2 22 20 58 st %g1, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
20031ec: a0 04 21 ff add %l0, 0x1ff, %l0
offset += 512 * nblocks;
20031f0: a0 0c 3e 00 and %l0, -512, %l0
20031f4: b6 04 00 1b add %l0, %i3, %i3
rtems_filesystem_eval_path_extract_currentloc( &ctx, &rootloc );
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (rootloc.ops != &IMFS_ops && rootloc.ops != &fifoIMFS_ops) {
20031f8: 10 bf ff a7 b 2003094 <rtems_tarfs_load+0x78>
20031fc: a8 10 00 1b mov %i3, %l4
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)
2003200: b0 10 20 00 clr %i0
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
2003204: 40 00 02 29 call 2003aa8 <rtems_filesystem_location_free>
2003208: 90 07 bf e4 add %fp, -28, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
200320c: 40 00 08 57 call 2005368 <rtems_filesystem_eval_path_cleanup>
2003210: 90 07 bf a8 add %fp, -88, %o0
return rv;
}
2003214: 81 c7 e0 08 ret
2003218: 81 e8 00 00 restore
0200f2d8 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
200f2d8: 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 )
200f2dc: 80 a6 a0 00 cmp %i2, 0
200f2e0: 02 80 00 5a be 200f448 <rtems_task_mode+0x170>
200f2e4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
200f2e8: 03 00 80 78 sethi %hi(0x201e000), %g1
200f2ec: f8 00 61 5c ld [ %g1 + 0x15c ], %i4 ! 201e15c <_Per_CPU_Information+0xc>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200f2f0: 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 ];
200f2f4: fa 07 21 58 ld [ %i4 + 0x158 ], %i5
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200f2f8: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200f2fc: 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;
200f300: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200f304: 80 a0 60 00 cmp %g1, 0
200f308: 02 80 00 03 be 200f314 <rtems_task_mode+0x3c>
200f30c: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
200f310: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
200f314: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
200f318: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
200f31c: 7f ff f0 56 call 200b474 <_CPU_ISR_Get_level>
200f320: 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;
200f324: a1 2c 20 0a sll %l0, 0xa, %l0
200f328: a0 14 00 08 or %l0, %o0, %l0
old_mode |= _ISR_Get_level();
200f32c: b6 14 00 1b or %l0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
200f330: 80 8e 61 00 btst 0x100, %i1
200f334: 02 80 00 06 be 200f34c <rtems_task_mode+0x74>
200f338: 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;
200f33c: 82 0e 21 00 and %i0, 0x100, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
200f340: 80 a0 00 01 cmp %g0, %g1
200f344: 82 60 3f ff subx %g0, -1, %g1
200f348: c2 2f 20 70 stb %g1, [ %i4 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
200f34c: 80 8e 62 00 btst 0x200, %i1
200f350: 02 80 00 0b be 200f37c <rtems_task_mode+0xa4>
200f354: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
200f358: 80 8e 22 00 btst 0x200, %i0
200f35c: 22 80 00 07 be,a 200f378 <rtems_task_mode+0xa0>
200f360: c0 27 20 78 clr [ %i4 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200f364: 82 10 20 01 mov 1, %g1
200f368: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
200f36c: 03 00 80 76 sethi %hi(0x201d800), %g1
200f370: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 201db74 <_Thread_Ticks_per_timeslice>
200f374: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
200f378: 80 8e 60 0f btst 0xf, %i1
200f37c: 02 80 00 06 be 200f394 <rtems_task_mode+0xbc>
200f380: 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 );
200f384: 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 ) );
200f388: 7f ff cc 9d call 20025fc <sparc_enable_interrupts>
200f38c: 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 ) {
200f390: 80 8e 64 00 btst 0x400, %i1
200f394: 02 80 00 14 be 200f3e4 <rtems_task_mode+0x10c>
200f398: 88 10 20 00 clr %g4
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
200f39c: c4 0f 60 08 ldub [ %i5 + 8 ], %g2
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_asr_disabled (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_ASR_MASK) == RTEMS_NO_ASR;
200f3a0: b0 0e 24 00 and %i0, 0x400, %i0
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
200f3a4: 80 a0 00 18 cmp %g0, %i0
200f3a8: 82 60 3f ff subx %g0, -1, %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;
if ( is_asr_enabled != asr->is_enabled ) {
200f3ac: 80 a0 40 02 cmp %g1, %g2
200f3b0: 22 80 00 0e be,a 200f3e8 <rtems_task_mode+0x110>
200f3b4: 03 00 80 77 sethi %hi(0x201dc00), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
200f3b8: 7f ff cc 8d call 20025ec <sparc_disable_interrupts>
200f3bc: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
_signals = information->signals_pending;
200f3c0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
200f3c4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
information->signals_posted = _signals;
200f3c8: 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;
200f3cc: c4 27 60 18 st %g2, [ %i5 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
200f3d0: 7f ff cc 8b call 20025fc <sparc_enable_interrupts>
200f3d4: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
200f3d8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
200f3dc: 80 a0 00 01 cmp %g0, %g1
200f3e0: 88 40 20 00 addx %g0, 0, %g4
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
200f3e4: 03 00 80 77 sethi %hi(0x201dc00), %g1
200f3e8: c4 00 61 68 ld [ %g1 + 0x168 ], %g2 ! 201dd68 <_System_state_Current>
200f3ec: 80 a0 a0 03 cmp %g2, 3
200f3f0: 12 80 00 16 bne 200f448 <rtems_task_mode+0x170>
200f3f4: 82 10 20 00 clr %g1
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
200f3f8: 07 00 80 78 sethi %hi(0x201e000), %g3
if ( are_signals_pending ||
200f3fc: 80 89 20 ff btst 0xff, %g4
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
200f400: 86 10 e1 50 or %g3, 0x150, %g3
if ( are_signals_pending ||
200f404: 12 80 00 0a bne 200f42c <rtems_task_mode+0x154>
200f408: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
200f40c: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
200f410: 80 a0 80 03 cmp %g2, %g3
200f414: 02 80 00 0d be 200f448 <rtems_task_mode+0x170>
200f418: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
200f41c: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
200f420: 80 a0 a0 00 cmp %g2, 0
200f424: 02 80 00 09 be 200f448 <rtems_task_mode+0x170> <== NEVER TAKEN
200f428: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
200f42c: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
200f430: 03 00 80 78 sethi %hi(0x201e000), %g1
200f434: 82 10 61 50 or %g1, 0x150, %g1 ! 201e150 <_Per_CPU_Information>
200f438: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
200f43c: 7f ff ea fe call 200a034 <_Thread_Dispatch>
200f440: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
200f444: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
200f448: 81 c7 e0 08 ret
200f44c: 91 e8 00 01 restore %g0, %g1, %o0
0200bac4 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
200bac4: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
200bac8: 80 a6 60 00 cmp %i1, 0
200bacc: 02 80 00 07 be 200bae8 <rtems_task_set_priority+0x24>
200bad0: 90 10 00 18 mov %i0, %o0
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 ) );
200bad4: 03 00 80 83 sethi %hi(0x2020c00), %g1
200bad8: c2 08 61 e4 ldub [ %g1 + 0x1e4 ], %g1 ! 2020de4 <rtems_maximum_priority>
200badc: 80 a6 40 01 cmp %i1, %g1
200bae0: 18 80 00 1c bgu 200bb50 <rtems_task_set_priority+0x8c>
200bae4: b0 10 20 13 mov 0x13, %i0
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
200bae8: 80 a6 a0 00 cmp %i2, 0
200baec: 02 80 00 19 be 200bb50 <rtems_task_set_priority+0x8c>
200baf0: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
200baf4: 40 00 09 ad call 200e1a8 <_Thread_Get>
200baf8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200bafc: c2 07 bf fc ld [ %fp + -4 ], %g1
200bb00: 80 a0 60 00 cmp %g1, 0
200bb04: 12 80 00 13 bne 200bb50 <rtems_task_set_priority+0x8c>
200bb08: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
200bb0c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
200bb10: 80 a6 60 00 cmp %i1, 0
200bb14: 02 80 00 0d be 200bb48 <rtems_task_set_priority+0x84>
200bb18: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
200bb1c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200bb20: 80 a0 60 00 cmp %g1, 0
200bb24: 02 80 00 06 be 200bb3c <rtems_task_set_priority+0x78>
200bb28: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
200bb2c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200bb30: 80 a0 40 19 cmp %g1, %i1
200bb34: 08 80 00 05 bleu 200bb48 <rtems_task_set_priority+0x84> <== ALWAYS TAKEN
200bb38: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
200bb3c: 92 10 00 19 mov %i1, %o1
200bb40: 40 00 08 68 call 200dce0 <_Thread_Change_priority>
200bb44: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
200bb48: 40 00 09 8b call 200e174 <_Thread_Enable_dispatch>
200bb4c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200bb50: 81 c7 e0 08 ret
200bb54: 81 e8 00 00 restore
020064d0 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
20064d0: 82 10 00 08 mov %o0, %g1
int baud_index;
switch (termios_baud) {
20064d4: 80 a0 60 09 cmp %g1, 9
20064d8: 02 80 00 17 be 2006534 <rtems_termios_baud_to_index+0x64>
20064dc: 90 10 20 09 mov 9, %o0
20064e0: 80 a0 60 09 cmp %g1, 9
20064e4: 18 80 00 23 bgu 2006570 <rtems_termios_baud_to_index+0xa0>
20064e8: 80 a0 60 0e cmp %g1, 0xe
20064ec: 80 a0 60 04 cmp %g1, 4
20064f0: 02 80 00 11 be 2006534 <rtems_termios_baud_to_index+0x64>
20064f4: 90 10 20 04 mov 4, %o0
20064f8: 80 a0 60 04 cmp %g1, 4
20064fc: 18 80 00 10 bgu 200653c <rtems_termios_baud_to_index+0x6c>
2006500: 80 a0 60 06 cmp %g1, 6
2006504: 80 a0 60 01 cmp %g1, 1
2006508: 02 80 00 0b be 2006534 <rtems_termios_baud_to_index+0x64>
200650c: 90 10 20 01 mov 1, %o0
2006510: 80 a0 60 01 cmp %g1, 1
2006514: 0a 80 00 08 bcs 2006534 <rtems_termios_baud_to_index+0x64>
2006518: 90 10 20 00 clr %o0
200651c: 80 a0 60 02 cmp %g1, 2
2006520: 02 80 00 05 be 2006534 <rtems_termios_baud_to_index+0x64>
2006524: 90 10 20 02 mov 2, %o0
2006528: 80 a0 60 03 cmp %g1, 3
200652c: 12 80 00 3b bne 2006618 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
2006530: 90 10 20 03 mov 3, %o0
2006534: 81 c3 e0 08 retl
2006538: 01 00 00 00 nop
200653c: 02 bf ff fe be 2006534 <rtems_termios_baud_to_index+0x64>
2006540: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6>
2006544: 80 a0 60 06 cmp %g1, 6
2006548: 0a bf ff fb bcs 2006534 <rtems_termios_baud_to_index+0x64>
200654c: 90 10 20 05 mov 5, %o0
2006550: 80 a0 60 07 cmp %g1, 7
2006554: 02 bf ff f8 be 2006534 <rtems_termios_baud_to_index+0x64>
2006558: 90 10 20 07 mov 7, %o0
200655c: 80 a0 60 08 cmp %g1, 8
2006560: 12 80 00 2e bne 2006618 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
2006564: 90 10 20 08 mov 8, %o0
2006568: 81 c3 e0 08 retl
200656c: 01 00 00 00 nop
2006570: 02 bf ff f1 be 2006534 <rtems_termios_baud_to_index+0x64>
2006574: 90 10 20 0e mov 0xe, %o0 ! e <PROM_START+0xe>
2006578: 80 a0 60 0e cmp %g1, 0xe
200657c: 18 80 00 10 bgu 20065bc <rtems_termios_baud_to_index+0xec>
2006580: 05 00 00 04 sethi %hi(0x1000), %g2
2006584: 80 a0 60 0b cmp %g1, 0xb
2006588: 02 bf ff eb be 2006534 <rtems_termios_baud_to_index+0x64>
200658c: 90 10 20 0b mov 0xb, %o0
2006590: 80 a0 60 0b cmp %g1, 0xb
2006594: 0a bf ff e8 bcs 2006534 <rtems_termios_baud_to_index+0x64>
2006598: 90 10 20 0a mov 0xa, %o0
200659c: 80 a0 60 0c cmp %g1, 0xc
20065a0: 02 bf ff e5 be 2006534 <rtems_termios_baud_to_index+0x64>
20065a4: 90 10 20 0c mov 0xc, %o0
20065a8: 80 a0 60 0d cmp %g1, 0xd
20065ac: 12 80 00 1b bne 2006618 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20065b0: 90 10 20 0d mov 0xd, %o0
20065b4: 81 c3 e0 08 retl
20065b8: 01 00 00 00 nop
20065bc: 86 10 a0 02 or %g2, 2, %g3
20065c0: 80 a0 40 03 cmp %g1, %g3
20065c4: 02 bf ff dc be 2006534 <rtems_termios_baud_to_index+0x64>
20065c8: 90 10 20 11 mov 0x11, %o0
20065cc: 80 a0 40 03 cmp %g1, %g3
20065d0: 38 80 00 0b bgu,a 20065fc <rtems_termios_baud_to_index+0x12c>
20065d4: 86 10 a0 03 or %g2, 3, %g3
20065d8: 80 a0 60 0f cmp %g1, 0xf
20065dc: 02 bf ff d6 be 2006534 <rtems_termios_baud_to_index+0x64>
20065e0: 90 10 20 0f mov 0xf, %o0
20065e4: 84 10 a0 01 or %g2, 1, %g2
20065e8: 80 a0 40 02 cmp %g1, %g2
20065ec: 12 80 00 0b bne 2006618 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20065f0: 90 10 20 10 mov 0x10, %o0
20065f4: 81 c3 e0 08 retl
20065f8: 01 00 00 00 nop
20065fc: 80 a0 40 03 cmp %g1, %g3
2006600: 02 bf ff cd be 2006534 <rtems_termios_baud_to_index+0x64>
2006604: 90 10 20 12 mov 0x12, %o0
2006608: 84 10 a0 04 or %g2, 4, %g2
200660c: 80 a0 40 02 cmp %g1, %g2
2006610: 02 bf ff c9 be 2006534 <rtems_termios_baud_to_index+0x64>
2006614: 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;
2006618: 90 10 3f ff mov -1, %o0
}
return baud_index;
}
200661c: 81 c3 e0 08 retl
020057a0 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
20057a0: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20057a4: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
20057a8: 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;
20057ac: fa 00 60 40 ld [ %g1 + 0x40 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
20057b0: 03 00 80 76 sethi %hi(0x201d800), %g1
20057b4: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 201dae0 <rtems_termios_ttyMutex>
20057b8: 40 00 08 30 call 2007878 <rtems_semaphore_obtain>
20057bc: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20057c0: 80 a2 20 00 cmp %o0, 0
20057c4: 12 80 00 32 bne 200588c <rtems_termios_close+0xec> <== NEVER TAKEN
20057c8: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
20057cc: c2 07 60 08 ld [ %i5 + 8 ], %g1
20057d0: 82 00 7f ff add %g1, -1, %g1
20057d4: 80 a0 60 00 cmp %g1, 0
20057d8: 12 80 00 64 bne 2005968 <rtems_termios_close+0x1c8>
20057dc: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
20057e0: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
20057e4: 03 00 80 75 sethi %hi(0x201d400), %g1
20057e8: 85 28 a0 05 sll %g2, 5, %g2
20057ec: 82 10 63 2c or %g1, 0x32c, %g1
20057f0: 82 00 40 02 add %g1, %g2, %g1
20057f4: c2 00 60 04 ld [ %g1 + 4 ], %g1
20057f8: 80 a0 60 00 cmp %g1, 0
20057fc: 22 80 00 06 be,a 2005814 <rtems_termios_close+0x74>
2005800: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
2005804: 9f c0 40 00 call %g1
2005808: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
200580c: 10 80 00 11 b 2005850 <rtems_termios_close+0xb0>
2005810: 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);
2005814: 92 10 20 00 clr %o1
2005818: 40 00 08 18 call 2007878 <rtems_semaphore_obtain>
200581c: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
2005820: 80 a2 20 00 cmp %o0, 0
2005824: 12 80 00 1a bne 200588c <rtems_termios_close+0xec> <== NEVER TAKEN
2005828: 01 00 00 00 nop
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
200582c: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005830: 80 a0 60 00 cmp %g1, 0
2005834: 02 80 00 04 be 2005844 <rtems_termios_close+0xa4>
2005838: 01 00 00 00 nop
200583c: 7f ff fe ad call 20052f0 <drainOutput.part.0>
2005840: 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);
2005844: 40 00 08 57 call 20079a0 <rtems_semaphore_release>
2005848: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
200584c: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005850: 80 a0 60 02 cmp %g1, 2
2005854: 32 80 00 10 bne,a 2005894 <rtems_termios_close+0xf4>
2005858: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
200585c: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
2005860: 40 00 06 d1 call 20073a4 <rtems_event_send>
2005864: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
2005868: 80 a2 20 00 cmp %o0, 0
200586c: 12 80 00 08 bne 200588c <rtems_termios_close+0xec> <== NEVER TAKEN
2005870: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
2005874: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
2005878: 40 00 06 cb call 20073a4 <rtems_event_send>
200587c: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
2005880: 80 a2 20 00 cmp %o0, 0
2005884: 22 80 00 04 be,a 2005894 <rtems_termios_close+0xf4> <== ALWAYS TAKEN
2005888: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
200588c: 40 00 09 bf call 2007f88 <rtems_fatal_error_occurred> <== NOT EXECUTED
2005890: 01 00 00 00 nop <== NOT EXECUTED
}
if (tty->device.lastClose)
2005894: 80 a0 60 00 cmp %g1, 0
2005898: 22 80 00 07 be,a 20058b4 <rtems_termios_close+0x114> <== ALWAYS TAKEN
200589c: c4 07 40 00 ld [ %i5 ], %g2
(*tty->device.lastClose)(tty->major, tty->minor, arg);
20058a0: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
20058a4: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
20058a8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20058ac: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
20058b0: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
20058b4: 80 a0 a0 00 cmp %g2, 0
20058b8: 12 80 00 08 bne 20058d8 <rtems_termios_close+0x138>
20058bc: c2 07 60 04 ld [ %i5 + 4 ], %g1
rtems_termios_ttyTail = tty->back;
20058c0: 05 00 80 76 sethi %hi(0x201d800), %g2
if ( rtems_termios_ttyTail != NULL ) {
20058c4: 80 a0 60 00 cmp %g1, 0
20058c8: 02 80 00 05 be 20058dc <rtems_termios_close+0x13c> <== ALWAYS TAKEN
20058cc: c2 20 a2 e4 st %g1, [ %g2 + 0x2e4 ]
rtems_termios_ttyTail->forw = NULL;
20058d0: 10 80 00 03 b 20058dc <rtems_termios_close+0x13c> <== NOT EXECUTED
20058d4: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
20058d8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
}
if (tty->back == NULL) {
20058dc: c4 07 60 04 ld [ %i5 + 4 ], %g2
20058e0: 80 a0 a0 00 cmp %g2, 0
20058e4: 12 80 00 08 bne 2005904 <rtems_termios_close+0x164> <== NEVER TAKEN
20058e8: c2 07 40 00 ld [ %i5 ], %g1
rtems_termios_ttyHead = tty->forw;
20058ec: 05 00 80 76 sethi %hi(0x201d800), %g2
if ( rtems_termios_ttyHead != NULL ) {
20058f0: 80 a0 60 00 cmp %g1, 0
20058f4: 02 80 00 05 be 2005908 <rtems_termios_close+0x168>
20058f8: c2 20 a2 e8 st %g1, [ %g2 + 0x2e8 ]
rtems_termios_ttyHead->back = NULL;
20058fc: 10 80 00 03 b 2005908 <rtems_termios_close+0x168>
2005900: c0 20 60 04 clr [ %g1 + 4 ]
}
} else {
tty->back->forw = tty->forw;
2005904: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
2005908: 40 00 07 ad call 20077bc <rtems_semaphore_delete>
200590c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
2005910: 40 00 07 ab call 20077bc <rtems_semaphore_delete>
2005914: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
2005918: 40 00 07 a9 call 20077bc <rtems_semaphore_delete>
200591c: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
2005920: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2005924: 80 a0 60 00 cmp %g1, 0
2005928: 02 80 00 06 be 2005940 <rtems_termios_close+0x1a0>
200592c: 01 00 00 00 nop
2005930: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005934: 80 a0 60 02 cmp %g1, 2
2005938: 12 80 00 04 bne 2005948 <rtems_termios_close+0x1a8>
200593c: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
2005940: 40 00 07 9f call 20077bc <rtems_semaphore_delete>
2005944: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free (tty->rawInBuf.theBuf);
2005948: 7f ff f7 72 call 2003710 <free>
200594c: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
2005950: 7f ff f7 70 call 2003710 <free>
2005954: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
2005958: 7f ff f7 6e call 2003710 <free>
200595c: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
2005960: 7f ff f7 6c call 2003710 <free>
2005964: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2005968: 03 00 80 76 sethi %hi(0x201d800), %g1
200596c: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 201dae0 <rtems_termios_ttyMutex>
2005970: 40 00 08 0c call 20079a0 <rtems_semaphore_release>
2005974: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
2005978: 81 c7 e0 08 ret
200597c: 81 e8 00 00 restore
02006cd4 <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)
{
2006cd4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2006cd8: c2 06 20 90 ld [ %i0 + 0x90 ], %g1
2006cdc: 82 00 40 19 add %g1, %i1, %g1
2006ce0: c2 26 20 90 st %g1, [ %i0 + 0x90 ]
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2006ce4: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
2006ce8: 80 a0 60 02 cmp %g1, 2
2006cec: 12 80 00 0a bne 2006d14 <rtems_termios_dequeue_characters+0x40>
2006cf0: 90 10 00 18 mov %i0, %o0
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
2006cf4: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
2006cf8: 40 00 01 ab call 20073a4 <rtems_event_send>
2006cfc: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
2006d00: 80 a2 20 00 cmp %o0, 0
2006d04: 02 80 00 11 be 2006d48 <rtems_termios_dequeue_characters+0x74><== ALWAYS TAKEN
2006d08: b0 10 20 00 clr %i0
rtems_fatal_error_occurred (sc);
2006d0c: 40 00 04 9f call 2007f88 <rtems_fatal_error_occurred> <== NOT EXECUTED
2006d10: 01 00 00 00 nop <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
2006d14: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
2006d18: 80 a0 60 05 cmp %g1, 5
2006d1c: 12 80 00 09 bne 2006d40 <rtems_termios_dequeue_characters+0x6c>
2006d20: 03 00 80 75 sethi %hi(0x201d400), %g1
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2006d24: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 201d7e0 <rtems_termios_linesw+0xb4>
2006d28: 80 a0 60 00 cmp %g1, 0
2006d2c: 02 80 00 07 be 2006d48 <rtems_termios_dequeue_characters+0x74><== NEVER TAKEN
2006d30: b0 10 20 00 clr %i0
rtems_termios_linesw[tty->t_line].l_start(tty);
2006d34: 9f c0 40 00 call %g1
2006d38: 01 00 00 00 nop
2006d3c: 30 80 00 03 b,a 2006d48 <rtems_termios_dequeue_characters+0x74>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
2006d40: 7f ff f8 d7 call 200509c <rtems_termios_refill_transmitter>
2006d44: 81 e8 00 00 restore
}
2006d48: 81 c7 e0 08 ret
2006d4c: 81 e8 00 00 restore
02006980 <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)
{
2006980: 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) {
2006984: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
2006988: 37 00 80 75 sethi %hi(0x201d400), %i3
200698c: 83 28 60 05 sll %g1, 5, %g1
2006990: b6 16 e3 2c or %i3, 0x32c, %i3
2006994: 82 06 c0 01 add %i3, %g1, %g1
2006998: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
* 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)
{
200699c: ba 10 00 18 mov %i0, %i5
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) {
20069a0: 80 a0 60 00 cmp %g1, 0
20069a4: 12 80 00 0e bne 20069dc <rtems_termios_enqueue_raw_characters+0x5c>
20069a8: b8 10 20 00 clr %i4
* 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)
20069ac: a0 10 20 00 clr %l0
20069b0: 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);
20069b4: a6 07 60 30 add %i5, 0x30, %l3
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
20069b8: 10 80 00 a3 b 2006c44 <rtems_termios_enqueue_raw_characters+0x2c4>
20069bc: a4 07 60 4a add %i5, 0x4a, %l2
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);
20069c0: d0 4e 40 1c ldsb [ %i1 + %i4 ], %o0
20069c4: 83 28 60 05 sll %g1, 5, %g1
20069c8: 82 06 c0 01 add %i3, %g1, %g1
20069cc: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
20069d0: 92 10 00 1d mov %i5, %o1
20069d4: 9f c0 40 00 call %g1
20069d8: b8 07 20 01 inc %i4
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--) {
20069dc: 80 a7 00 1a cmp %i4, %i2
20069e0: 32 bf ff f8 bne,a 20069c0 <rtems_termios_enqueue_raw_characters+0x40>
20069e4: 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 )) {
20069e8: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
20069ec: 80 a0 60 00 cmp %g1, 0
20069f0: 12 80 00 0b bne 2006a1c <rtems_termios_enqueue_raw_characters+0x9c><== NEVER TAKEN
20069f4: b0 10 20 00 clr %i0
20069f8: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
20069fc: 80 a0 60 00 cmp %g1, 0
2006a00: 02 80 00 99 be 2006c64 <rtems_termios_enqueue_raw_characters+0x2e4>
2006a04: 01 00 00 00 nop
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2006a08: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1
2006a0c: 9f c0 40 00 call %g1
2006a10: 90 07 60 30 add %i5, 0x30, %o0
tty->tty_rcvwakeup = 1;
2006a14: 82 10 20 01 mov 1, %g1
2006a18: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ]
2006a1c: 81 c7 e0 08 ret
2006a20: 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) {
2006a24: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006a28: 80 88 62 00 btst 0x200, %g1
2006a2c: 02 80 00 17 be 2006a88 <rtems_termios_enqueue_raw_characters+0x108>
2006a30: e2 0e 40 1c ldub [ %i1 + %i4 ], %l1
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
2006a34: c4 0f 60 4a ldub [ %i5 + 0x4a ], %g2
2006a38: 83 2c 60 18 sll %l1, 0x18, %g1
2006a3c: 83 38 60 18 sra %g1, 0x18, %g1
2006a40: 80 a0 40 02 cmp %g1, %g2
2006a44: c4 0f 60 49 ldub [ %i5 + 0x49 ], %g2
2006a48: 12 80 00 0a bne 2006a70 <rtems_termios_enqueue_raw_characters+0xf0>
2006a4c: 84 08 a0 ff and %g2, 0xff, %g2
if (c == tty->termios.c_cc[VSTART]) {
2006a50: 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;
2006a54: 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]) {
2006a58: 32 80 00 03 bne,a 2006a64 <rtems_termios_enqueue_raw_characters+0xe4><== ALWAYS TAKEN
2006a5c: 82 10 60 10 or %g1, 0x10, %g1
2006a60: 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;
2006a64: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
* 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)
2006a68: 10 80 00 0b b 2006a94 <rtems_termios_enqueue_raw_characters+0x114>
2006a6c: a0 10 20 01 mov 1, %l0
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
2006a70: 80 a0 40 02 cmp %g1, %g2
2006a74: 12 80 00 06 bne 2006a8c <rtems_termios_enqueue_raw_characters+0x10c><== ALWAYS TAKEN
2006a78: 80 8c 20 ff btst 0xff, %l0
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
2006a7c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006a80: 10 bf ff f9 b 2006a64 <rtems_termios_enqueue_raw_characters+0xe4><== NOT EXECUTED
2006a84: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
2006a88: 80 8c 20 ff btst 0xff, %l0
2006a8c: 02 80 00 1c be 2006afc <rtems_termios_enqueue_raw_characters+0x17c><== ALWAYS TAKEN
2006a90: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
2006a94: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006a98: 82 08 60 30 and %g1, 0x30, %g1
2006a9c: 80 a0 60 20 cmp %g1, 0x20
2006aa0: 32 80 00 69 bne,a 2006c44 <rtems_termios_enqueue_raw_characters+0x2c4><== ALWAYS TAKEN
2006aa4: b8 07 20 01 inc %i4
/* disable interrupts */
rtems_interrupt_disable(level);
2006aa8: 7f ff ee d1 call 20025ec <sparc_disable_interrupts> <== NOT EXECUTED
2006aac: 01 00 00 00 nop <== NOT EXECUTED
2006ab0: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2006ab4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006ab8: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
2006abc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2006ac0: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2006ac4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006ac8: 02 80 00 09 be 2006aec <rtems_termios_enqueue_raw_characters+0x16c><== NOT EXECUTED
2006acc: 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);
2006ad0: 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)(
2006ad4: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
2006ad8: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2006adc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2006ae0: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
2006ae4: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006ae8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2006aec: 7f ff ee c4 call 20025fc <sparc_enable_interrupts> <== NOT EXECUTED
2006af0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
2006af4: 10 80 00 54 b 2006c44 <rtems_termios_enqueue_raw_characters+0x2c4><== NOT EXECUTED
2006af8: b8 07 20 01 inc %i4 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
2006afc: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
2006b00: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
2006b04: 40 00 47 f0 call 2018ac4 <.urem>
2006b08: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
2006b0c: 7f ff ee b8 call 20025ec <sparc_disable_interrupts>
2006b10: b6 10 00 08 mov %o0, %i3
2006b14: a8 10 00 08 mov %o0, %l4
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
2006b18: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
2006b1c: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
2006b20: 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)
2006b24: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
2006b28: 40 00 47 e7 call 2018ac4 <.urem>
2006b2c: 90 02 00 1b add %o0, %i3, %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)
2006b30: c2 07 60 c0 ld [ %i5 + 0xc0 ], %g1
2006b34: 80 a2 00 01 cmp %o0, %g1
2006b38: 08 80 00 2b bleu 2006be4 <rtems_termios_enqueue_raw_characters+0x264><== ALWAYS TAKEN
2006b3c: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
2006b40: 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) &&
2006b44: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2006b48: 12 80 00 27 bne 2006be4 <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
2006b4c: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
2006b50: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006b54: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
2006b58: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
2006b5c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006b60: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
2006b64: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006b68: 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))
2006b6c: 32 80 00 12 bne,a 2006bb4 <rtems_termios_enqueue_raw_characters+0x234><== NOT EXECUTED
2006b70: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006b74: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006b78: 12 80 00 06 bne 2006b90 <rtems_termios_enqueue_raw_characters+0x210><== NOT EXECUTED
2006b7c: 01 00 00 00 nop <== NOT EXECUTED
2006b80: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2006b84: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006b88: 12 80 00 17 bne 2006be4 <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
2006b8c: 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;
2006b90: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006b94: 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;
2006b98: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
2006b9c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006ba0: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2006ba4: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
2006ba8: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006bac: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2006bb0: 30 80 00 0d b,a 2006be4 <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
2006bb4: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
2006bb8: 12 80 00 0b bne 2006be4 <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
2006bbc: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
2006bc0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006bc4: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED
2006bc8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
2006bcc: c2 07 60 ac ld [ %i5 + 0xac ], %g1 <== NOT EXECUTED
2006bd0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006bd4: 02 80 00 04 be 2006be4 <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
2006bd8: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
2006bdc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006be0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2006be4: 7f ff ee 86 call 20025fc <sparc_enable_interrupts>
2006be8: 90 10 00 14 mov %l4, %o0
if (newTail == tty->rawInBuf.Head) {
2006bec: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
2006bf0: 80 a6 c0 01 cmp %i3, %g1
2006bf4: 32 80 00 04 bne,a 2006c04 <rtems_termios_enqueue_raw_characters+0x284><== ALWAYS TAKEN
2006bf8: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
dropped++;
2006bfc: 10 80 00 11 b 2006c40 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
2006c00: b0 06 20 01 inc %i0 <== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
2006c04: e2 28 40 1b stb %l1, [ %g1 + %i3 ]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006c08: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
2006c0c: f6 27 60 60 st %i3, [ %i5 + 0x60 ]
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006c10: 80 a0 60 00 cmp %g1, 0
2006c14: 32 80 00 0c bne,a 2006c44 <rtems_termios_enqueue_raw_characters+0x2c4><== NEVER TAKEN
2006c18: b8 07 20 01 inc %i4 <== NOT EXECUTED
2006c1c: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
2006c20: 80 a0 60 00 cmp %g1, 0
2006c24: 22 80 00 08 be,a 2006c44 <rtems_termios_enqueue_raw_characters+0x2c4><== ALWAYS TAKEN
2006c28: b8 07 20 01 inc %i4
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2006c2c: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1 <== NOT EXECUTED
2006c30: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006c34: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
2006c38: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2006c3c: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ] <== NOT EXECUTED
2006c40: b8 07 20 01 inc %i4 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2006c44: 80 a7 00 1a cmp %i4, %i2
2006c48: 12 bf ff 77 bne 2006a24 <rtems_termios_enqueue_raw_characters+0xa4>
2006c4c: 01 00 00 00 nop
}
}
}
}
tty->rawInBufDropped += dropped;
2006c50: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006c54: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
2006c58: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006c5c: 40 00 03 51 call 20079a0 <rtems_semaphore_release>
2006c60: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
return dropped;
}
2006c64: 81 c7 e0 08 ret
2006c68: 81 e8 00 00 restore
020059a0 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
20059a0: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20059a4: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
20059a8: 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;
20059ac: fa 00 60 40 ld [ %g1 + 0x40 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
20059b0: 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);
20059b4: 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;
20059b8: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20059bc: 92 10 20 00 clr %o1
20059c0: 40 00 07 ae call 2007878 <rtems_semaphore_obtain>
20059c4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
20059c8: b0 92 20 00 orcc %o0, 0, %i0
20059cc: 12 80 00 f3 bne 2005d98 <rtems_termios_ioctl+0x3f8> <== NEVER TAKEN
20059d0: 01 00 00 00 nop
return sc;
}
switch (args->command) {
20059d4: c2 07 20 04 ld [ %i4 + 4 ], %g1
20059d8: 80 a0 60 04 cmp %g1, 4
20059dc: 22 80 00 c1 be,a 2005ce0 <rtems_termios_ioctl+0x340>
20059e0: c2 06 c0 00 ld [ %i3 ], %g1
20059e4: 18 80 00 0c bgu 2005a14 <rtems_termios_ioctl+0x74>
20059e8: 05 10 01 19 sethi %hi(0x40046400), %g2
20059ec: 80 a0 60 02 cmp %g1, 2
20059f0: 22 80 00 2e be,a 2005aa8 <rtems_termios_ioctl+0x108>
20059f4: d2 07 20 08 ld [ %i4 + 8 ], %o1
20059f8: 38 80 00 b0 bgu,a 2005cb8 <rtems_termios_ioctl+0x318>
20059fc: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005a00: 80 a0 60 01 cmp %g1, 1
2005a04: 32 80 00 18 bne,a 2005a64 <rtems_termios_ioctl+0xc4> <== NEVER TAKEN
2005a08: 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;
2005a0c: 10 80 00 23 b 2005a98 <rtems_termios_ioctl+0xf8>
2005a10: 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) {
2005a14: 84 10 a2 7f or %g2, 0x27f, %g2
2005a18: 80 a0 40 02 cmp %g1, %g2
2005a1c: 02 80 00 d0 be 2005d5c <rtems_termios_ioctl+0x3bc> <== NEVER TAKEN
2005a20: 01 00 00 00 nop
2005a24: 18 80 00 07 bgu 2005a40 <rtems_termios_ioctl+0xa0>
2005a28: 05 10 01 1d sethi %hi(0x40047400), %g2
2005a2c: 80 a0 60 05 cmp %g1, 5
2005a30: 32 80 00 0d bne,a 2005a64 <rtems_termios_ioctl+0xc4>
2005a34: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
2005a38: 10 80 00 a6 b 2005cd0 <rtems_termios_ioctl+0x330>
2005a3c: 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) {
2005a40: 84 10 a0 1a or %g2, 0x1a, %g2
2005a44: 80 a0 40 02 cmp %g1, %g2
2005a48: 02 80 00 c2 be 2005d50 <rtems_termios_ioctl+0x3b0>
2005a4c: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
2005a50: 07 20 01 1d sethi %hi(0x80047400), %g3
2005a54: 86 10 e0 1b or %g3, 0x1b, %g3 ! 8004741b <RAM_END+0x7dc4741b>
2005a58: 80 a0 40 03 cmp %g1, %g3
2005a5c: 02 80 00 a5 be 2005cf0 <rtems_termios_ioctl+0x350> <== ALWAYS TAKEN
2005a60: 03 00 80 75 sethi %hi(0x201d400), %g1
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
2005a64: 03 00 80 75 sethi %hi(0x201d400), %g1
2005a68: 85 28 a0 05 sll %g2, 5, %g2
2005a6c: 82 10 63 2c or %g1, 0x32c, %g1
2005a70: 82 00 40 02 add %g1, %g2, %g1
2005a74: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
2005a78: 80 a0 60 00 cmp %g1, 0
2005a7c: 02 80 00 c5 be 2005d90 <rtems_termios_ioctl+0x3f0>
2005a80: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
2005a84: 90 10 00 1d mov %i5, %o0
2005a88: 9f c0 40 00 call %g1
2005a8c: 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);
2005a90: 10 80 00 c0 b 2005d90 <rtems_termios_ioctl+0x3f0>
2005a94: b0 10 00 08 mov %o0, %i0
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
2005a98: 92 07 60 30 add %i5, 0x30, %o1
2005a9c: 40 00 29 d2 call 20101e4 <memcpy>
2005aa0: 94 10 20 24 mov 0x24, %o2
break;
2005aa4: 30 80 00 bb b,a 2005d90 <rtems_termios_ioctl+0x3f0>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
2005aa8: 90 07 60 30 add %i5, 0x30, %o0
2005aac: 40 00 29 ce call 20101e4 <memcpy>
2005ab0: 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) &&
2005ab4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005ab8: 80 88 62 00 btst 0x200, %g1
2005abc: 02 80 00 20 be 2005b3c <rtems_termios_ioctl+0x19c>
2005ac0: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
2005ac4: 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) &&
2005ac8: 80 88 64 00 btst 0x400, %g1
2005acc: 12 80 00 1c bne 2005b3c <rtems_termios_ioctl+0x19c>
2005ad0: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
2005ad4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005ad8: 82 08 7d ef and %g1, -529, %g1
2005adc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
2005ae0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005ae4: 80 88 60 20 btst 0x20, %g1
2005ae8: 02 80 00 15 be 2005b3c <rtems_termios_ioctl+0x19c> <== ALWAYS TAKEN
2005aec: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
2005af0: 7f ff f2 bf call 20025ec <sparc_disable_interrupts> <== NOT EXECUTED
2005af4: 01 00 00 00 nop <== NOT EXECUTED
2005af8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2005afc: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005b00: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
2005b04: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2005b08: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2005b0c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005b10: 02 80 00 09 be 2005b34 <rtems_termios_ioctl+0x194> <== NOT EXECUTED
2005b14: 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);
2005b18: 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)(
2005b1c: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
2005b20: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2005b24: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2005b28: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
2005b2c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005b30: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2005b34: 7f ff f2 b2 call 20025fc <sparc_enable_interrupts> <== NOT EXECUTED
2005b38: 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)) {
2005b3c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b40: 80 88 64 00 btst 0x400, %g1
2005b44: 02 80 00 0c be 2005b74 <rtems_termios_ioctl+0x1d4>
2005b48: 03 00 00 04 sethi %hi(0x1000), %g1
2005b4c: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
2005b50: 80 88 80 01 btst %g2, %g1
2005b54: 12 80 00 08 bne 2005b74 <rtems_termios_ioctl+0x1d4> <== NEVER TAKEN
2005b58: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
2005b5c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b60: 82 08 7b ff and %g1, -1025, %g1
2005b64: 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);
2005b68: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b6c: 82 08 7f fd and %g1, -3, %g1
2005b70: 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)) {
2005b74: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b78: 80 88 61 00 btst 0x100, %g1
2005b7c: 02 80 00 16 be 2005bd4 <rtems_termios_ioctl+0x234> <== ALWAYS TAKEN
2005b80: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
2005b84: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005b88: 06 80 00 14 bl 2005bd8 <rtems_termios_ioctl+0x238> <== NOT EXECUTED
2005b8c: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
2005b90: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005b94: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED
2005b98: 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)) {
2005b9c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005ba0: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
2005ba4: 02 80 00 08 be 2005bc4 <rtems_termios_ioctl+0x224> <== NOT EXECUTED
2005ba8: 01 00 00 00 nop <== NOT EXECUTED
2005bac: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
2005bb0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005bb4: 02 80 00 04 be 2005bc4 <rtems_termios_ioctl+0x224> <== NOT EXECUTED
2005bb8: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
2005bbc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005bc0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
2005bc4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005bc8: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
2005bcc: 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) {
2005bd0: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
2005bd4: 80 a0 60 00 cmp %g1, 0
2005bd8: 36 80 00 06 bge,a 2005bf0 <rtems_termios_ioctl+0x250> <== ALWAYS TAKEN
2005bdc: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
tty->flow_ctrl |= FL_MDRTS;
2005be0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005be4: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
2005be8: 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) {
2005bec: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2005bf0: 05 00 00 04 sethi %hi(0x1000), %g2
2005bf4: 80 88 40 02 btst %g1, %g2
2005bf8: 02 80 00 06 be 2005c10 <rtems_termios_ioctl+0x270>
2005bfc: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
2005c00: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
2005c04: 84 10 a4 00 or %g2, 0x400, %g2
2005c08: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
2005c0c: 80 88 64 00 btst 0x400, %g1
2005c10: 22 80 00 06 be,a 2005c28 <rtems_termios_ioctl+0x288>
2005c14: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
2005c18: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005c1c: 82 10 62 00 or %g1, 0x200, %g1
2005c20: 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) {
2005c24: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2005c28: 80 88 60 02 btst 2, %g1
2005c2c: 32 80 00 17 bne,a 2005c88 <rtems_termios_ioctl+0x2e8>
2005c30: 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;
2005c34: 40 00 05 4c call 2007164 <rtems_clock_get_ticks_per_second>
2005c38: 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] *
2005c3c: 40 00 4a bc call 201872c <.umul>
2005c40: 92 10 00 1c mov %i4, %o1
rtems_clock_get_ticks_per_second() / 10;
2005c44: 40 00 4a f4 call 2018814 <.udiv>
2005c48: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
2005c4c: 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] *
2005c50: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
2005c54: 80 a0 60 00 cmp %g1, 0
2005c58: 02 80 00 08 be 2005c78 <rtems_termios_ioctl+0x2d8>
2005c5c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005c60: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
2005c64: 80 88 60 ff btst 0xff, %g1
2005c68: 12 80 00 09 bne 2005c8c <rtems_termios_ioctl+0x2ec>
2005c6c: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
2005c70: 10 80 00 0a b 2005c98 <rtems_termios_ioctl+0x2f8>
2005c74: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
} else {
if (tty->termios.c_cc[VMIN]) {
2005c78: 80 88 60 ff btst 0xff, %g1
2005c7c: 02 80 00 06 be 2005c94 <rtems_termios_ioctl+0x2f4> <== ALWAYS TAKEN
2005c80: 82 10 20 01 mov 1, %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005c84: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
2005c88: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
2005c8c: 10 80 00 03 b 2005c98 <rtems_termios_ioctl+0x2f8>
2005c90: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
2005c94: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
}
}
}
if (tty->device.setAttributes)
2005c98: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
2005c9c: 80 a0 60 00 cmp %g1, 0
2005ca0: 02 80 00 3c be 2005d90 <rtems_termios_ioctl+0x3f0>
2005ca4: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
2005ca8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2005cac: 9f c0 40 00 call %g1
2005cb0: 92 07 60 30 add %i5, 0x30, %o1
2005cb4: 30 80 00 37 b,a 2005d90 <rtems_termios_ioctl+0x3f0>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
2005cb8: 80 a0 60 00 cmp %g1, 0
2005cbc: 02 80 00 35 be 2005d90 <rtems_termios_ioctl+0x3f0> <== ALWAYS TAKEN
2005cc0: 01 00 00 00 nop
2005cc4: 7f ff fd 8b call 20052f0 <drainOutput.part.0> <== NOT EXECUTED
2005cc8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2005ccc: 30 80 00 31 b,a 2005d90 <rtems_termios_ioctl+0x3f0> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
2005cd0: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
2005cd4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
2005cd8: 10 80 00 2e b 2005d90 <rtems_termios_ioctl+0x3f0>
2005cdc: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
2005ce0: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
2005ce4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
2005ce8: 10 80 00 2a b 2005d90 <rtems_termios_ioctl+0x3f0>
2005cec: 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) {
2005cf0: 82 10 63 2c or %g1, 0x32c, %g1
2005cf4: 85 28 a0 05 sll %g2, 5, %g2
2005cf8: 84 00 40 02 add %g1, %g2, %g2
2005cfc: c2 00 a0 04 ld [ %g2 + 4 ], %g1
2005d00: 80 a0 60 00 cmp %g1, 0
2005d04: 22 80 00 06 be,a 2005d1c <rtems_termios_ioctl+0x37c>
2005d08: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
2005d0c: 9f c0 40 00 call %g1
2005d10: 90 10 00 1d mov %i5, %o0
2005d14: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
2005d18: 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) {
2005d1c: 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);
2005d20: 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) {
2005d24: 84 10 a3 2c or %g2, 0x32c, %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);
2005d28: 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) {
2005d2c: 83 28 60 05 sll %g1, 5, %g1
2005d30: c2 00 80 01 ld [ %g2 + %g1 ], %g1
2005d34: 80 a0 60 00 cmp %g1, 0
2005d38: 02 80 00 16 be 2005d90 <rtems_termios_ioctl+0x3f0>
2005d3c: c0 27 60 d0 clr [ %i5 + 0xd0 ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
2005d40: 9f c0 40 00 call %g1
2005d44: 90 10 00 1d mov %i5, %o0
2005d48: 10 80 00 12 b 2005d90 <rtems_termios_ioctl+0x3f0>
2005d4c: b0 10 00 08 mov %o0, %i0
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
2005d50: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
2005d54: 10 80 00 0f b 2005d90 <rtems_termios_ioctl+0x3f0>
2005d58: c4 20 40 00 st %g2, [ %g1 ]
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
2005d5c: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
2005d60: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
2005d64: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
2005d68: 3c 80 00 05 bpos,a 2005d7c <rtems_termios_ioctl+0x3dc> <== NOT EXECUTED
2005d6c: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
2005d70: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
2005d74: 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;
2005d78: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
2005d7c: c6 07 60 24 ld [ %i5 + 0x24 ], %g3 <== NOT EXECUTED
2005d80: c4 07 20 08 ld [ %i4 + 8 ], %g2 <== NOT EXECUTED
2005d84: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
2005d88: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
2005d8c: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
2005d90: 40 00 07 04 call 20079a0 <rtems_semaphore_release>
2005d94: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
2005d98: 81 c7 e0 08 ret
2005d9c: 81 e8 00 00 restore
02005354 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
2005354: 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(
2005358: 03 00 80 76 sethi %hi(0x201d800), %g1
200535c: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 201dae0 <rtems_termios_ttyMutex>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
2005360: ba 10 00 18 mov %i0, %i5
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
2005364: 92 10 20 00 clr %o1
2005368: 40 00 09 44 call 2007878 <rtems_semaphore_obtain>
200536c: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005370: b0 92 20 00 orcc %o0, 0, %i0
2005374: 12 80 00 35 bne 2005448 <rtems_termios_open+0xf4> <== NEVER TAKEN
2005378: 03 00 80 76 sethi %hi(0x201d800), %g1
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
200537c: e0 00 62 e8 ld [ %g1 + 0x2e8 ], %l0 ! 201dae8 <rtems_termios_ttyHead>
2005380: 10 80 00 0a b 20053a8 <rtems_termios_open+0x54>
2005384: b8 10 00 10 mov %l0, %i4
if ((tty->major == major) && (tty->minor == minor))
2005388: 80 a0 40 1d cmp %g1, %i5
200538c: 32 80 00 07 bne,a 20053a8 <rtems_termios_open+0x54>
2005390: f8 07 00 00 ld [ %i4 ], %i4
2005394: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
2005398: 80 a0 40 19 cmp %g1, %i1
200539c: 22 80 00 d2 be,a 20056e4 <rtems_termios_open+0x390> <== ALWAYS TAKEN
20053a0: 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) {
20053a4: f8 07 00 00 ld [ %i4 ], %i4 <== NOT EXECUTED
20053a8: 80 a7 20 00 cmp %i4, 0
20053ac: 32 bf ff f7 bne,a 2005388 <rtems_termios_open+0x34>
20053b0: c2 07 20 0c ld [ %i4 + 0xc ], %g1
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
20053b4: 10 80 00 f4 b 2005784 <rtems_termios_open+0x430>
20053b8: 90 10 20 01 mov 1, %o0
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
20053bc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20053c0: c2 27 20 64 st %g1, [ %i4 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
20053c4: d0 07 20 64 ld [ %i4 + 0x64 ], %o0
20053c8: 7f ff f9 ba call 2003ab0 <malloc>
20053cc: 01 00 00 00 nop
20053d0: d0 27 20 58 st %o0, [ %i4 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
20053d4: 80 a2 20 00 cmp %o0, 0
20053d8: 02 80 00 16 be 2005430 <rtems_termios_open+0xdc>
20053dc: a2 10 00 08 mov %o0, %l1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
20053e0: 03 00 80 74 sethi %hi(0x201d000), %g1
20053e4: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 201d038 <rtems_termios_raw_output_size>
20053e8: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
20053ec: d0 07 20 88 ld [ %i4 + 0x88 ], %o0
20053f0: 7f ff f9 b0 call 2003ab0 <malloc>
20053f4: 01 00 00 00 nop
20053f8: d0 27 20 7c st %o0, [ %i4 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
20053fc: 80 a2 20 00 cmp %o0, 0
2005400: 02 80 00 0a be 2005428 <rtems_termios_open+0xd4>
2005404: a4 10 00 08 mov %o0, %l2
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
2005408: 03 00 80 74 sethi %hi(0x201d000), %g1
200540c: 7f ff f9 a9 call 2003ab0 <malloc>
2005410: d0 00 60 3c ld [ %g1 + 0x3c ], %o0 ! 201d03c <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
2005414: 80 a2 20 00 cmp %o0, 0
2005418: 12 80 00 0e bne 2005450 <rtems_termios_open+0xfc> <== ALWAYS TAKEN
200541c: d0 27 20 1c st %o0, [ %i4 + 0x1c ]
free((void *)(tty->rawOutBuf.theBuf));
2005420: 7f ff f8 bc call 2003710 <free> <== NOT EXECUTED
2005424: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
2005428: 7f ff f8 ba call 2003710 <free>
200542c: 90 10 00 11 mov %l1, %o0
free(tty);
2005430: 7f ff f8 b8 call 2003710 <free>
2005434: 90 10 00 1c mov %i4, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
2005438: 03 00 80 76 sethi %hi(0x201d800), %g1
200543c: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 201dae0 <rtems_termios_ttyMutex>
2005440: 40 00 09 58 call 20079a0 <rtems_semaphore_release>
2005444: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
2005448: 81 c7 e0 08 ret
200544c: 81 e8 00 00 restore
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
2005450: c0 27 20 d4 clr [ %i4 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
2005454: c0 27 20 d8 clr [ %i4 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
2005458: c0 27 20 dc clr [ %i4 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
200545c: c0 27 20 e0 clr [ %i4 + 0xe0 ]
tty->tty_rcvwakeup = 0;
2005460: c0 27 20 e4 clr [ %i4 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
2005464: e0 27 00 00 st %l0, [ %i4 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
2005468: 80 a4 20 00 cmp %l0, 0
200546c: 02 80 00 03 be 2005478 <rtems_termios_open+0x124>
2005470: c0 27 20 04 clr [ %i4 + 4 ]
rtems_termios_ttyHead->back = tty;
2005474: f8 24 20 04 st %i4, [ %l0 + 4 ]
rtems_termios_ttyHead = tty;
2005478: 03 00 80 76 sethi %hi(0x201d800), %g1
200547c: f8 20 62 e8 st %i4, [ %g1 + 0x2e8 ] ! 201dae8 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
2005480: 03 00 80 76 sethi %hi(0x201d800), %g1
2005484: c4 00 62 e4 ld [ %g1 + 0x2e4 ], %g2 ! 201dae4 <rtems_termios_ttyTail>
2005488: 80 a0 a0 00 cmp %g2, 0
200548c: 22 80 00 02 be,a 2005494 <rtems_termios_open+0x140>
2005490: f8 20 62 e4 st %i4, [ %g1 + 0x2e4 ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
2005494: 21 00 80 74 sethi %hi(0x201d000), %l0
2005498: d0 4c 20 40 ldsb [ %l0 + 0x40 ], %o0 ! 201d040 <c.6678>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
200549c: 03 15 14 9a sethi %hi(0x54526800), %g1
20054a0: 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;
20054a4: f2 27 20 10 st %i1, [ %i4 + 0x10 ]
tty->major = major;
20054a8: fa 27 20 0c st %i5, [ %i4 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
20054ac: 90 12 00 01 or %o0, %g1, %o0
20054b0: 92 10 20 01 mov 1, %o1
20054b4: 94 10 20 54 mov 0x54, %o2
20054b8: 96 10 20 00 clr %o3
20054bc: 40 00 08 55 call 2007610 <rtems_semaphore_create>
20054c0: 98 07 20 14 add %i4, 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)
20054c4: 80 a2 20 00 cmp %o0, 0
20054c8: 12 80 00 a8 bne 2005768 <rtems_termios_open+0x414>
20054cc: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
20054d0: d0 4c 20 40 ldsb [ %l0 + 0x40 ], %o0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
20054d4: 03 15 14 9b sethi %hi(0x54526c00), %g1
20054d8: 82 10 63 00 or %g1, 0x300, %g1 ! 54526f00 <RAM_END+0x52126f00>
20054dc: 92 10 20 01 mov 1, %o1
20054e0: 90 12 00 01 or %o0, %g1, %o0
20054e4: 94 10 20 54 mov 0x54, %o2
20054e8: 96 10 20 00 clr %o3
20054ec: 40 00 08 49 call 2007610 <rtems_semaphore_create>
20054f0: 98 07 20 18 add %i4, 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)
20054f4: 80 a2 20 00 cmp %o0, 0
20054f8: 12 80 00 9c bne 2005768 <rtems_termios_open+0x414>
20054fc: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
2005500: d0 4c 20 40 ldsb [ %l0 + 0x40 ], %o0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
2005504: 03 15 14 9e sethi %hi(0x54527800), %g1
2005508: 92 10 20 00 clr %o1
200550c: 90 12 00 01 or %o0, %g1, %o0
2005510: 94 10 20 20 mov 0x20, %o2
2005514: 96 10 20 00 clr %o3
2005518: 40 00 08 3e call 2007610 <rtems_semaphore_create>
200551c: 98 07 20 8c add %i4, 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)
2005520: 80 a2 20 00 cmp %o0, 0
2005524: 12 80 00 91 bne 2005768 <rtems_termios_open+0x414>
2005528: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
200552c: c0 27 20 94 clr [ %i4 + 0x94 ]
/*
* Set callbacks
*/
tty->device = *callbacks;
2005530: 90 07 20 98 add %i4, 0x98, %o0
2005534: 92 10 00 1b mov %i3, %o1
2005538: 40 00 2b 2b call 20101e4 <memcpy>
200553c: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005540: c2 07 20 b4 ld [ %i4 + 0xb4 ], %g1
2005544: 80 a0 60 02 cmp %g1, 2
2005548: 32 80 00 1b bne,a 20055b4 <rtems_termios_open+0x260>
200554c: c2 07 20 a0 ld [ %i4 + 0xa0 ], %g1
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
2005550: d0 4c 20 40 ldsb [ %l0 + 0x40 ], %o0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
2005554: 03 15 1e 15 sethi %hi(0x54785400), %g1
2005558: 92 10 20 0a mov 0xa, %o1
200555c: 90 12 00 01 or %o0, %g1, %o0
2005560: 94 10 24 00 mov 0x400, %o2
2005564: 96 10 25 00 mov 0x500, %o3
2005568: 98 10 20 00 clr %o4
200556c: 40 00 09 3a call 2007a54 <rtems_task_create>
2005570: 9a 07 20 c8 add %i4, 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)
2005574: 80 a2 20 00 cmp %o0, 0
2005578: 12 80 00 7c bne 2005768 <rtems_termios_open+0x414> <== NEVER TAKEN
200557c: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
2005580: d0 4c 20 40 ldsb [ %l0 + 0x40 ], %o0
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
2005584: 03 14 9e 15 sethi %hi(0x52785400), %g1
2005588: 92 10 20 09 mov 9, %o1
200558c: 90 12 00 01 or %o0, %g1, %o0
2005590: 94 10 24 00 mov 0x400, %o2
2005594: 96 10 25 00 mov 0x500, %o3
2005598: 98 10 20 00 clr %o4
200559c: 40 00 09 2e call 2007a54 <rtems_task_create>
20055a0: 9a 07 20 c4 add %i4, 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)
20055a4: 80 a2 20 00 cmp %o0, 0
20055a8: 12 80 00 70 bne 2005768 <rtems_termios_open+0x414> <== NEVER TAKEN
20055ac: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
20055b0: c2 07 20 a0 ld [ %i4 + 0xa0 ], %g1
20055b4: 80 a0 60 00 cmp %g1, 0
20055b8: 02 80 00 07 be 20055d4 <rtems_termios_open+0x280>
20055bc: 03 00 80 74 sethi %hi(0x201d000), %g1
20055c0: c2 07 20 b4 ld [ %i4 + 0xb4 ], %g1
20055c4: 80 a0 60 02 cmp %g1, 2
20055c8: 12 80 00 0f bne 2005604 <rtems_termios_open+0x2b0>
20055cc: 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),
20055d0: 03 00 80 74 sethi %hi(0x201d000), %g1
20055d4: d0 48 60 40 ldsb [ %g1 + 0x40 ], %o0 ! 201d040 <c.6678>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
20055d8: 03 15 14 9c sethi %hi(0x54527000), %g1
20055dc: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x52127200>
20055e0: 92 10 20 00 clr %o1
20055e4: 90 12 00 01 or %o0, %g1, %o0
20055e8: 94 10 20 24 mov 0x24, %o2
20055ec: 96 10 20 00 clr %o3
20055f0: 40 00 08 08 call 2007610 <rtems_semaphore_create>
20055f4: 98 07 20 68 add %i4, 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)
20055f8: 80 a2 20 00 cmp %o0, 0
20055fc: 12 80 00 5b bne 2005768 <rtems_termios_open+0x414> <== NEVER TAKEN
2005600: 03 00 00 09 sethi %hi(0x2400), %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
2005604: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 <PROM_START+0x2502>
2005608: c2 27 20 30 st %g1, [ %i4 + 0x30 ]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
200560c: 03 00 00 06 sethi %hi(0x1800), %g1
2005610: 82 10 60 05 or %g1, 5, %g1 ! 1805 <PROM_START+0x1805>
2005614: c2 27 20 34 st %g1, [ %i4 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
2005618: 82 10 28 bd mov 0x8bd, %g1
200561c: c2 27 20 38 st %g1, [ %i4 + 0x38 ]
tty->termios.c_lflag =
2005620: 03 00 00 20 sethi %hi(0x8000), %g1
2005624: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b <PROM_START+0x823b>
2005628: c2 27 20 3c st %g1, [ %i4 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
200562c: 82 10 20 03 mov 3, %g1
2005630: c2 2f 20 41 stb %g1, [ %i4 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
2005634: 82 10 20 1c mov 0x1c, %g1
2005638: c2 2f 20 42 stb %g1, [ %i4 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
200563c: 82 10 20 7f mov 0x7f, %g1
2005640: c2 2f 20 43 stb %g1, [ %i4 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
2005644: 82 10 20 15 mov 0x15, %g1
2005648: c2 2f 20 44 stb %g1, [ %i4 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
200564c: 82 10 20 04 mov 4, %g1
2005650: c2 2f 20 45 stb %g1, [ %i4 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
2005654: 82 10 20 11 mov 0x11, %g1
2005658: c2 2f 20 49 stb %g1, [ %i4 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
200565c: 82 10 20 13 mov 0x13, %g1
2005660: c2 2f 20 4a stb %g1, [ %i4 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
2005664: 82 10 20 1a mov 0x1a, %g1
2005668: c2 2f 20 4b stb %g1, [ %i4 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
200566c: 82 10 20 12 mov 0x12, %g1
2005670: c2 2f 20 4d stb %g1, [ %i4 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
2005674: 82 10 20 0f mov 0xf, %g1
2005678: c2 2f 20 4e stb %g1, [ %i4 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
200567c: 82 10 20 17 mov 0x17, %g1
2005680: c2 2f 20 4f stb %g1, [ %i4 + 0x4f ]
tty->termios.c_cc[VLNEXT] = '\026';
2005684: 82 10 20 16 mov 0x16, %g1
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
2005688: c0 27 20 b8 clr [ %i4 + 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';
200568c: c2 2f 20 50 stb %g1, [ %i4 + 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;
2005690: c2 07 20 64 ld [ %i4 + 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';
2005694: c0 2f 20 4c clrb [ %i4 + 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;
2005698: 83 30 60 01 srl %g1, 1, %g1
200569c: c2 27 20 bc st %g1, [ %i4 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
20056a0: c2 07 20 64 ld [ %i4 + 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';
20056a4: c0 2f 20 51 clrb [ %i4 + 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;
20056a8: 85 28 60 01 sll %g1, 1, %g2
20056ac: 82 00 80 01 add %g2, %g1, %g1
20056b0: 83 30 60 02 srl %g1, 2, %g1
20056b4: c2 27 20 c0 st %g1, [ %i4 + 0xc0 ]
/*
* Bump name characer
*/
if (c++ == 'z')
20056b8: 03 00 80 74 sethi %hi(0x201d000), %g1
20056bc: c4 08 60 40 ldub [ %g1 + 0x40 ], %g2 ! 201d040 <c.6678>
20056c0: 86 00 a0 01 add %g2, 1, %g3
20056c4: 85 28 a0 18 sll %g2, 0x18, %g2
20056c8: 85 38 a0 18 sra %g2, 0x18, %g2
20056cc: 80 a0 a0 7a cmp %g2, 0x7a
20056d0: 12 80 00 04 bne 20056e0 <rtems_termios_open+0x38c>
20056d4: c6 28 60 40 stb %g3, [ %g1 + 0x40 ]
c = 'a';
20056d8: 84 10 20 61 mov 0x61, %g2
20056dc: c4 28 60 40 stb %g2, [ %g1 + 0x40 ]
}
args->iop->data1 = tty;
20056e0: c2 06 80 00 ld [ %i2 ], %g1
20056e4: f8 20 60 40 st %i4, [ %g1 + 0x40 ]
if (!tty->refcount++) {
20056e8: c2 07 20 08 ld [ %i4 + 8 ], %g1
20056ec: 84 00 60 01 add %g1, 1, %g2
20056f0: 80 a0 60 00 cmp %g1, 0
20056f4: 12 80 00 1f bne 2005770 <rtems_termios_open+0x41c>
20056f8: c4 27 20 08 st %g2, [ %i4 + 8 ]
if (tty->device.firstOpen)
20056fc: c2 07 20 98 ld [ %i4 + 0x98 ], %g1
2005700: 80 a0 60 00 cmp %g1, 0
2005704: 02 80 00 05 be 2005718 <rtems_termios_open+0x3c4>
2005708: 90 10 00 1d mov %i5, %o0
(*tty->device.firstOpen)(major, minor, arg);
200570c: 92 10 00 19 mov %i1, %o1
2005710: 9f c0 40 00 call %g1
2005714: 94 10 00 1a mov %i2, %o2
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005718: c2 07 20 b4 ld [ %i4 + 0xb4 ], %g1
200571c: 80 a0 60 02 cmp %g1, 2
2005720: 12 80 00 15 bne 2005774 <rtems_termios_open+0x420>
2005724: 03 00 80 76 sethi %hi(0x201d800), %g1
sc = rtems_task_start(
2005728: d0 07 20 c4 ld [ %i4 + 0xc4 ], %o0
200572c: 13 00 80 1b sethi %hi(0x2006c00), %o1
2005730: 94 10 00 1c mov %i4, %o2
2005734: 40 00 09 6d call 2007ce8 <rtems_task_start>
2005738: 92 12 60 6c or %o1, 0x6c, %o1
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
200573c: 80 a2 20 00 cmp %o0, 0
2005740: 12 80 00 0a bne 2005768 <rtems_termios_open+0x414> <== NEVER TAKEN
2005744: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
2005748: d0 07 20 c8 ld [ %i4 + 0xc8 ], %o0
200574c: 13 00 80 14 sethi %hi(0x2005000), %o1
2005750: 94 10 00 1c mov %i4, %o2
2005754: 40 00 09 65 call 2007ce8 <rtems_task_start>
2005758: 92 12 62 80 or %o1, 0x280, %o1
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
200575c: 80 a2 20 00 cmp %o0, 0
2005760: 02 80 00 05 be 2005774 <rtems_termios_open+0x420> <== ALWAYS TAKEN
2005764: 03 00 80 76 sethi %hi(0x201d800), %g1
rtems_fatal_error_occurred (sc);
2005768: 40 00 0a 08 call 2007f88 <rtems_fatal_error_occurred>
200576c: 01 00 00 00 nop
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2005770: 03 00 80 76 sethi %hi(0x201d800), %g1
2005774: 40 00 08 8b call 20079a0 <rtems_semaphore_release>
2005778: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 201dae0 <rtems_termios_ttyMutex>
return RTEMS_SUCCESSFUL;
}
200577c: 81 c7 e0 08 ret
2005780: 81 e8 00 00 restore
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
2005784: 7f ff f7 35 call 2003458 <calloc>
2005788: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
200578c: b8 92 20 00 orcc %o0, 0, %i4
2005790: 32 bf ff 0b bne,a 20053bc <rtems_termios_open+0x68>
2005794: 03 00 80 74 sethi %hi(0x201d000), %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);
2005798: 10 bf ff 29 b 200543c <rtems_termios_open+0xe8>
200579c: 03 00 80 76 sethi %hi(0x201d800), %g1
02005da0 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
2005da0: 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) {
2005da4: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
2005da8: 80 a0 60 00 cmp %g1, 0
2005dac: 12 80 00 08 bne 2005dcc <rtems_termios_puts+0x2c>
2005db0: 92 10 00 18 mov %i0, %o1
(*tty->device.write)(tty->minor, buf, len);
2005db4: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2005db8: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005dbc: 9f c0 40 00 call %g1
2005dc0: 94 10 00 19 mov %i1, %o2
return;
2005dc4: 81 c7 e0 08 ret
2005dc8: 81 e8 00 00 restore
}
newHead = tty->rawOutBuf.Head;
2005dcc: f8 06 a0 80 ld [ %i2 + 0x80 ], %i4
while (len) {
2005dd0: ba 10 20 00 clr %i5
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
2005dd4: a2 10 20 02 mov 2, %l1
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
2005dd8: 10 80 00 36 b 2005eb0 <rtems_termios_puts+0x110>
2005ddc: 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;
2005de0: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
2005de4: 40 00 4b 38 call 2018ac4 <.urem>
2005de8: 90 07 20 01 add %i4, 1, %o0
2005dec: 10 80 00 0d b 2005e20 <rtems_termios_puts+0x80>
2005df0: b8 10 00 08 mov %o0, %i4
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
2005df4: 7f ff f2 02 call 20025fc <sparc_enable_interrupts>
2005df8: 90 10 00 1b mov %i3, %o0
sc = rtems_semaphore_obtain(
2005dfc: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
2005e00: 92 10 20 00 clr %o1
2005e04: 40 00 06 9d call 2007878 <rtems_semaphore_obtain>
2005e08: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005e0c: 80 a2 20 00 cmp %o0, 0
2005e10: 02 80 00 04 be 2005e20 <rtems_termios_puts+0x80> <== ALWAYS TAKEN
2005e14: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
2005e18: 40 00 08 5c call 2007f88 <rtems_fatal_error_occurred> <== NOT EXECUTED
2005e1c: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
2005e20: 7f ff f1 f3 call 20025ec <sparc_disable_interrupts>
2005e24: 01 00 00 00 nop
2005e28: b6 10 00 08 mov %o0, %i3
* 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) {
2005e2c: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
2005e30: 80 a7 00 01 cmp %i4, %g1
2005e34: 22 bf ff f0 be,a 2005df4 <rtems_termios_puts+0x54>
2005e38: e2 26 a0 94 st %l1, [ %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++;
2005e3c: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
2005e40: c6 0e 00 1d ldub [ %i0 + %i5 ], %g3
2005e44: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
2005e48: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
2005e4c: 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;
2005e50: f8 26 a0 80 st %i4, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
2005e54: 80 a0 60 00 cmp %g1, 0
2005e58: 12 80 00 13 bne 2005ea4 <rtems_termios_puts+0x104>
2005e5c: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
2005e60: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
2005e64: 80 88 60 10 btst 0x10, %g1
2005e68: 12 80 00 0b bne 2005e94 <rtems_termios_puts+0xf4> <== NEVER TAKEN
2005e6c: 01 00 00 00 nop
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
2005e70: 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)(
2005e74: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
2005e78: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2005e7c: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005e80: 92 02 40 02 add %o1, %g2, %o1
2005e84: 9f c0 40 00 call %g1
2005e88: 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;
2005e8c: 10 80 00 06 b 2005ea4 <rtems_termios_puts+0x104>
2005e90: 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;
2005e94: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
2005e98: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
2005e9c: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
2005ea0: e0 26 a0 94 st %l0, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
2005ea4: 90 10 00 1b mov %i3, %o0
2005ea8: 7f ff f1 d5 call 20025fc <sparc_enable_interrupts>
2005eac: ba 07 60 01 inc %i5
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
2005eb0: 80 a7 40 19 cmp %i5, %i1
2005eb4: 12 bf ff cb bne 2005de0 <rtems_termios_puts+0x40>
2005eb8: 01 00 00 00 nop
2005ebc: 81 c7 e0 08 ret
2005ec0: 81 e8 00 00 restore
020065c0 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
20065c0: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20065c4: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
20065c8: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20065cc: fa 00 60 40 ld [ %g1 + 0x40 ], %i5
uint32_t count = args->count;
char *buffer = args->buffer;
20065d0: f2 06 20 10 ld [ %i0 + 0x10 ], %i1
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20065d4: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
20065d8: 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);
20065dc: 92 10 20 00 clr %o1
20065e0: 40 00 04 a6 call 2007878 <rtems_semaphore_obtain>
20065e4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
20065e8: b0 92 20 00 orcc %o0, 0, %i0
20065ec: 12 80 00 10 bne 200662c <rtems_termios_read+0x6c> <== NEVER TAKEN
20065f0: 03 00 80 75 sethi %hi(0x201d400), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
20065f4: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
20065f8: 85 28 a0 05 sll %g2, 5, %g2
20065fc: 82 10 63 2c or %g1, 0x32c, %g1
2006600: 82 00 40 02 add %g1, %g2, %g1
2006604: c2 00 60 08 ld [ %g1 + 8 ], %g1
2006608: 80 a0 60 00 cmp %g1, 0
200660c: 02 80 00 0a be 2006634 <rtems_termios_read+0x74>
2006610: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
2006614: 9f c0 40 00 call %g1
2006618: 92 10 00 1c mov %i4, %o1
200661c: b0 10 00 08 mov %o0, %i0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
2006620: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
2006624: 40 00 04 df call 20079a0 <rtems_semaphore_release>
2006628: c0 27 60 e4 clr [ %i5 + 0xe4 ]
return sc;
200662c: 81 c7 e0 08 ret
2006630: 81 e8 00 00 restore
}
if (tty->cindex == tty->ccount) {
2006634: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
2006638: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200663c: 80 a0 80 01 cmp %g2, %g1
2006640: 12 80 00 bc bne 2006930 <rtems_termios_read+0x370> <== NEVER TAKEN
2006644: 80 a6 e0 00 cmp %i3, 0
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
2006648: 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;
200664c: c0 27 60 20 clr [ %i5 + 0x20 ]
tty->read_start_column = tty->column;
2006650: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
if (tty->device.pollRead != NULL &&
2006654: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2006658: 80 a0 60 00 cmp %g1, 0
200665c: 02 80 00 4c be 200678c <rtems_termios_read+0x1cc>
2006660: c0 27 60 24 clr [ %i5 + 0x24 ]
2006664: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2006668: 80 a0 60 00 cmp %g1, 0
200666c: 32 80 00 49 bne,a 2006790 <rtems_termios_read+0x1d0>
2006670: 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) {
2006674: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2006678: 80 88 60 02 btst 2, %g1
200667c: 02 80 00 13 be 20066c8 <rtems_termios_read+0x108>
2006680: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006684: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2006688: 9f c0 40 00 call %g1
200668c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
2006690: 80 a2 20 00 cmp %o0, 0
2006694: 16 80 00 06 bge 20066ac <rtems_termios_read+0xec>
2006698: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
200669c: 40 00 05 ae call 2007d54 <rtems_task_wake_after>
20066a0: 90 10 20 01 mov 1, %o0
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
20066a4: 10 bf ff f9 b 2006688 <rtems_termios_read+0xc8>
20066a8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
20066ac: 7f ff ff 80 call 20064ac <siproc>
20066b0: 92 10 00 1d mov %i5, %o1
20066b4: 80 a2 20 00 cmp %o0, 0
20066b8: 22 bf ff f4 be,a 2006688 <rtems_termios_read+0xc8>
20066bc: 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)) {
20066c0: 10 80 00 9c b 2006930 <rtems_termios_read+0x370>
20066c4: 80 a6 e0 00 cmp %i3, 0
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
20066c8: 40 00 02 af call 2007184 <rtems_clock_get_ticks_since_boot>
20066cc: 01 00 00 00 nop
20066d0: b4 10 00 08 mov %o0, %i2
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
20066d4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
20066d8: 9f c0 40 00 call %g1
20066dc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
20066e0: 80 a2 20 00 cmp %o0, 0
20066e4: 36 80 00 1c bge,a 2006754 <rtems_termios_read+0x194>
20066e8: 90 0a 20 ff and %o0, 0xff, %o0
if (tty->termios.c_cc[VMIN]) {
20066ec: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
20066f0: 80 a0 60 00 cmp %g1, 0
20066f4: 02 80 00 0a be 200671c <rtems_termios_read+0x15c>
20066f8: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
20066fc: 80 88 60 ff btst 0xff, %g1
2006700: 02 80 00 11 be 2006744 <rtems_termios_read+0x184> <== NEVER TAKEN
2006704: 01 00 00 00 nop
2006708: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200670c: 80 a0 60 00 cmp %g1, 0
2006710: 02 80 00 0d be 2006744 <rtems_termios_read+0x184>
2006714: 01 00 00 00 nop
2006718: 30 80 00 04 b,a 2006728 <rtems_termios_read+0x168>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
200671c: 80 88 60 ff btst 0xff, %g1
2006720: 02 80 00 84 be 2006930 <rtems_termios_read+0x370> <== NEVER TAKEN
2006724: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
2006728: 40 00 02 97 call 2007184 <rtems_clock_get_ticks_since_boot>
200672c: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
2006730: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
2006734: 90 22 00 1a sub %o0, %i2, %o0
2006738: 80 a2 00 01 cmp %o0, %g1
200673c: 18 80 00 7d bgu 2006930 <rtems_termios_read+0x370>
2006740: 80 a6 e0 00 cmp %i3, 0
break;
}
}
rtems_task_wake_after (1);
2006744: 40 00 05 84 call 2007d54 <rtems_task_wake_after>
2006748: 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);
200674c: 10 bf ff e3 b 20066d8 <rtems_termios_read+0x118>
2006750: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
2006754: 7f ff ff 56 call 20064ac <siproc>
2006758: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
200675c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
2006760: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2006764: 80 a0 80 01 cmp %g2, %g1
2006768: 16 80 00 71 bge 200692c <rtems_termios_read+0x36c>
200676c: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
2006770: 22 bf ff da be,a 20066d8 <rtems_termios_read+0x118> <== NEVER TAKEN
2006774: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
2006778: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
200677c: 80 a0 60 00 cmp %g1, 0
2006780: 22 bf ff d6 be,a 20066d8 <rtems_termios_read+0x118> <== NEVER TAKEN
2006784: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
2006788: 30 bf ff d0 b,a 20066c8 <rtems_termios_read+0x108>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
200678c: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
rtems_status_code sc;
int wait = 1;
2006790: b4 10 20 01 mov 1, %i2
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
2006794: 25 00 80 74 sethi %hi(0x201d000), %l2
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
2006798: 10 80 00 4a b 20068c0 <rtems_termios_read+0x300>
200679c: a2 07 60 49 add %i5, 0x49, %l1
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;
20067a0: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
20067a4: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
20067a8: 40 00 48 c7 call 2018ac4 <.urem>
20067ac: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
20067b0: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
20067b4: e0 08 40 08 ldub [ %g1 + %o0 ], %l0
tty->rawInBuf.Head = newHead;
20067b8: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
20067bc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
20067c0: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
20067c4: 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)
20067c8: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
20067cc: 40 00 48 be call 2018ac4 <.urem>
20067d0: 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)
20067d4: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
20067d8: 80 a2 00 01 cmp %o0, %g1
20067dc: 3a 80 00 27 bcc,a 2006878 <rtems_termios_read+0x2b8> <== NEVER TAKEN
20067e0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
20067e4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20067e8: 82 08 7f fe and %g1, -2, %g1
20067ec: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
20067f0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20067f4: 82 08 62 02 and %g1, 0x202, %g1
20067f8: 80 a0 62 02 cmp %g1, 0x202
20067fc: 12 80 00 11 bne 2006840 <rtems_termios_read+0x280> <== ALWAYS TAKEN
2006800: 01 00 00 00 nop
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
2006804: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2006808: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200680c: 22 80 00 07 be,a 2006828 <rtems_termios_read+0x268> <== NOT EXECUTED
2006810: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
2006814: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006818: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
200681c: 02 80 00 09 be 2006840 <rtems_termios_read+0x280> <== NOT EXECUTED
2006820: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
2006824: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2006828: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
200682c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2006830: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006834: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006838: 10 80 00 10 b 2006878 <rtems_termios_read+0x2b8> <== NOT EXECUTED
200683c: 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) {
2006840: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006844: 80 88 61 00 btst 0x100, %g1
2006848: 22 80 00 0c be,a 2006878 <rtems_termios_read+0x2b8> <== ALWAYS TAKEN
200684c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
2006850: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006854: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
2006858: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
200685c: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
2006860: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006864: 22 80 00 05 be,a 2006878 <rtems_termios_read+0x2b8> <== NOT EXECUTED
2006868: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
200686c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006870: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006874: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
2006878: 92 10 00 1d mov %i5, %o1
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
200687c: 80 88 60 02 btst 2, %g1
2006880: 02 80 00 08 be 20068a0 <rtems_termios_read+0x2e0> <== NEVER TAKEN
2006884: 90 0c 20 ff and %l0, 0xff, %o0
if (siproc (c, tty))
2006888: 7f ff ff 09 call 20064ac <siproc>
200688c: 01 00 00 00 nop
wait = 0;
2006890: 80 a0 00 08 cmp %g0, %o0
2006894: 82 40 3f ff addx %g0, -1, %g1
2006898: 10 80 00 09 b 20068bc <rtems_termios_read+0x2fc>
200689c: b4 0e 80 01 and %i2, %g1, %i2
} else {
siproc (c, tty);
20068a0: 7f ff ff 03 call 20064ac <siproc> <== NOT EXECUTED
20068a4: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
20068a8: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
20068ac: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
20068b0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20068b4: 36 80 00 02 bge,a 20068bc <rtems_termios_read+0x2fc> <== NOT EXECUTED
20068b8: b4 10 20 00 clr %i2 <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
20068bc: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
20068c0: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
20068c4: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
20068c8: 80 a0 80 01 cmp %g2, %g1
20068cc: 02 80 00 07 be 20068e8 <rtems_termios_read+0x328>
20068d0: c2 04 a0 3c ld [ %l2 + 0x3c ], %g1
20068d4: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
20068d8: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
20068dc: 80 a0 80 01 cmp %g2, %g1
20068e0: 0a bf ff b0 bcs 20067a0 <rtems_termios_read+0x1e0> <== ALWAYS TAKEN
20068e4: 01 00 00 00 nop
}
/*
* Wait for characters
*/
if ( wait ) {
20068e8: 80 a6 a0 00 cmp %i2, 0
20068ec: 02 80 00 11 be 2006930 <rtems_termios_read+0x370>
20068f0: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
20068f4: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
20068f8: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
20068fc: 40 00 03 df call 2007878 <rtems_semaphore_obtain>
2006900: 94 10 00 10 mov %l0, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
2006904: 80 a2 20 00 cmp %o0, 0
2006908: 02 bf ff ee be 20068c0 <rtems_termios_read+0x300> <== ALWAYS TAKEN
200690c: 80 a6 e0 00 cmp %i3, 0
2006910: 30 80 00 08 b,a 2006930 <rtems_termios_read+0x370> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
2006914: 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++];
2006918: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
200691c: 82 00 60 01 inc %g1
2006920: c4 2e 40 00 stb %g2, [ %i1 ]
2006924: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
2006928: b2 06 60 01 inc %i1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
200692c: 80 a6 e0 00 cmp %i3, 0
2006930: 22 80 00 08 be,a 2006950 <rtems_termios_read+0x390>
2006934: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2006938: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200693c: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2006940: 80 a0 40 02 cmp %g1, %g2
2006944: 26 bf ff f4 bl,a 2006914 <rtems_termios_read+0x354>
2006948: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
200694c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
2006950: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
2006954: b6 20 40 1b sub %g1, %i3, %i3
2006958: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
200695c: 40 00 04 11 call 20079a0 <rtems_semaphore_release>
2006960: c0 27 60 e4 clr [ %i5 + 0xe4 ]
return sc;
}
2006964: 81 c7 e0 08 ret
2006968: 81 e8 00 00 restore
0200509c <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)
{
200509c: 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))
20050a0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
20050a4: 82 08 64 03 and %g1, 0x403, %g1
20050a8: 80 a0 64 01 cmp %g1, 0x401
20050ac: 12 80 00 0f bne 20050e8 <rtems_termios_refill_transmitter+0x4c><== ALWAYS TAKEN
20050b0: 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);
20050b4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
20050b8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
20050bc: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
20050c0: 9f c0 40 00 call %g1 <== NOT EXECUTED
20050c4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
20050c8: 7f ff f5 49 call 20025ec <sparc_disable_interrupts> <== NOT EXECUTED
20050cc: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
20050d0: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
20050d4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20050d8: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
20050dc: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20050e0: 10 80 00 12 b 2005128 <rtems_termios_refill_transmitter+0x8c><== NOT EXECUTED
20050e4: 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) {
20050e8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
20050ec: 82 08 60 03 and %g1, 3, %g1
20050f0: 80 a0 60 02 cmp %g1, 2
20050f4: 12 80 00 12 bne 200513c <rtems_termios_refill_transmitter+0xa0><== ALWAYS TAKEN
20050f8: 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);
20050fc: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
2005100: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2005104: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005108: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
200510c: 7f ff f5 38 call 20025ec <sparc_disable_interrupts> <== NOT EXECUTED
2005110: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
2005114: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
2005118: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
200511c: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
2005120: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2005124: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
2005128: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
200512c: 7f ff f5 34 call 20025fc <sparc_enable_interrupts> <== NOT EXECUTED
2005130: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2005134: 81 c7 e0 08 ret
2005138: 81 e8 00 00 restore
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
200513c: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
2005140: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2005144: 80 a0 80 01 cmp %g2, %g1
2005148: 12 80 00 0a bne 2005170 <rtems_termios_refill_transmitter+0xd4>
200514c: 01 00 00 00 nop
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
2005150: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
2005154: 80 a0 60 02 cmp %g1, 2
2005158: 12 bf ff f7 bne 2005134 <rtems_termios_refill_transmitter+0x98><== ALWAYS TAKEN
200515c: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2005160: 40 00 0a 10 call 20079a0 <rtems_semaphore_release> <== NOT EXECUTED
2005164: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
2005168: 81 c7 e0 08 ret <== NOT EXECUTED
200516c: 81 e8 00 00 restore <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
2005170: 7f ff f5 1f call 20025ec <sparc_disable_interrupts>
2005174: 01 00 00 00 nop
len = tty->t_dqlen;
2005178: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
200517c: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
2005180: 7f ff f5 1f call 20025fc <sparc_enable_interrupts>
2005184: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
2005188: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
200518c: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
2005190: 40 00 4e 4d call 2018ac4 <.urem>
2005194: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
2005198: 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;
200519c: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
20051a0: 80 a0 60 02 cmp %g1, 2
20051a4: 12 80 00 04 bne 20051b4 <rtems_termios_refill_transmitter+0x118>
20051a8: b8 10 00 08 mov %o0, %i4
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
20051ac: 40 00 09 fd call 20079a0 <rtems_semaphore_release>
20051b0: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
}
if (newTail == tty->rawOutBuf.Head) {
20051b4: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
20051b8: 80 a7 00 01 cmp %i4, %g1
20051bc: 12 80 00 0b bne 20051e8 <rtems_termios_refill_transmitter+0x14c>
20051c0: 01 00 00 00 nop
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
20051c4: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
20051c8: 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) {
20051cc: 80 a0 60 00 cmp %g1, 0
20051d0: 02 80 00 29 be 2005274 <rtems_termios_refill_transmitter+0x1d8><== ALWAYS TAKEN
20051d4: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
20051d8: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
20051dc: 9f c0 40 00 call %g1 <== NOT EXECUTED
20051e0: 90 07 60 30 add %i5, 0x30, %o0 <== NOT EXECUTED
20051e4: 30 80 00 24 b,a 2005274 <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))
20051e8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20051ec: 82 08 62 10 and %g1, 0x210, %g1
20051f0: 80 a0 62 10 cmp %g1, 0x210
20051f4: 12 80 00 0c bne 2005224 <rtems_termios_refill_transmitter+0x188><== ALWAYS TAKEN
20051f8: 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);
20051fc: 7f ff f4 fc call 20025ec <sparc_disable_interrupts> <== NOT EXECUTED
2005200: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
2005204: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005208: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
200520c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
2005210: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2005214: c2 27 60 94 st %g1, [ %i5 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
2005218: 7f ff f4 f9 call 20025fc <sparc_enable_interrupts> <== NOT EXECUTED
200521c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2005220: 30 80 00 15 b,a 2005274 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
2005224: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2005228: 80 a7 00 01 cmp %i4, %g1
200522c: 08 80 00 04 bleu 200523c <rtems_termios_refill_transmitter+0x1a0>
2005230: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
2005234: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
2005238: 30 80 00 02 b,a 2005240 <rtems_termios_refill_transmitter+0x1a4>
else
nToSend = tty->rawOutBuf.Head - newTail;
200523c: 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)) {
2005240: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005244: 80 88 66 00 btst 0x600, %g1
2005248: 02 80 00 03 be 2005254 <rtems_termios_refill_transmitter+0x1b8>
200524c: b0 26 00 1c sub %i0, %i4, %i0
nToSend = 1;
2005250: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
2005254: 82 10 20 01 mov 1, %g1
(*tty->device.write)(
2005258: 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*/
200525c: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
(*tty->device.write)(
2005260: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2005264: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
2005268: 92 02 40 1c add %o1, %i4, %o1
200526c: 9f c0 40 00 call %g1
2005270: 94 10 00 18 mov %i0, %o2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
2005274: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
2005278: 81 c7 e0 08 ret
200527c: 81 e8 00 00 restore
02006c6c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
2006c6c: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006c70: 90 10 20 03 mov 3, %o0
2006c74: 92 10 20 02 mov 2, %o1
2006c78: 94 10 20 00 clr %o2
2006c7c: 40 00 01 65 call 2007210 <rtems_event_receive>
2006c80: 96 07 bf f8 add %fp, -8, %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) {
2006c84: c2 07 bf f8 ld [ %fp + -8 ], %g1
2006c88: 80 88 60 01 btst 1, %g1
2006c8c: 22 80 00 06 be,a 2006ca4 <rtems_termios_rxdaemon+0x38> <== ALWAYS TAKEN
2006c90: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
2006c94: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
2006c98: 40 00 03 ba call 2007b80 <rtems_task_delete> <== NOT EXECUTED
2006c9c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
2006ca0: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
2006ca4: 9f c0 40 00 call %g1
2006ca8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
2006cac: 80 a2 3f ff cmp %o0, -1
2006cb0: 22 bf ff f1 be,a 2006c74 <rtems_termios_rxdaemon+0x8>
2006cb4: 90 10 20 03 mov 3, %o0
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
2006cb8: d0 2f bf ff stb %o0, [ %fp + -1 ]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
2006cbc: 92 07 bf ff add %fp, -1, %o1
2006cc0: 90 10 00 18 mov %i0, %o0
2006cc4: 7f ff ff 2f call 2006980 <rtems_termios_enqueue_raw_characters>
2006cc8: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006ccc: 10 bf ff ea b 2006c74 <rtems_termios_rxdaemon+0x8>
2006cd0: 90 10 20 03 mov 3, %o0
02005280 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
2005280: 9d e3 bf 98 save %sp, -104, %sp
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2005284: 3b 00 80 75 sethi %hi(0x201d400), %i5
2005288: ba 17 63 2c or %i5, 0x32c, %i5 ! 201d72c <rtems_termios_linesw>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
200528c: 90 10 20 03 mov 3, %o0
2005290: 92 10 20 02 mov 2, %o1
2005294: 94 10 20 00 clr %o2
2005298: 40 00 07 de call 2007210 <rtems_event_receive>
200529c: 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) {
20052a0: c2 07 bf fc ld [ %fp + -4 ], %g1
20052a4: 80 88 60 01 btst 1, %g1
20052a8: 22 80 00 06 be,a 20052c0 <rtems_termios_txdaemon+0x40> <== ALWAYS TAKEN
20052ac: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
20052b0: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
20052b4: 40 00 0a 33 call 2007b80 <rtems_task_delete> <== NOT EXECUTED
20052b8: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
20052bc: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
20052c0: 83 28 60 05 sll %g1, 5, %g1
20052c4: 82 07 40 01 add %i5, %g1, %g1
20052c8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
20052cc: 80 a0 60 00 cmp %g1, 0
20052d0: 02 80 00 04 be 20052e0 <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
20052d4: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
20052d8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20052dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
20052e0: 7f ff ff 6f call 200509c <rtems_termios_refill_transmitter>
20052e4: 90 10 00 18 mov %i0, %o0
}
20052e8: 10 bf ff ea b 2005290 <rtems_termios_txdaemon+0x10>
20052ec: 90 10 20 03 mov 3, %o0
020064f4 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
20064f4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20064f8: c2 06 00 00 ld [ %i0 ], %g1
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
20064fc: b8 10 00 18 mov %i0, %i4
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2006500: fa 00 60 40 ld [ %g1 + 0x40 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2006504: 92 10 20 00 clr %o1
2006508: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
200650c: 40 00 04 db call 2007878 <rtems_semaphore_obtain>
2006510: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
2006514: b0 92 20 00 orcc %o0, 0, %i0
2006518: 12 80 00 0f bne 2006554 <rtems_termios_write+0x60> <== NEVER TAKEN
200651c: 03 00 80 75 sethi %hi(0x201d400), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
2006520: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
2006524: 85 28 a0 05 sll %g2, 5, %g2
2006528: 82 10 63 2c or %g1, 0x32c, %g1
200652c: 82 00 40 02 add %g1, %g2, %g1
2006530: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2006534: 80 a0 60 00 cmp %g1, 0
2006538: 02 80 00 09 be 200655c <rtems_termios_write+0x68>
200653c: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
2006540: 9f c0 40 00 call %g1
2006544: 92 10 00 1c mov %i4, %o1
2006548: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
200654c: 40 00 05 15 call 20079a0 <rtems_semaphore_release>
2006550: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
2006554: 81 c7 e0 08 ret
2006558: 81 e8 00 00 restore
}
if (tty->termios.c_oflag & OPOST) {
200655c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
2006560: 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) {
2006564: 80 88 60 01 btst 1, %g1
2006568: f4 07 20 14 ld [ %i4 + 0x14 ], %i2
200656c: 12 80 00 07 bne 2006588 <rtems_termios_write+0x94> <== ALWAYS TAKEN
2006570: 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);
2006574: 10 80 00 0a b 200659c <rtems_termios_write+0xa8> <== NOT EXECUTED
2006578: 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);
200657c: 92 10 00 1d mov %i5, %o1
2006580: 7f ff fe 51 call 2005ec4 <oproc>
2006584: 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--)
2006588: 80 a6 c0 1a cmp %i3, %i2
200658c: 32 bf ff fc bne,a 200657c <rtems_termios_write+0x88>
2006590: 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;
2006594: 10 80 00 06 b 20065ac <rtems_termios_write+0xb8>
2006598: 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);
200659c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
20065a0: 7f ff fe 00 call 2005da0 <rtems_termios_puts> <== NOT EXECUTED
20065a4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
20065a8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
20065ac: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
20065b0: 40 00 04 fc call 20079a0 <rtems_semaphore_release>
20065b4: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
return sc;
}
20065b8: 81 c7 e0 08 ret
20065bc: 81 e8 00 00 restore
02018200 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
2018200: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
2018204: 11 00 80 f5 sethi %hi(0x203d400), %o0
2018208: 92 10 00 18 mov %i0, %o1
201820c: 90 12 21 d4 or %o0, 0x1d4, %o0
2018210: 40 00 0c 26 call 201b2a8 <_Objects_Get>
2018214: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2018218: c2 07 bf fc ld [ %fp + -4 ], %g1
201821c: 80 a0 60 00 cmp %g1, 0
2018220: 12 80 00 0c bne 2018250 <rtems_timer_cancel+0x50>
2018224: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
2018228: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
201822c: 80 a0 60 04 cmp %g1, 4
2018230: 02 80 00 04 be 2018240 <rtems_timer_cancel+0x40> <== NEVER TAKEN
2018234: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
2018238: 40 00 14 25 call 201d2cc <_Watchdog_Remove>
201823c: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
2018240: 40 00 0f f8 call 201c220 <_Thread_Enable_dispatch>
2018244: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
2018248: 81 c7 e0 08 ret
201824c: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2018250: 81 c7 e0 08 ret
2018254: 91 e8 20 04 restore %g0, 4, %o0
02018714 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2018714: 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;
2018718: 03 00 80 f5 sethi %hi(0x203d400), %g1
201871c: e0 00 62 14 ld [ %g1 + 0x214 ], %l0 ! 203d614 <_Timer_server>
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2018720: ba 10 00 18 mov %i0, %i5
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
2018724: 80 a4 20 00 cmp %l0, 0
2018728: 02 80 00 3b be 2018814 <rtems_timer_server_fire_when+0x100>
201872c: b0 10 20 0e mov 0xe, %i0
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
2018730: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2018734: c2 08 60 60 ldub [ %g1 + 0x60 ], %g1 ! 203cc60 <_TOD_Is_set>
2018738: 80 a0 60 00 cmp %g1, 0
201873c: 02 80 00 36 be 2018814 <rtems_timer_server_fire_when+0x100><== NEVER TAKEN
2018740: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( !routine )
2018744: 80 a6 a0 00 cmp %i2, 0
2018748: 02 80 00 33 be 2018814 <rtems_timer_server_fire_when+0x100>
201874c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
2018750: 90 10 00 19 mov %i1, %o0
2018754: 7f ff f3 8f call 2015590 <_TOD_Validate>
2018758: b0 10 20 14 mov 0x14, %i0
201875c: 80 8a 20 ff btst 0xff, %o0
2018760: 02 80 00 2f be 201881c <rtems_timer_server_fire_when+0x108>
2018764: 01 00 00 00 nop
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
2018768: 7f ff f3 4f call 20154a4 <_TOD_To_seconds>
201876c: 90 10 00 19 mov %i1, %o0
if ( seconds <= _TOD_Seconds_since_epoch() )
2018770: 23 00 80 f3 sethi %hi(0x203cc00), %l1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
2018774: b2 10 00 08 mov %o0, %i1
2018778: d0 1c 60 e0 ldd [ %l1 + 0xe0 ], %o0
201877c: 94 10 20 00 clr %o2
2018780: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018784: 40 00 4f ed call 202c738 <__divdi3>
2018788: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
201878c: 80 a6 40 09 cmp %i1, %o1
2018790: 08 80 00 21 bleu 2018814 <rtems_timer_server_fire_when+0x100>
2018794: 11 00 80 f5 sethi %hi(0x203d400), %o0
2018798: 92 10 00 1d mov %i5, %o1
201879c: 90 12 21 d4 or %o0, 0x1d4, %o0
20187a0: 40 00 0a c2 call 201b2a8 <_Objects_Get>
20187a4: 94 07 bf fc add %fp, -4, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
20187a8: c2 07 bf fc ld [ %fp + -4 ], %g1
20187ac: b8 10 00 08 mov %o0, %i4
20187b0: 80 a0 60 00 cmp %g1, 0
20187b4: 12 80 00 18 bne 2018814 <rtems_timer_server_fire_when+0x100>
20187b8: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
20187bc: 40 00 12 c4 call 201d2cc <_Watchdog_Remove>
20187c0: 90 02 20 10 add %o0, 0x10, %o0
20187c4: d0 1c 60 e0 ldd [ %l1 + 0xe0 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
20187c8: 82 10 20 03 mov 3, %g1
20187cc: 94 10 20 00 clr %o2
20187d0: c2 27 20 38 st %g1, [ %i4 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20187d4: c0 27 20 18 clr [ %i4 + 0x18 ]
the_watchdog->routine = routine;
20187d8: f4 27 20 2c st %i2, [ %i4 + 0x2c ]
the_watchdog->id = id;
20187dc: fa 27 20 30 st %i5, [ %i4 + 0x30 ]
the_watchdog->user_data = user_data;
20187e0: f6 27 20 34 st %i3, [ %i4 + 0x34 ]
20187e4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20187e8: 40 00 4f d4 call 202c738 <__divdi3>
20187ec: 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 );
20187f0: c2 04 20 04 ld [ %l0 + 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();
20187f4: b2 26 40 09 sub %i1, %o1, %i1
(*timer_server->schedule_operation)( timer_server, the_timer );
20187f8: 90 10 00 10 mov %l0, %o0
20187fc: 92 10 00 1c mov %i4, %o1
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();
2018800: f2 27 20 1c st %i1, [ %i4 + 0x1c ]
(*timer_server->schedule_operation)( timer_server, the_timer );
2018804: 9f c0 40 00 call %g1
2018808: b0 10 20 00 clr %i0
_Thread_Enable_dispatch();
201880c: 40 00 0e 85 call 201c220 <_Thread_Enable_dispatch>
2018810: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2018814: 81 c7 e0 08 ret
2018818: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
201881c: 81 c7 e0 08 ret
2018820: 81 e8 00 00 restore
020034cc <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
20034cc: 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) {
20034d0: 03 08 00 00 sethi %hi(0x20000000), %g1
20034d4: 80 8e 00 01 btst %i0, %g1
20034d8: 02 80 00 12 be 2003520 <rtems_verror+0x54>
20034dc: b8 10 00 18 mov %i0, %i4
if (rtems_panic_in_progress++)
20034e0: 05 00 80 76 sethi %hi(0x201d800), %g2
20034e4: c2 00 a2 94 ld [ %g2 + 0x294 ], %g1 ! 201da94 <rtems_panic_in_progress>
20034e8: 86 00 60 01 add %g1, 1, %g3
20034ec: 80 a0 60 00 cmp %g1, 0
20034f0: 02 80 00 07 be 200350c <rtems_verror+0x40> <== ALWAYS TAKEN
20034f4: c6 20 a2 94 st %g3, [ %g2 + 0x294 ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
20034f8: 03 00 80 77 sethi %hi(0x201dc00), %g1 <== NOT EXECUTED
20034fc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201dc10 <_Thread_Dispatch_disable_level><== NOT EXECUTED
2003500: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2003504: c4 20 60 10 st %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
return _Thread_Dispatch_disable_level;
2003508: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
200350c: 03 00 80 76 sethi %hi(0x201d800), %g1
2003510: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 201da94 <rtems_panic_in_progress>
2003514: 80 a0 60 02 cmp %g1, 2
2003518: 14 80 00 48 bg 2003638 <rtems_verror+0x16c> <== NEVER TAKEN
200351c: b0 10 20 00 clr %i0
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
2003520: 03 00 80 74 sethi %hi(0x201d000), %g1
2003524: c2 00 61 c8 ld [ %g1 + 0x1c8 ], %g1 ! 201d1c8 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
2003528: 37 1c 00 00 sethi %hi(0x70000000), %i3
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
200352c: d0 00 60 08 ld [ %g1 + 8 ], %o0
2003530: 40 00 31 e1 call 200fcb4 <fflush>
2003534: b6 2f 00 1b andn %i4, %i3, %i3
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
2003538: 03 10 00 00 sethi %hi(0x40000000), %g1
200353c: 80 8f 00 01 btst %i4, %g1
2003540: 02 80 00 05 be 2003554 <rtems_verror+0x88>
2003544: ba 10 20 00 clr %i5
local_errno = errno;
2003548: 40 00 30 cb call 200f874 <__errno>
200354c: 01 00 00 00 nop
2003550: 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);
2003554: 39 00 80 74 sethi %hi(0x201d000), %i4
2003558: c2 07 21 c8 ld [ %i4 + 0x1c8 ], %g1 ! 201d1c8 <_impure_ptr>
200355c: 92 10 00 19 mov %i1, %o1
2003560: d0 00 60 0c ld [ %g1 + 0xc ], %o0
2003564: 40 00 46 0b call 2014d90 <vfprintf>
2003568: 94 10 00 1a mov %i2, %o2
if (status)
200356c: 80 a6 e0 00 cmp %i3, 0
2003570: 02 80 00 0c be 20035a0 <rtems_verror+0xd4>
2003574: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
2003578: c2 07 21 c8 ld [ %i4 + 0x1c8 ], %g1
200357c: 90 10 00 1b mov %i3, %o0
2003580: 7f ff ff cd call 20034b4 <rtems_status_text>
2003584: f8 00 60 0c ld [ %g1 + 0xc ], %i4
2003588: 13 00 80 6c sethi %hi(0x201b000), %o1
200358c: 94 10 00 08 mov %o0, %o2
2003590: 92 12 63 28 or %o1, 0x328, %o1
2003594: 40 00 32 c1 call 2010098 <fprintf>
2003598: 90 10 00 1c mov %i4, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
200359c: b0 06 00 08 add %i0, %o0, %i0
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
20035a0: 80 a7 60 00 cmp %i5, 0
20035a4: 22 80 00 1c be,a 2003614 <rtems_verror+0x148>
20035a8: 3b 00 80 74 sethi %hi(0x201d000), %i5
if ((local_errno > 0) && *strerror(local_errno))
20035ac: 80 a7 60 00 cmp %i5, 0
20035b0: 04 80 00 11 ble 20035f4 <rtems_verror+0x128>
20035b4: 03 00 80 74 sethi %hi(0x201d000), %g1
20035b8: 40 00 36 3f call 2010eb4 <strerror>
20035bc: 90 10 00 1d mov %i5, %o0
20035c0: c2 4a 00 00 ldsb [ %o0 ], %g1
20035c4: 80 a0 60 00 cmp %g1, 0
20035c8: 02 80 00 0b be 20035f4 <rtems_verror+0x128> <== NEVER TAKEN
20035cc: 03 00 80 74 sethi %hi(0x201d000), %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
20035d0: c2 00 61 c8 ld [ %g1 + 0x1c8 ], %g1 ! 201d1c8 <_impure_ptr>
20035d4: 90 10 00 1d mov %i5, %o0
20035d8: 40 00 36 37 call 2010eb4 <strerror>
20035dc: f8 00 60 0c ld [ %g1 + 0xc ], %i4
20035e0: 13 00 80 6c sethi %hi(0x201b000), %o1
20035e4: 94 10 00 08 mov %o0, %o2
20035e8: 92 12 63 38 or %o1, 0x338, %o1
20035ec: 10 80 00 07 b 2003608 <rtems_verror+0x13c>
20035f0: 90 10 00 1c mov %i4, %o0
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
20035f4: c2 00 61 c8 ld [ %g1 + 0x1c8 ], %g1
20035f8: 13 00 80 6c sethi %hi(0x201b000), %o1
20035fc: d0 00 60 0c ld [ %g1 + 0xc ], %o0
2003600: 92 12 63 48 or %o1, 0x348, %o1
2003604: 94 10 00 1d mov %i5, %o2
2003608: 40 00 32 a4 call 2010098 <fprintf>
200360c: 3b 00 80 74 sethi %hi(0x201d000), %i5
2003610: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
2003614: c2 07 61 c8 ld [ %i5 + 0x1c8 ], %g1
2003618: 13 00 80 6c sethi %hi(0x201b000), %o1
200361c: d0 00 60 0c ld [ %g1 + 0xc ], %o0
2003620: 40 00 32 9e call 2010098 <fprintf>
2003624: 92 12 61 80 or %o1, 0x180, %o1
(void) fflush(stderr);
2003628: c2 07 61 c8 ld [ %i5 + 0x1c8 ], %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");
200362c: b0 06 00 08 add %i0, %o0, %i0
(void) fflush(stderr);
2003630: 40 00 31 a1 call 200fcb4 <fflush>
2003634: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
2003638: 81 c7 e0 08 ret
200363c: 81 e8 00 00 restore
02027a40 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
2027a40: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2027a44: 35 1f ff ff sethi %hi(0x7ffffc00), %i2
int sign = 0;
2027a48: b8 10 20 00 clr %i4
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2027a4c: b4 16 a3 ff or %i2, 0x3ff, %i2
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
2027a50: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2027a54: 23 00 81 ae sethi %hi(0x206b800), %l1
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
2027a58: 21 00 81 ae sethi %hi(0x206b800), %l0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2027a5c: c2 06 20 04 ld [ %i0 + 4 ], %g1
2027a60: 82 00 7f ff add %g1, -1, %g1
2027a64: 80 a0 60 00 cmp %g1, 0
2027a68: 16 80 00 07 bge 2027a84 <scanInt+0x44> <== ALWAYS TAKEN
2027a6c: c2 26 20 04 st %g1, [ %i0 + 4 ]
2027a70: d0 04 61 68 ld [ %l1 + 0x168 ], %o0 <== NOT EXECUTED
2027a74: 40 00 7e fe call 204766c <__srget_r> <== NOT EXECUTED
2027a78: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2027a7c: 10 80 00 06 b 2027a94 <scanInt+0x54> <== NOT EXECUTED
2027a80: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
2027a84: c2 06 00 00 ld [ %i0 ], %g1
2027a88: f6 08 40 00 ldub [ %g1 ], %i3
2027a8c: 82 00 60 01 inc %g1
2027a90: c2 26 00 00 st %g1, [ %i0 ]
if (c == ':')
2027a94: 80 a6 e0 3a cmp %i3, 0x3a
2027a98: 02 80 00 21 be 2027b1c <scanInt+0xdc>
2027a9c: 80 a7 20 00 cmp %i4, 0
break;
if (sign == 0) {
2027aa0: 12 80 00 08 bne 2027ac0 <scanInt+0x80>
2027aa4: c2 04 21 58 ld [ %l0 + 0x158 ], %g1
if (c == '-') {
2027aa8: 80 a6 e0 2d cmp %i3, 0x2d
2027aac: 12 80 00 05 bne 2027ac0 <scanInt+0x80>
2027ab0: b8 10 20 01 mov 1, %i4
sign = -1;
limit++;
2027ab4: b4 06 a0 01 inc %i2
continue;
2027ab8: 10 bf ff e9 b 2027a5c <scanInt+0x1c>
2027abc: b8 10 3f ff mov -1, %i4
}
sign = 1;
}
if (!isdigit(c))
2027ac0: 82 00 40 1b add %g1, %i3, %g1
2027ac4: c2 08 60 01 ldub [ %g1 + 1 ], %g1
2027ac8: 80 88 60 04 btst 4, %g1
2027acc: 02 80 00 1d be 2027b40 <scanInt+0x100>
2027ad0: 90 10 00 1a mov %i2, %o0
return 0;
d = c - '0';
if ((i > (limit / 10))
2027ad4: 40 00 ce 5f call 205b450 <.udiv>
2027ad8: 92 10 20 0a mov 0xa, %o1
2027adc: 80 a7 40 08 cmp %i5, %o0
2027ae0: 38 80 00 16 bgu,a 2027b38 <scanInt+0xf8>
2027ae4: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
2027ae8: 12 80 00 08 bne 2027b08 <scanInt+0xc8>
2027aec: b6 06 ff d0 add %i3, -48, %i3
2027af0: 90 10 00 1a mov %i2, %o0
2027af4: 40 00 cf 03 call 205b700 <.urem>
2027af8: 92 10 20 0a mov 0xa, %o1
2027afc: 80 a6 c0 08 cmp %i3, %o0
2027b00: 38 80 00 0e bgu,a 2027b38 <scanInt+0xf8> <== ALWAYS TAKEN
2027b04: b0 10 20 00 clr %i0
return 0;
i = i * 10 + d;
2027b08: 83 2f 60 01 sll %i5, 1, %g1
2027b0c: bb 2f 60 03 sll %i5, 3, %i5
2027b10: ba 00 40 1d add %g1, %i5, %i5
2027b14: 10 bf ff d2 b 2027a5c <scanInt+0x1c>
2027b18: ba 06 c0 1d add %i3, %i5, %i5
}
if (sign == 0)
2027b1c: 02 80 00 07 be 2027b38 <scanInt+0xf8> <== NEVER TAKEN
2027b20: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
2027b24: 90 10 00 1c mov %i4, %o0
2027b28: 92 10 00 1d mov %i5, %o1
2027b2c: 7f ff 6c a4 call 2002dbc <.umul>
2027b30: b0 10 20 01 mov 1, %i0
2027b34: d0 26 40 00 st %o0, [ %i1 ]
return 1;
2027b38: 81 c7 e0 08 ret
2027b3c: 81 e8 00 00 restore
2027b40: b0 10 20 00 clr %i0
}
2027b44: 81 c7 e0 08 ret
2027b48: 81 e8 00 00 restore
02027c44 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2027c44: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2027c48: 98 10 20 00 clr %o4
2027c4c: 90 10 00 18 mov %i0, %o0
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2027c50: ba 10 00 18 mov %i0, %i5
2027c54: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2027c58: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2027c5c: 92 10 00 19 mov %i1, %o1
2027c60: 94 07 a0 4c add %fp, 0x4c, %o2
2027c64: 96 07 a0 50 add %fp, 0x50, %o3
2027c68: 7f ff ff b9 call 2027b4c <scanString>
2027c6c: b0 10 20 00 clr %i0
2027c70: 80 a2 20 00 cmp %o0, 0
2027c74: 02 80 00 42 be 2027d7c <scangr+0x138>
2027c78: 90 10 00 1d mov %i5, %o0
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
2027c7c: 92 06 60 04 add %i1, 4, %o1
2027c80: 94 07 a0 4c add %fp, 0x4c, %o2
2027c84: 96 07 a0 50 add %fp, 0x50, %o3
2027c88: 7f ff ff b1 call 2027b4c <scanString>
2027c8c: 98 10 20 00 clr %o4
2027c90: 80 a2 20 00 cmp %o0, 0
2027c94: 02 80 00 3a be 2027d7c <scangr+0x138> <== NEVER TAKEN
2027c98: 90 10 00 1d mov %i5, %o0
|| !scanInt(fp, &grgid)
2027c9c: 7f ff ff 69 call 2027a40 <scanInt>
2027ca0: 92 07 bf f8 add %fp, -8, %o1
2027ca4: 80 a2 20 00 cmp %o0, 0
2027ca8: 02 80 00 35 be 2027d7c <scangr+0x138> <== NEVER TAKEN
2027cac: 90 10 00 1d mov %i5, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
2027cb0: 92 07 bf fc add %fp, -4, %o1
2027cb4: 94 07 a0 4c add %fp, 0x4c, %o2
2027cb8: 96 07 a0 50 add %fp, 0x50, %o3
2027cbc: 7f ff ff a4 call 2027b4c <scanString>
2027cc0: 98 10 20 01 mov 1, %o4
2027cc4: 80 a2 20 00 cmp %o0, 0
2027cc8: 02 80 00 2d be 2027d7c <scangr+0x138> <== NEVER TAKEN
2027ccc: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027cd0: 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;
2027cd4: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027cd8: 84 10 00 03 mov %g3, %g2
2027cdc: 10 80 00 05 b 2027cf0 <scangr+0xac>
2027ce0: 82 10 20 01 mov 1, %g1
2027ce4: 84 00 a0 01 inc %g2
if(*cp == ',')
memcount++;
2027ce8: 80 a0 00 04 cmp %g0, %g4
2027cec: 82 60 7f ff subx %g1, -1, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027cf0: c8 48 80 00 ldsb [ %g2 ], %g4
2027cf4: 80 a1 20 00 cmp %g4, 0
2027cf8: 32 bf ff fb bne,a 2027ce4 <scangr+0xa0>
2027cfc: 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))
2027d00: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
2027d04: 83 28 60 02 sll %g1, 2, %g1
2027d08: 82 00 60 13 add %g1, 0x13, %g1
2027d0c: 80 a0 80 01 cmp %g2, %g1
2027d10: 0a 80 00 1b bcs 2027d7c <scangr+0x138> <== NEVER TAKEN
2027d14: b0 10 20 00 clr %i0
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
2027d18: 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++) {
2027d1c: 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);
2027d20: 82 00 60 0f add %g1, 0xf, %g1
2027d24: 82 08 7f f0 and %g1, -16, %g1
2027d28: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
2027d2c: c6 20 40 00 st %g3, [ %g1 ]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027d30: 10 80 00 0b b 2027d5c <scangr+0x118>
2027d34: c2 07 bf fc ld [ %fp + -4 ], %g1
if(*cp == ',') {
2027d38: 32 80 00 09 bne,a 2027d5c <scangr+0x118>
2027d3c: 82 00 60 01 inc %g1
*cp = '\0';
2027d40: c0 28 40 00 clrb [ %g1 ]
grp->gr_mem[memcount++] = cp + 1;
2027d44: c8 06 60 0c ld [ %i1 + 0xc ], %g4
2027d48: 87 28 a0 02 sll %g2, 2, %g3
}
/*
* Extract a single group record from the database
*/
static int scangr(
2027d4c: ba 00 60 01 add %g1, 1, %i5
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
2027d50: 84 00 a0 01 inc %g2
2027d54: fa 21 00 03 st %i5, [ %g4 + %g3 ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027d58: 82 00 60 01 inc %g1
2027d5c: c6 48 40 00 ldsb [ %g1 ], %g3
2027d60: 80 a0 e0 00 cmp %g3, 0
2027d64: 12 bf ff f5 bne 2027d38 <scangr+0xf4>
2027d68: 80 a0 e0 2c cmp %g3, 0x2c
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
2027d6c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2027d70: 85 28 a0 02 sll %g2, 2, %g2
return 1;
2027d74: b0 10 20 01 mov 1, %i0
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
2027d78: c0 20 40 02 clr [ %g1 + %g2 ]
return 1;
}
2027d7c: 81 c7 e0 08 ret
2027d80: 81 e8 00 00 restore
02027d84 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2027d84: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2027d88: 98 10 20 00 clr %o4
2027d8c: 90 10 00 18 mov %i0, %o0
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2027d90: ba 10 00 18 mov %i0, %i5
2027d94: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2027d98: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2027d9c: 92 10 00 19 mov %i1, %o1
2027da0: 94 07 a0 4c add %fp, 0x4c, %o2
2027da4: 96 07 a0 50 add %fp, 0x50, %o3
2027da8: 7f ff ff 69 call 2027b4c <scanString>
2027dac: b0 10 20 00 clr %i0
2027db0: 80 a2 20 00 cmp %o0, 0
2027db4: 02 80 00 38 be 2027e94 <scanpw+0x110>
2027db8: 90 10 00 1d mov %i5, %o0
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
2027dbc: 92 06 60 04 add %i1, 4, %o1
2027dc0: 94 07 a0 4c add %fp, 0x4c, %o2
2027dc4: 96 07 a0 50 add %fp, 0x50, %o3
2027dc8: 7f ff ff 61 call 2027b4c <scanString>
2027dcc: 98 10 20 00 clr %o4
2027dd0: 80 a2 20 00 cmp %o0, 0
2027dd4: 02 80 00 30 be 2027e94 <scanpw+0x110> <== NEVER TAKEN
2027dd8: 90 10 00 1d mov %i5, %o0
|| !scanInt(fp, &pwuid)
2027ddc: 7f ff ff 19 call 2027a40 <scanInt>
2027de0: 92 07 bf f8 add %fp, -8, %o1
2027de4: 80 a2 20 00 cmp %o0, 0
2027de8: 02 80 00 2b be 2027e94 <scanpw+0x110>
2027dec: 90 10 00 1d mov %i5, %o0
|| !scanInt(fp, &pwgid)
2027df0: 7f ff ff 14 call 2027a40 <scanInt>
2027df4: 92 07 bf fc add %fp, -4, %o1
2027df8: 80 a2 20 00 cmp %o0, 0
2027dfc: 02 80 00 26 be 2027e94 <scanpw+0x110>
2027e00: 90 10 00 1d mov %i5, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
2027e04: 92 06 60 0c add %i1, 0xc, %o1
2027e08: 94 07 a0 4c add %fp, 0x4c, %o2
2027e0c: 96 07 a0 50 add %fp, 0x50, %o3
2027e10: 7f ff ff 4f call 2027b4c <scanString>
2027e14: 98 10 20 00 clr %o4
2027e18: 80 a2 20 00 cmp %o0, 0
2027e1c: 02 80 00 1e be 2027e94 <scanpw+0x110> <== NEVER TAKEN
2027e20: 90 10 00 1d mov %i5, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
2027e24: 92 06 60 10 add %i1, 0x10, %o1
2027e28: 94 07 a0 4c add %fp, 0x4c, %o2
2027e2c: 96 07 a0 50 add %fp, 0x50, %o3
2027e30: 7f ff ff 47 call 2027b4c <scanString>
2027e34: 98 10 20 00 clr %o4
2027e38: 80 a2 20 00 cmp %o0, 0
2027e3c: 02 80 00 16 be 2027e94 <scanpw+0x110> <== NEVER TAKEN
2027e40: 90 10 00 1d mov %i5, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
2027e44: 92 06 60 14 add %i1, 0x14, %o1
2027e48: 94 07 a0 4c add %fp, 0x4c, %o2
2027e4c: 96 07 a0 50 add %fp, 0x50, %o3
2027e50: 7f ff ff 3f call 2027b4c <scanString>
2027e54: 98 10 20 00 clr %o4
2027e58: 80 a2 20 00 cmp %o0, 0
2027e5c: 02 80 00 0e be 2027e94 <scanpw+0x110> <== NEVER TAKEN
2027e60: 90 10 00 1d mov %i5, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
2027e64: 92 06 60 18 add %i1, 0x18, %o1
2027e68: 94 07 a0 4c add %fp, 0x4c, %o2
2027e6c: 96 07 a0 50 add %fp, 0x50, %o3
2027e70: 7f ff ff 37 call 2027b4c <scanString>
2027e74: 98 10 20 01 mov 1, %o4
2027e78: 80 a2 20 00 cmp %o0, 0
2027e7c: 02 80 00 06 be 2027e94 <scanpw+0x110>
2027e80: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
2027e84: b0 10 20 01 mov 1, %i0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
2027e88: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
2027e8c: c2 07 bf fc ld [ %fp + -4 ], %g1
2027e90: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
2027e94: 81 c7 e0 08 ret
2027e98: 81 e8 00 00 restore
02007ecc <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
2007ecc: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007ed0: 80 a6 20 04 cmp %i0, 4
2007ed4: 18 80 00 06 bgu 2007eec <sched_get_priority_max+0x20>
2007ed8: 82 10 20 01 mov 1, %g1
2007edc: b1 28 40 18 sll %g1, %i0, %i0
2007ee0: 80 8e 20 17 btst 0x17, %i0
2007ee4: 12 80 00 08 bne 2007f04 <sched_get_priority_max+0x38> <== ALWAYS TAKEN
2007ee8: 03 00 80 86 sethi %hi(0x2021800), %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007eec: 40 00 21 42 call 20103f4 <__errno>
2007ef0: b0 10 3f ff mov -1, %i0
2007ef4: 82 10 20 16 mov 0x16, %g1
2007ef8: c2 22 00 00 st %g1, [ %o0 ]
2007efc: 81 c7 e0 08 ret
2007f00: 81 e8 00 00 restore
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
2007f04: f0 08 63 64 ldub [ %g1 + 0x364 ], %i0
}
2007f08: 81 c7 e0 08 ret
2007f0c: 91 ee 3f ff restore %i0, -1, %o0
02007f10 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
2007f10: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007f14: 80 a6 20 04 cmp %i0, 4
2007f18: 18 80 00 06 bgu 2007f30 <sched_get_priority_min+0x20>
2007f1c: 82 10 20 01 mov 1, %g1
2007f20: 83 28 40 18 sll %g1, %i0, %g1
2007f24: 80 88 60 17 btst 0x17, %g1
2007f28: 12 80 00 06 bne 2007f40 <sched_get_priority_min+0x30> <== ALWAYS TAKEN
2007f2c: b0 10 20 01 mov 1, %i0
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007f30: 40 00 21 31 call 20103f4 <__errno>
2007f34: b0 10 3f ff mov -1, %i0
2007f38: 82 10 20 16 mov 0x16, %g1
2007f3c: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
2007f40: 81 c7 e0 08 ret
2007f44: 81 e8 00 00 restore
02007f48 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
2007f48: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
2007f4c: 80 a6 20 00 cmp %i0, 0
2007f50: 02 80 00 0b be 2007f7c <sched_rr_get_interval+0x34> <== NEVER TAKEN
2007f54: 80 a6 60 00 cmp %i1, 0
2007f58: 7f ff ef 7e call 2003d50 <getpid>
2007f5c: 01 00 00 00 nop
2007f60: 80 a6 00 08 cmp %i0, %o0
2007f64: 02 80 00 06 be 2007f7c <sched_rr_get_interval+0x34>
2007f68: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
2007f6c: 40 00 21 22 call 20103f4 <__errno>
2007f70: 01 00 00 00 nop
2007f74: 10 80 00 07 b 2007f90 <sched_rr_get_interval+0x48>
2007f78: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
if ( !interval )
2007f7c: 12 80 00 08 bne 2007f9c <sched_rr_get_interval+0x54>
2007f80: 03 00 80 8a sethi %hi(0x2022800), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2007f84: 40 00 21 1c call 20103f4 <__errno>
2007f88: 01 00 00 00 nop
2007f8c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007f90: c2 22 00 00 st %g1, [ %o0 ]
2007f94: 81 c7 e0 08 ret
2007f98: 91 e8 3f ff restore %g0, -1, %o0
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
2007f9c: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
2007fa0: 92 10 00 19 mov %i1, %o1
2007fa4: 40 00 0e a7 call 200ba40 <_Timespec_From_ticks>
2007fa8: b0 10 20 00 clr %i0
return 0;
}
2007fac: 81 c7 e0 08 ret
2007fb0: 81 e8 00 00 restore
02008660 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
2008660: 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++;
2008664: 03 00 80 89 sethi %hi(0x2022400), %g1
2008668: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2022730 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
200866c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2008670: 84 00 a0 01 inc %g2
2008674: c4 20 63 30 st %g2, [ %g1 + 0x330 ]
return _Thread_Dispatch_disable_level;
2008678: c2 00 63 30 ld [ %g1 + 0x330 ], %g1
200867c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2008680: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2008684: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
2008688: b6 8e 62 00 andcc %i1, 0x200, %i3
200868c: 02 80 00 05 be 20086a0 <sem_open+0x40>
2008690: ba 10 20 00 clr %i5
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
2008694: fa 07 a0 50 ld [ %fp + 0x50 ], %i5
2008698: 82 07 a0 54 add %fp, 0x54, %g1
200869c: 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 );
20086a0: 39 00 80 8a sethi %hi(0x2022800), %i4
20086a4: 92 10 00 18 mov %i0, %o1
20086a8: 90 17 22 30 or %i4, 0x230, %o0
20086ac: 94 07 bf f0 add %fp, -16, %o2
20086b0: 7f ff fe 82 call 20080b8 <_POSIX_Name_to_id>
20086b4: 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 ) {
20086b8: b4 92 20 00 orcc %o0, 0, %i2
20086bc: 22 80 00 0e be,a 20086f4 <sem_open+0x94>
20086c0: 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) ) ) {
20086c4: 80 a6 a0 02 cmp %i2, 2
20086c8: 12 80 00 04 bne 20086d8 <sem_open+0x78>
20086cc: 80 a6 e0 00 cmp %i3, 0
20086d0: 12 80 00 20 bne 2008750 <sem_open+0xf0>
20086d4: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
20086d8: 40 00 0d df call 200be54 <_Thread_Enable_dispatch>
20086dc: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
20086e0: 40 00 24 41 call 20117e4 <__errno>
20086e4: 01 00 00 00 nop
20086e8: f4 22 00 00 st %i2, [ %o0 ]
20086ec: 81 c7 e0 08 ret
20086f0: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
20086f4: 80 a6 6a 00 cmp %i1, 0xa00
20086f8: 12 80 00 0a bne 2008720 <sem_open+0xc0>
20086fc: d2 07 bf f0 ld [ %fp + -16 ], %o1
_Thread_Enable_dispatch();
2008700: 40 00 0d d5 call 200be54 <_Thread_Enable_dispatch>
2008704: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
2008708: 40 00 24 37 call 20117e4 <__errno>
200870c: 01 00 00 00 nop
2008710: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
2008714: c2 22 00 00 st %g1, [ %o0 ]
2008718: 81 c7 e0 08 ret
200871c: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
2008720: 94 07 bf f8 add %fp, -8, %o2
2008724: 40 00 09 df call 200aea0 <_Objects_Get>
2008728: 90 17 22 30 or %i4, 0x230, %o0
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
200872c: 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 );
2008730: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
2008734: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
2008738: 40 00 0d c7 call 200be54 <_Thread_Enable_dispatch>
200873c: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
2008740: 40 00 0d c5 call 200be54 <_Thread_Enable_dispatch>
2008744: 01 00 00 00 nop
goto return_id;
2008748: 10 80 00 0d b 200877c <sem_open+0x11c>
200874c: 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(
2008750: 96 10 00 1d mov %i5, %o3
2008754: 90 10 00 18 mov %i0, %o0
2008758: 94 10 20 00 clr %o2
200875c: 40 00 19 bd call 200ee50 <_POSIX_Semaphore_Create_support>
2008760: 98 07 bf f4 add %fp, -12, %o4
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
2008764: 40 00 0d bc call 200be54 <_Thread_Enable_dispatch>
2008768: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
200876c: 80 a7 7f ff cmp %i5, -1
2008770: 02 bf ff ea be 2008718 <sem_open+0xb8> <== NEVER TAKEN
2008774: b0 10 3f ff mov -1, %i0
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;
2008778: f0 07 bf f4 ld [ %fp + -12 ], %i0
200877c: b0 06 20 08 add %i0, 8, %i0
#endif
}
2008780: 81 c7 e0 08 ret
2008784: 81 e8 00 00 restore
02007ed8 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
2007ed8: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
2007edc: 90 96 a0 00 orcc %i2, 0, %o0
2007ee0: 02 80 00 09 be 2007f04 <sigaction+0x2c>
2007ee4: 83 2e 20 02 sll %i0, 2, %g1
*oact = _POSIX_signals_Vectors[ sig ];
2007ee8: 85 2e 20 04 sll %i0, 4, %g2
2007eec: 82 20 80 01 sub %g2, %g1, %g1
2007ef0: 13 00 80 85 sethi %hi(0x2021400), %o1
2007ef4: 94 10 20 0c mov 0xc, %o2
2007ef8: 92 12 63 a0 or %o1, 0x3a0, %o1
2007efc: 40 00 25 03 call 2011308 <memcpy>
2007f00: 92 02 40 01 add %o1, %g1, %o1
if ( !sig )
2007f04: 80 a6 20 00 cmp %i0, 0
2007f08: 02 80 00 09 be 2007f2c <sigaction+0x54>
2007f0c: 01 00 00 00 nop
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
2007f10: 82 06 3f ff add %i0, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
2007f14: 80 a0 60 1f cmp %g1, 0x1f
2007f18: 18 80 00 05 bgu 2007f2c <sigaction+0x54>
2007f1c: 01 00 00 00 nop
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
2007f20: 80 a6 20 09 cmp %i0, 9
2007f24: 12 80 00 08 bne 2007f44 <sigaction+0x6c>
2007f28: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
2007f2c: 40 00 22 97 call 2010988 <__errno>
2007f30: 01 00 00 00 nop
2007f34: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007f38: c2 22 00 00 st %g1, [ %o0 ]
2007f3c: 10 80 00 20 b 2007fbc <sigaction+0xe4>
2007f40: 82 10 3f ff mov -1, %g1
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
2007f44: 02 80 00 1e be 2007fbc <sigaction+0xe4> <== NEVER TAKEN
2007f48: 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 );
2007f4c: 7f ff ea 90 call 200298c <sparc_disable_interrupts>
2007f50: 01 00 00 00 nop
2007f54: ba 10 00 08 mov %o0, %i5
if ( act->sa_handler == SIG_DFL ) {
2007f58: c2 06 60 08 ld [ %i1 + 8 ], %g1
2007f5c: 39 00 80 85 sethi %hi(0x2021400), %i4
2007f60: 80 a0 60 00 cmp %g1, 0
2007f64: 12 80 00 0a bne 2007f8c <sigaction+0xb4>
2007f68: b8 17 23 a0 or %i4, 0x3a0, %i4
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
2007f6c: 83 2e 20 02 sll %i0, 2, %g1
2007f70: 13 00 80 7c sethi %hi(0x201f000), %o1
2007f74: b1 2e 20 04 sll %i0, 4, %i0
2007f78: 92 12 61 d4 or %o1, 0x1d4, %o1
2007f7c: b0 26 00 01 sub %i0, %g1, %i0
2007f80: 90 07 00 18 add %i4, %i0, %o0
2007f84: 10 80 00 09 b 2007fa8 <sigaction+0xd0>
2007f88: 92 02 40 18 add %o1, %i0, %o1
} else {
_POSIX_signals_Clear_process_signals( sig );
2007f8c: 40 00 16 f9 call 200db70 <_POSIX_signals_Clear_process_signals>
2007f90: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
2007f94: 83 2e 20 02 sll %i0, 2, %g1
2007f98: 92 10 00 19 mov %i1, %o1
2007f9c: b1 2e 20 04 sll %i0, 4, %i0
2007fa0: 90 26 00 01 sub %i0, %g1, %o0
2007fa4: 90 07 00 08 add %i4, %o0, %o0
2007fa8: 40 00 24 d8 call 2011308 <memcpy>
2007fac: 94 10 20 0c mov 0xc, %o2
}
_ISR_Enable( level );
2007fb0: 7f ff ea 7b call 200299c <sparc_enable_interrupts>
2007fb4: 90 10 00 1d mov %i5, %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;
2007fb8: 82 10 20 00 clr %g1
}
2007fbc: 81 c7 e0 08 ret
2007fc0: 91 e8 00 01 restore %g0, %g1, %o0
0200841c <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
200841c: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
2008420: ba 96 20 00 orcc %i0, 0, %i5
2008424: 02 80 00 0f be 2008460 <sigtimedwait+0x44>
2008428: 01 00 00 00 nop
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
200842c: 80 a6 a0 00 cmp %i2, 0
2008430: 02 80 00 12 be 2008478 <sigtimedwait+0x5c>
2008434: a0 10 20 00 clr %l0
if ( !_Timespec_Is_valid( timeout ) )
2008438: 40 00 0e e8 call 200bfd8 <_Timespec_Is_valid>
200843c: 90 10 00 1a mov %i2, %o0
2008440: 80 8a 20 ff btst 0xff, %o0
2008444: 02 80 00 07 be 2008460 <sigtimedwait+0x44>
2008448: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
200844c: 40 00 0e f4 call 200c01c <_Timespec_To_ticks>
2008450: 90 10 00 1a mov %i2, %o0
if ( !interval )
2008454: a0 92 20 00 orcc %o0, 0, %l0
2008458: 12 80 00 09 bne 200847c <sigtimedwait+0x60> <== ALWAYS TAKEN
200845c: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
2008460: 40 00 23 16 call 20110b8 <__errno>
2008464: b0 10 3f ff mov -1, %i0
2008468: 82 10 20 16 mov 0x16, %g1
200846c: c2 22 00 00 st %g1, [ %o0 ]
2008470: 81 c7 e0 08 ret
2008474: 81 e8 00 00 restore
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
2008478: 80 a6 60 00 cmp %i1, 0
200847c: 22 80 00 02 be,a 2008484 <sigtimedwait+0x68>
2008480: b2 07 bf f4 add %fp, -12, %i1
the_thread = _Thread_Executing;
2008484: 31 00 80 87 sethi %hi(0x2021c00), %i0
2008488: b0 16 20 20 or %i0, 0x20, %i0 ! 2021c20 <_Per_CPU_Information>
200848c: f4 06 20 0c ld [ %i0 + 0xc ], %i2
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
2008490: 7f ff ea 1a call 2002cf8 <sparc_disable_interrupts>
2008494: f6 06 a1 5c ld [ %i2 + 0x15c ], %i3
2008498: b8 10 00 08 mov %o0, %i4
if ( *set & api->signals_pending ) {
200849c: c4 07 40 00 ld [ %i5 ], %g2
20084a0: c2 06 e0 d4 ld [ %i3 + 0xd4 ], %g1
20084a4: 80 88 80 01 btst %g2, %g1
20084a8: 22 80 00 13 be,a 20084f4 <sigtimedwait+0xd8>
20084ac: 03 00 80 87 sethi %hi(0x2021c00), %g1
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
20084b0: 7f ff ff c3 call 20083bc <_POSIX_signals_Get_lowest>
20084b4: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals(
20084b8: 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 );
20084bc: 92 10 00 08 mov %o0, %o1
20084c0: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
20084c4: 96 10 20 00 clr %o3
20084c8: 90 10 00 1b mov %i3, %o0
20084cc: 40 00 17 c7 call 200e3e8 <_POSIX_signals_Clear_signals>
20084d0: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
20084d4: 7f ff ea 0d call 2002d08 <sparc_enable_interrupts>
20084d8: 90 10 00 1c mov %i4, %o0
the_info->si_code = SI_USER;
20084dc: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
20084e0: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
20084e4: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
20084e8: f0 06 40 00 ld [ %i1 ], %i0
20084ec: 81 c7 e0 08 ret
20084f0: 81 e8 00 00 restore
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
20084f4: c2 00 62 74 ld [ %g1 + 0x274 ], %g1
20084f8: 80 88 80 01 btst %g2, %g1
20084fc: 22 80 00 13 be,a 2008548 <sigtimedwait+0x12c>
2008500: 82 10 3f ff mov -1, %g1
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008504: 7f ff ff ae call 20083bc <_POSIX_signals_Get_lowest>
2008508: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
200850c: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008510: b0 10 00 08 mov %o0, %i0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
2008514: 96 10 20 01 mov 1, %o3
2008518: 90 10 00 1b mov %i3, %o0
200851c: 92 10 00 18 mov %i0, %o1
2008520: 40 00 17 b2 call 200e3e8 <_POSIX_signals_Clear_signals>
2008524: 98 10 20 00 clr %o4
_ISR_Enable( level );
2008528: 7f ff e9 f8 call 2002d08 <sparc_enable_interrupts>
200852c: 90 10 00 1c mov %i4, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
2008530: 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;
2008534: f0 26 40 00 st %i0, [ %i1 ]
the_info->si_code = SI_USER;
2008538: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
200853c: c0 26 60 08 clr [ %i1 + 8 ]
return signo;
2008540: 81 c7 e0 08 ret
2008544: 81 e8 00 00 restore
}
the_info->si_signo = -1;
2008548: 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++;
200854c: 03 00 80 85 sethi %hi(0x2021400), %g1
2008550: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 20216e0 <_Thread_Dispatch_disable_level>
2008554: 84 00 a0 01 inc %g2
2008558: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
return _Thread_Dispatch_disable_level;
200855c: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
2008560: 82 10 20 04 mov 4, %g1
2008564: c2 26 a0 34 st %g1, [ %i2 + 0x34 ]
the_thread->Wait.option = *set;
2008568: c2 07 40 00 ld [ %i5 ], %g1
the_thread->Wait.return_argument = the_info;
200856c: f2 26 a0 28 st %i1, [ %i2 + 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;
2008570: c2 26 a0 30 st %g1, [ %i2 + 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;
2008574: b8 10 20 01 mov 1, %i4
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
2008578: 23 00 80 87 sethi %hi(0x2021c00), %l1
200857c: a2 14 62 0c or %l1, 0x20c, %l1 ! 2021e0c <_POSIX_signals_Wait_queue>
2008580: e2 26 a0 44 st %l1, [ %i2 + 0x44 ]
2008584: f8 24 60 30 st %i4, [ %l1 + 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 );
2008588: 7f ff e9 e0 call 2002d08 <sparc_enable_interrupts>
200858c: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
2008590: 90 10 00 11 mov %l1, %o0
2008594: 92 10 00 10 mov %l0, %o1
2008598: 15 00 80 2f sethi %hi(0x200bc00), %o2
200859c: 40 00 0d 38 call 200ba7c <_Thread_queue_Enqueue_with_handler>
20085a0: 94 12 a1 e8 or %o2, 0x1e8, %o2 ! 200bde8 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
20085a4: 40 00 0b f7 call 200b580 <_Thread_Enable_dispatch>
20085a8: 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 );
20085ac: d2 06 40 00 ld [ %i1 ], %o1
20085b0: 90 10 00 1b mov %i3, %o0
20085b4: 94 10 00 19 mov %i1, %o2
20085b8: 96 10 20 00 clr %o3
20085bc: 40 00 17 8b call 200e3e8 <_POSIX_signals_Clear_signals>
20085c0: 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)
20085c4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20085c8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20085cc: 80 a0 60 04 cmp %g1, 4
20085d0: 12 80 00 09 bne 20085f4 <sigtimedwait+0x1d8>
20085d4: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
20085d8: f0 06 40 00 ld [ %i1 ], %i0
20085dc: 82 06 3f ff add %i0, -1, %g1
20085e0: b9 2f 00 01 sll %i4, %g1, %i4
20085e4: c2 07 40 00 ld [ %i5 ], %g1
20085e8: 80 8f 00 01 btst %i4, %g1
20085ec: 12 80 00 08 bne 200860c <sigtimedwait+0x1f0>
20085f0: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
20085f4: 40 00 22 b1 call 20110b8 <__errno>
20085f8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff>
20085fc: 03 00 80 87 sethi %hi(0x2021c00), %g1
2008600: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 ! 2021c2c <_Per_CPU_Information+0xc>
2008604: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008608: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
return the_info->si_signo;
}
200860c: 81 c7 e0 08 ret
2008610: 81 e8 00 00 restore
0200a330 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
200a330: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
200a334: 92 10 20 00 clr %o1
200a338: 90 10 00 18 mov %i0, %o0
200a33c: 7f ff ff 7b call 200a128 <sigtimedwait>
200a340: 94 10 20 00 clr %o2
if ( status != -1 ) {
200a344: 80 a2 3f ff cmp %o0, -1
200a348: 02 80 00 07 be 200a364 <sigwait+0x34>
200a34c: 80 a6 60 00 cmp %i1, 0
if ( sig )
200a350: 02 80 00 03 be 200a35c <sigwait+0x2c> <== NEVER TAKEN
200a354: b0 10 20 00 clr %i0
*sig = status;
200a358: d0 26 40 00 st %o0, [ %i1 ]
200a35c: 81 c7 e0 08 ret
200a360: 81 e8 00 00 restore
return 0;
}
return errno;
200a364: 40 00 21 e2 call 2012aec <__errno>
200a368: 01 00 00 00 nop
200a36c: f0 02 00 00 ld [ %o0 ], %i0
}
200a370: 81 c7 e0 08 ret
200a374: 81 e8 00 00 restore
020064ac <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
20064ac: 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)) {
20064b0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
20064b4: 80 88 6e 78 btst 0xe78, %g1
20064b8: 02 80 00 0d be 20064ec <siproc+0x40> <== NEVER TAKEN
20064bc: 94 10 20 00 clr %o2
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20064c0: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
20064c4: 40 00 04 ed call 2007878 <rtems_semaphore_obtain>
20064c8: 92 10 20 00 clr %o1
i = iproc (c, tty);
20064cc: 90 10 00 18 mov %i0, %o0
20064d0: 7f ff ff 85 call 20062e4 <iproc>
20064d4: 92 10 00 19 mov %i1, %o1
20064d8: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
20064dc: 40 00 05 31 call 20079a0 <rtems_semaphore_release>
20064e0: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
}
else {
i = iproc (c, tty);
}
return i;
}
20064e4: 81 c7 e0 08 ret
20064e8: 81 e8 00 00 restore
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
20064ec: 7f ff ff 7e call 20062e4 <iproc> <== NOT EXECUTED
20064f0: 81 e8 00 00 restore <== NOT EXECUTED
020060e0 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
20060e0: 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;
20060e4: c4 06 21 54 ld [ %i0 + 0x154 ], %g2
if ( this_reent ) {
20060e8: 80 a0 a0 00 cmp %g2, 0
20060ec: 02 80 00 0c be 200611c <sync_per_thread+0x3c> <== NEVER TAKEN
20060f0: 3b 00 80 7e sethi %hi(0x201f800), %i5
current_reent = _Thread_Executing->libc_reent;
20060f4: ba 17 62 50 or %i5, 0x250, %i5 ! 201fa50 <_Per_CPU_Information>
20060f8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
20060fc: 13 00 80 18 sethi %hi(0x2006000), %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;
2006100: f8 00 61 54 ld [ %g1 + 0x154 ], %i4
_Thread_Executing->libc_reent = this_reent;
2006104: c4 20 61 54 st %g2, [ %g1 + 0x154 ]
_fwalk (t->libc_reent, sync_wrapper);
2006108: d0 06 21 54 ld [ %i0 + 0x154 ], %o0
200610c: 40 00 2d a1 call 2011790 <_fwalk>
2006110: 92 12 61 24 or %o1, 0x124, %o1
_Thread_Executing->libc_reent = current_reent;
2006114: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2006118: f8 20 61 54 st %i4, [ %g1 + 0x154 ]
200611c: 81 c7 e0 08 ret
2006120: 81 e8 00 00 restore
02007190 <sysconf>:
*/
long sysconf(
int name
)
{
2007190: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
2007194: 80 a6 20 02 cmp %i0, 2
2007198: 12 80 00 09 bne 20071bc <sysconf+0x2c>
200719c: 03 00 80 74 sethi %hi(0x201d000), %g1
return (TOD_MICROSECONDS_PER_SECOND /
20071a0: 03 00 80 74 sethi %hi(0x201d000), %g1
20071a4: d2 00 61 ac ld [ %g1 + 0x1ac ], %o1 ! 201d1ac <Configuration+0x10>
20071a8: 11 00 03 d0 sethi %hi(0xf4000), %o0
20071ac: 40 00 46 69 call 2018b50 <.udiv>
20071b0: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
20071b4: 81 c7 e0 08 ret
20071b8: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
20071bc: 80 a6 20 04 cmp %i0, 4
20071c0: 02 80 00 13 be 200720c <sysconf+0x7c>
20071c4: d0 00 62 f0 ld [ %g1 + 0x2f0 ], %o0
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
20071c8: 80 a6 20 33 cmp %i0, 0x33
20071cc: 02 80 00 10 be 200720c <sysconf+0x7c>
20071d0: 90 10 24 00 mov 0x400, %o0
return 1024;
if ( name == _SC_PAGESIZE )
20071d4: 80 a6 20 08 cmp %i0, 8
20071d8: 02 80 00 0d be 200720c <sysconf+0x7c>
20071dc: 11 00 00 04 sethi %hi(0x1000), %o0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
20071e0: 80 a6 20 4f cmp %i0, 0x4f
20071e4: 02 80 00 0a be 200720c <sysconf+0x7c> <== NEVER TAKEN
20071e8: 90 10 20 20 mov 0x20, %o0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
20071ec: 80 a6 22 03 cmp %i0, 0x203
20071f0: 02 80 00 07 be 200720c <sysconf+0x7c> <== NEVER TAKEN
20071f4: 90 10 20 00 clr %o0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
20071f8: 40 00 22 6e call 200fbb0 <__errno>
20071fc: 01 00 00 00 nop
2007200: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007204: c2 22 00 00 st %g1, [ %o0 ]
2007208: 90 10 3f ff mov -1, %o0
}
200720c: b0 10 00 08 mov %o0, %i0
2007210: 81 c7 e0 08 ret
2007214: 81 e8 00 00 restore
02013038 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
2013038: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
201303c: 80 a6 60 00 cmp %i1, 0
2013040: 02 80 00 10 be 2013080 <tcsetattr+0x48>
2013044: 80 a6 60 01 cmp %i1, 1
2013048: 02 80 00 08 be 2013068 <tcsetattr+0x30>
201304c: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
2013050: 40 00 10 aa call 20172f8 <__errno>
2013054: b0 10 3f ff mov -1, %i0
2013058: 82 10 20 86 mov 0x86, %g1
201305c: c2 22 00 00 st %g1, [ %o0 ]
2013060: 81 c7 e0 08 ret
2013064: 81 e8 00 00 restore
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
2013068: 92 10 20 03 mov 3, %o1
201306c: 40 00 0e 0c call 201689c <ioctl>
2013070: 94 10 20 00 clr %o2
2013074: 80 a2 20 00 cmp %o0, 0
2013078: 26 80 00 04 bl,a 2013088 <tcsetattr+0x50> <== NEVER TAKEN
201307c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
2013080: 40 00 0e 07 call 201689c <ioctl>
2013084: 93 e8 20 02 restore %g0, 2, %o1
}
}
2013088: 81 c7 e0 08 ret <== NOT EXECUTED
201308c: 81 e8 00 00 restore <== NOT EXECUTED
02008788 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
2008788: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
200878c: 80 a6 20 01 cmp %i0, 1
2008790: 12 80 00 15 bne 20087e4 <timer_create+0x5c>
2008794: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
2008798: 80 a6 a0 00 cmp %i2, 0
200879c: 02 80 00 12 be 20087e4 <timer_create+0x5c>
20087a0: 01 00 00 00 nop
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
20087a4: 80 a6 60 00 cmp %i1, 0
20087a8: 02 80 00 13 be 20087f4 <timer_create+0x6c>
20087ac: 03 00 80 89 sethi %hi(0x2022400), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
20087b0: c2 06 40 00 ld [ %i1 ], %g1
20087b4: 82 00 7f ff add %g1, -1, %g1
20087b8: 80 a0 60 01 cmp %g1, 1
20087bc: 18 80 00 0a bgu 20087e4 <timer_create+0x5c> <== NEVER TAKEN
20087c0: 01 00 00 00 nop
( 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 )
20087c4: c2 06 60 04 ld [ %i1 + 4 ], %g1
20087c8: 80 a0 60 00 cmp %g1, 0
20087cc: 02 80 00 06 be 20087e4 <timer_create+0x5c> <== NEVER TAKEN
20087d0: 01 00 00 00 nop
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
20087d4: 82 00 7f ff add %g1, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
20087d8: 80 a0 60 1f cmp %g1, 0x1f
20087dc: 28 80 00 06 bleu,a 20087f4 <timer_create+0x6c> <== ALWAYS TAKEN
20087e0: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
20087e4: 40 00 24 00 call 20117e4 <__errno>
20087e8: 01 00 00 00 nop
20087ec: 10 80 00 11 b 2008830 <timer_create+0xa8>
20087f0: 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++;
20087f4: c4 00 63 30 ld [ %g1 + 0x330 ], %g2
20087f8: 84 00 a0 01 inc %g2
20087fc: c4 20 63 30 st %g2, [ %g1 + 0x330 ]
return _Thread_Dispatch_disable_level;
2008800: c2 00 63 30 ld [ %g1 + 0x330 ], %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 );
2008804: 11 00 80 8a sethi %hi(0x2022800), %o0
2008808: 40 00 08 6b call 200a9b4 <_Objects_Allocate>
200880c: 90 12 22 70 or %o0, 0x270, %o0 ! 2022a70 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
2008810: 80 a2 20 00 cmp %o0, 0
2008814: 12 80 00 0a bne 200883c <timer_create+0xb4>
2008818: 82 10 20 02 mov 2, %g1
_Thread_Enable_dispatch();
200881c: 40 00 0d 8e call 200be54 <_Thread_Enable_dispatch>
2008820: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
2008824: 40 00 23 f0 call 20117e4 <__errno>
2008828: 01 00 00 00 nop
200882c: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
2008830: c2 22 00 00 st %g1, [ %o0 ]
2008834: 81 c7 e0 08 ret
2008838: 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;
200883c: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
2008840: 03 00 80 8b sethi %hi(0x2022c00), %g1
2008844: c2 00 60 bc ld [ %g1 + 0xbc ], %g1 ! 2022cbc <_Per_CPU_Information+0xc>
if ( evp != NULL ) {
2008848: 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;
200884c: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
2008850: 02 80 00 08 be 2008870 <timer_create+0xe8>
2008854: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
2008858: c2 06 40 00 ld [ %i1 ], %g1
200885c: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
2008860: c2 06 60 04 ld [ %i1 + 4 ], %g1
2008864: c2 22 20 44 st %g1, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
2008868: c2 06 60 08 ld [ %i1 + 8 ], %g1
200886c: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008870: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008874: 07 00 80 8a sethi %hi(0x2022800), %g3
2008878: c6 00 e2 8c ld [ %g3 + 0x28c ], %g3 ! 2022a8c <_POSIX_Timer_Information+0x1c>
}
ptimer->overrun = 0;
200887c: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
2008880: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
2008884: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
2008888: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
200888c: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2008890: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
2008894: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
2008898: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
200889c: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20088a0: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20088a4: 85 28 a0 02 sll %g2, 2, %g2
20088a8: 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;
20088ac: 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;
20088b0: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
20088b4: 40 00 0d 68 call 200be54 <_Thread_Enable_dispatch>
20088b8: b0 10 20 00 clr %i0
return 0;
}
20088bc: 81 c7 e0 08 ret
20088c0: 81 e8 00 00 restore
0200737c <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
200737c: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
2007380: 80 a6 a0 00 cmp %i2, 0
2007384: 02 80 00 2f be 2007440 <timer_settime+0xc4> <== NEVER TAKEN
2007388: 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) ) ) {
200738c: 40 00 0f 6d call 200b140 <_Timespec_Is_valid>
2007390: 90 06 a0 08 add %i2, 8, %o0
2007394: 80 8a 20 ff btst 0xff, %o0
2007398: 02 80 00 2a be 2007440 <timer_settime+0xc4>
200739c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
20073a0: 40 00 0f 68 call 200b140 <_Timespec_Is_valid>
20073a4: 90 10 00 1a mov %i2, %o0
20073a8: 80 8a 20 ff btst 0xff, %o0
20073ac: 02 80 00 25 be 2007440 <timer_settime+0xc4> <== NEVER TAKEN
20073b0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
20073b4: 80 a6 60 00 cmp %i1, 0
20073b8: 02 80 00 05 be 20073cc <timer_settime+0x50>
20073bc: 90 07 bf d8 add %fp, -40, %o0
20073c0: 80 a6 60 04 cmp %i1, 4
20073c4: 12 80 00 1f bne 2007440 <timer_settime+0xc4>
20073c8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
20073cc: 92 10 00 1a mov %i2, %o1
20073d0: 40 00 25 bb call 2010abc <memcpy>
20073d4: 94 10 20 10 mov 0x10, %o2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
20073d8: 80 a6 60 04 cmp %i1, 4
20073dc: 32 80 00 23 bne,a 2007468 <timer_settime+0xec>
20073e0: 92 10 00 18 mov %i0, %o1
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
20073e4: 40 00 06 62 call 2008d6c <_TOD_Get_as_timestamp>
20073e8: 90 07 bf e8 add %fp, -24, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
20073ec: f8 1f bf e8 ldd [ %fp + -24 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
20073f0: 94 10 20 00 clr %o2
20073f4: 90 10 00 1c mov %i4, %o0
20073f8: 92 10 00 1d mov %i5, %o1
20073fc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007400: 40 00 49 5b call 201996c <__divdi3>
2007404: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007408: 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);
200740c: d2 27 bf f4 st %o1, [ %fp + -12 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007410: 90 10 00 1c mov %i4, %o0
2007414: 92 10 00 1d mov %i5, %o1
2007418: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
200741c: 40 00 4a 3a call 2019d04 <__moddi3>
2007420: 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 ) )
2007424: 90 07 bf e0 add %fp, -32, %o0
2007428: d2 27 bf f8 st %o1, [ %fp + -8 ]
200742c: 40 00 0f 56 call 200b184 <_Timespec_Less_than>
2007430: 92 07 bf f4 add %fp, -12, %o1
2007434: 80 8a 20 ff btst 0xff, %o0
2007438: 02 80 00 08 be 2007458 <timer_settime+0xdc>
200743c: 92 07 bf e0 add %fp, -32, %o1
rtems_set_errno_and_return_minus_one( EINVAL );
2007440: 40 00 23 43 call 201014c <__errno>
2007444: b0 10 3f ff mov -1, %i0
2007448: 82 10 20 16 mov 0x16, %g1
200744c: c2 22 00 00 st %g1, [ %o0 ]
2007450: 81 c7 e0 08 ret
2007454: 81 e8 00 00 restore
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
2007458: 90 07 bf f4 add %fp, -12, %o0
200745c: 40 00 0f 5a call 200b1c4 <_Timespec_Subtract>
2007460: 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 *)
2007464: 92 10 00 18 mov %i0, %o1
2007468: 11 00 80 7a sethi %hi(0x201e800), %o0
200746c: 94 07 bf fc add %fp, -4, %o2
2007470: 40 00 08 eb call 200981c <_Objects_Get>
2007474: 90 12 21 90 or %o0, 0x190, %o0
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
2007478: c2 07 bf fc ld [ %fp + -4 ], %g1
200747c: 80 a0 60 00 cmp %g1, 0
2007480: 12 80 00 48 bne 20075a0 <timer_settime+0x224>
2007484: b0 10 00 08 mov %o0, %i0
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 ) {
2007488: c2 07 bf e0 ld [ %fp + -32 ], %g1
200748c: 80 a0 60 00 cmp %g1, 0
2007490: 12 80 00 14 bne 20074e0 <timer_settime+0x164>
2007494: c2 07 bf e4 ld [ %fp + -28 ], %g1
2007498: 80 a0 60 00 cmp %g1, 0
200749c: 12 80 00 11 bne 20074e0 <timer_settime+0x164>
20074a0: 01 00 00 00 nop
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
20074a4: 40 00 10 80 call 200b6a4 <_Watchdog_Remove>
20074a8: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
20074ac: 80 a6 e0 00 cmp %i3, 0
20074b0: 02 80 00 05 be 20074c4 <timer_settime+0x148>
20074b4: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
20074b8: 92 06 20 54 add %i0, 0x54, %o1
20074bc: 40 00 25 80 call 2010abc <memcpy>
20074c0: 94 10 20 10 mov 0x10, %o2
/* The new data are set */
ptimer->timer_data = normalize;
20074c4: 90 06 20 54 add %i0, 0x54, %o0
20074c8: 92 07 bf d8 add %fp, -40, %o1
20074cc: 40 00 25 7c call 2010abc <memcpy>
20074d0: 94 10 20 10 mov 0x10, %o2
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
20074d4: 82 10 20 04 mov 4, %g1
20074d8: 10 80 00 2e b 2007590 <timer_settime+0x214>
20074dc: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ]
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
20074e0: 40 00 0f 4a call 200b208 <_Timespec_To_ticks>
20074e4: 90 10 00 1a mov %i2, %o0
20074e8: d0 26 20 64 st %o0, [ %i0 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
20074ec: 40 00 0f 47 call 200b208 <_Timespec_To_ticks>
20074f0: 90 07 bf e0 add %fp, -32, %o0
activated = _POSIX_Timer_Insert_helper(
20074f4: d4 06 20 08 ld [ %i0 + 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 );
20074f8: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
20074fc: 17 00 80 1d sethi %hi(0x2007400), %o3
2007500: 90 06 20 10 add %i0, 0x10, %o0
2007504: 96 12 e1 b8 or %o3, 0x1b8, %o3
2007508: 40 00 18 71 call 200d6cc <_POSIX_Timer_Insert_helper>
200750c: 98 10 00 18 mov %i0, %o4
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
2007510: 80 8a 20 ff btst 0xff, %o0
2007514: 02 80 00 1f be 2007590 <timer_settime+0x214>
2007518: 01 00 00 00 nop
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
200751c: 80 a6 e0 00 cmp %i3, 0
2007520: 02 80 00 05 be 2007534 <timer_settime+0x1b8>
2007524: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
2007528: 92 06 20 54 add %i0, 0x54, %o1
200752c: 40 00 25 64 call 2010abc <memcpy>
2007530: 94 10 20 10 mov 0x10, %o2
ptimer->timer_data = normalize;
2007534: 92 07 bf d8 add %fp, -40, %o1
2007538: 94 10 20 10 mov 0x10, %o2
200753c: 40 00 25 60 call 2010abc <memcpy>
2007540: 90 06 20 54 add %i0, 0x54, %o0
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
2007544: 82 10 20 03 mov 3, %g1
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
2007548: 90 07 bf e8 add %fp, -24, %o0
200754c: 40 00 06 08 call 2008d6c <_TOD_Get_as_timestamp>
2007550: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ]
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007554: f8 1f bf e8 ldd [ %fp + -24 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007558: 94 10 20 00 clr %o2
200755c: 90 10 00 1c mov %i4, %o0
2007560: 92 10 00 1d mov %i5, %o1
2007564: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007568: 40 00 49 01 call 201996c <__divdi3>
200756c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007570: 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);
2007574: d2 26 20 6c st %o1, [ %i0 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007578: 94 10 20 00 clr %o2
200757c: 92 10 00 1d mov %i5, %o1
2007580: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007584: 40 00 49 e0 call 2019d04 <__moddi3>
2007588: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
200758c: d2 26 20 70 st %o1, [ %i0 + 0x70 ]
_TOD_Get( &ptimer->time );
_Thread_Enable_dispatch();
2007590: 40 00 0c 56 call 200a6e8 <_Thread_Enable_dispatch>
2007594: b0 10 20 00 clr %i0
return 0;
2007598: 81 c7 e0 08 ret
200759c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
20075a0: 40 00 22 eb call 201014c <__errno>
20075a4: b0 10 3f ff mov -1, %i0
20075a8: 82 10 20 16 mov 0x16, %g1
20075ac: c2 22 00 00 st %g1, [ %o0 ]
}
20075b0: 81 c7 e0 08 ret
20075b4: 81 e8 00 00 restore
02007578 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
2007578: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
200757c: 39 00 80 80 sethi %hi(0x2020000), %i4
2007580: b8 17 20 f8 or %i4, 0xf8, %i4 ! 20200f8 <_POSIX_signals_Ualarm_timer>
2007584: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
2007588: 80 a0 60 00 cmp %g1, 0
200758c: 12 80 00 0a bne 20075b4 <ualarm+0x3c>
2007590: ba 10 00 18 mov %i0, %i5
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2007594: 03 00 80 1d sethi %hi(0x2007400), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2007598: c0 27 20 08 clr [ %i4 + 8 ]
the_watchdog->routine = routine;
200759c: 82 10 61 4c or %g1, 0x14c, %g1
the_watchdog->id = id;
20075a0: c0 27 20 20 clr [ %i4 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20075a4: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
20075a8: c0 27 20 24 clr [ %i4 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
20075ac: 10 80 00 1b b 2007618 <ualarm+0xa0>
20075b0: 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 );
20075b4: 40 00 0f f5 call 200b588 <_Watchdog_Remove>
20075b8: 90 10 00 1c mov %i4, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
20075bc: 90 02 3f fe add %o0, -2, %o0
20075c0: 80 a2 20 01 cmp %o0, 1
20075c4: 18 80 00 15 bgu 2007618 <ualarm+0xa0> <== NEVER TAKEN
20075c8: 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);
20075cc: c2 07 20 0c ld [ %i4 + 0xc ], %g1
20075d0: d0 07 20 14 ld [ %i4 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
20075d4: 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);
20075d8: 90 02 00 01 add %o0, %g1, %o0
20075dc: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
20075e0: 40 00 0e 87 call 200affc <_Timespec_From_ticks>
20075e4: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
20075e8: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
20075ec: 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;
20075f0: b1 28 60 08 sll %g1, 8, %i0
20075f4: 85 28 60 03 sll %g1, 3, %g2
20075f8: 84 26 00 02 sub %i0, %g2, %g2
remaining += tp.tv_nsec / 1000;
20075fc: 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;
2007600: b1 28 a0 06 sll %g2, 6, %i0
2007604: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
2007608: 40 00 4c 56 call 201a760 <.div>
200760c: 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;
2007610: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
2007614: 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 ) {
2007618: 80 a7 60 00 cmp %i5, 0
200761c: 02 80 00 19 be 2007680 <ualarm+0x108>
2007620: 39 00 03 d0 sethi %hi(0xf4000), %i4
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
2007624: 90 10 00 1d mov %i5, %o0
2007628: 40 00 4c 4c call 201a758 <.udiv>
200762c: 92 17 22 40 or %i4, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007630: 92 17 22 40 or %i4, 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;
2007634: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007638: 40 00 4c f4 call 201aa08 <.urem>
200763c: 90 10 00 1d mov %i5, %o0
2007640: 85 2a 20 07 sll %o0, 7, %g2
2007644: 83 2a 20 02 sll %o0, 2, %g1
2007648: 82 20 80 01 sub %g2, %g1, %g1
200764c: 90 00 40 08 add %g1, %o0, %o0
2007650: 91 2a 20 03 sll %o0, 3, %o0
2007654: d0 27 bf fc st %o0, [ %fp + -4 ]
ticks = _Timespec_To_ticks( &tp );
2007658: 40 00 0e 7e call 200b050 <_Timespec_To_ticks>
200765c: 90 07 bf f8 add %fp, -8, %o0
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
2007660: 40 00 0e 7c call 200b050 <_Timespec_To_ticks>
2007664: 90 07 bf f8 add %fp, -8, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2007668: 13 00 80 80 sethi %hi(0x2020000), %o1
200766c: 92 12 60 f8 or %o1, 0xf8, %o1 ! 20200f8 <_POSIX_signals_Ualarm_timer>
2007670: d0 22 60 0c st %o0, [ %o1 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007674: 11 00 80 7e sethi %hi(0x201f800), %o0
2007678: 40 00 0f 6a call 200b420 <_Watchdog_Insert>
200767c: 90 12 20 a0 or %o0, 0xa0, %o0 ! 201f8a0 <_Watchdog_Ticks_chain>
}
return remaining;
}
2007680: 81 c7 e0 08 ret
2007684: 81 e8 00 00 restore
0201a3a8 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
201a3a8: 9d e3 bf a0 save %sp, -96, %sp
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a3ac: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a3b0: c2 00 63 5c ld [ %g1 + 0x35c ], %g1 ! 201cf5c <rtems_libio_number_iops>
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
201a3b4: 92 10 00 19 mov %i1, %o1
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a3b8: 80 a6 00 01 cmp %i0, %g1
201a3bc: 1a 80 00 18 bcc 201a41c <write+0x74>
201a3c0: 94 10 00 1a mov %i2, %o2
iop = rtems_libio_iop( fd );
201a3c4: bb 2e 20 03 sll %i0, 3, %i5
201a3c8: 03 00 80 76 sethi %hi(0x201d800), %g1
201a3cc: b1 2e 20 06 sll %i0, 6, %i0
201a3d0: b0 07 40 18 add %i5, %i0, %i0
201a3d4: fa 00 62 98 ld [ %g1 + 0x298 ], %i5
201a3d8: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open( iop );
201a3dc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
201a3e0: 80 88 61 00 btst 0x100, %g1
201a3e4: 02 80 00 0e be 201a41c <write+0x74>
201a3e8: 01 00 00 00 nop
rtems_libio_check_buffer( buffer );
201a3ec: 80 a6 60 00 cmp %i1, 0
201a3f0: 12 80 00 06 bne 201a408 <write+0x60> <== ALWAYS TAKEN
201a3f4: 80 a6 a0 00 cmp %i2, 0
201a3f8: 7f ff d5 1f call 200f874 <__errno> <== NOT EXECUTED
201a3fc: 01 00 00 00 nop <== NOT EXECUTED
201a400: 10 80 00 0a b 201a428 <write+0x80> <== NOT EXECUTED
201a404: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
201a408: 02 80 00 15 be 201a45c <write+0xb4>
201a40c: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
201a410: 80 88 60 04 btst 4, %g1
201a414: 32 80 00 08 bne,a 201a434 <write+0x8c>
201a418: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
201a41c: 7f ff d5 16 call 200f874 <__errno>
201a420: 01 00 00 00 nop
201a424: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a428: c2 22 00 00 st %g1, [ %o0 ]
201a42c: 81 c7 e0 08 ret
201a430: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
201a434: c2 00 60 0c ld [ %g1 + 0xc ], %g1
201a438: 9f c0 40 00 call %g1
201a43c: 90 10 00 1d mov %i5, %o0
if ( rc > 0 )
201a440: b0 92 20 00 orcc %o0, 0, %i0
201a444: 04 80 00 06 ble 201a45c <write+0xb4>
201a448: 85 3e 20 1f sra %i0, 0x1f, %g2
iop->offset += rc;
201a44c: d8 1f 60 10 ldd [ %i5 + 0x10 ], %o4
201a450: 86 83 40 18 addcc %o5, %i0, %g3
201a454: 84 43 00 02 addx %o4, %g2, %g2
201a458: c4 3f 60 10 std %g2, [ %i5 + 0x10 ]
return rc;
}
201a45c: 81 c7 e0 08 ret
201a460: 81 e8 00 00 restore
0200828c <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
200828c: 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 );
2008290: 03 00 80 76 sethi %hi(0x201d800), %g1
2008294: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 201daac <rtems_libio_number_iops>
2008298: 80 a6 00 01 cmp %i0, %g1
200829c: 1a 80 00 0f bcc 20082d8 <writev+0x4c>
20082a0: 01 00 00 00 nop
iop = rtems_libio_iop( fd );
20082a4: b7 2e 20 03 sll %i0, 3, %i3
20082a8: 03 00 80 79 sethi %hi(0x201e400), %g1
20082ac: b1 2e 20 06 sll %i0, 6, %i0
20082b0: b0 06 c0 18 add %i3, %i0, %i0
20082b4: f6 00 61 e8 ld [ %g1 + 0x1e8 ], %i3
20082b8: b6 06 c0 18 add %i3, %i0, %i3
rtems_libio_check_is_open( iop );
20082bc: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1
20082c0: 80 88 61 00 btst 0x100, %g1
20082c4: 02 80 00 05 be 20082d8 <writev+0x4c>
20082c8: 01 00 00 00 nop
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
20082cc: 80 88 60 04 btst 4, %g1
20082d0: 12 80 00 06 bne 20082e8 <writev+0x5c> <== ALWAYS TAKEN
20082d4: 80 a6 60 00 cmp %i1, 0
20082d8: 40 00 21 33 call 20107a4 <__errno>
20082dc: 01 00 00 00 nop
20082e0: 10 80 00 24 b 2008370 <writev+0xe4>
20082e4: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
20082e8: 02 80 00 1f be 2008364 <writev+0xd8>
20082ec: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
20082f0: 80 a6 a0 00 cmp %i2, 0
20082f4: 04 80 00 1c ble 2008364 <writev+0xd8>
20082f8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
20082fc: 80 a6 a4 00 cmp %i2, 0x400
2008300: 14 80 00 19 bg 2008364 <writev+0xd8> <== NEVER TAKEN
2008304: 01 00 00 00 nop
2008308: 84 10 00 19 mov %i1, %g2
200830c: 86 10 20 01 mov 1, %g3
2008310: 88 10 20 00 clr %g4
2008314: 10 80 00 03 b 2008320 <writev+0x94>
2008318: 82 10 20 00 clr %g1
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
200831c: 82 10 00 18 mov %i0, %g1
/*
* 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 )
2008320: f0 00 80 00 ld [ %g2 ], %i0
2008324: 80 a6 20 00 cmp %i0, 0
2008328: 02 80 00 0f be 2008364 <writev+0xd8>
200832c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
2008330: f0 00 a0 04 ld [ %g2 + 4 ], %i0
all_zeros = false;
2008334: 80 a0 00 18 cmp %g0, %i0
2008338: 9e 40 3f ff addx %g0, -1, %o7
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
200833c: b0 86 00 01 addcc %i0, %g1, %i0
2008340: 0c 80 00 09 bneg 2008364 <writev+0xd8>
2008344: 86 08 c0 0f and %g3, %o7, %g3
2008348: 80 a6 00 01 cmp %i0, %g1
200834c: 06 80 00 03 bl 2008358 <writev+0xcc>
2008350: 9e 10 20 01 mov 1, %o7
2008354: 9e 10 20 00 clr %o7
2008358: 80 8b e0 ff btst 0xff, %o7
200835c: 02 80 00 08 be 200837c <writev+0xf0>
2008360: 88 01 20 01 inc %g4
rtems_set_errno_and_return_minus_one( EINVAL );
2008364: 40 00 21 10 call 20107a4 <__errno>
2008368: 01 00 00 00 nop
200836c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2008370: c2 22 00 00 st %g1, [ %o0 ]
2008374: 81 c7 e0 08 ret
2008378: 91 e8 3f ff restore %g0, -1, %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++ ) {
200837c: 80 a1 00 1a cmp %g4, %i2
2008380: 12 bf ff e7 bne 200831c <writev+0x90>
2008384: 84 00 a0 08 add %g2, 8, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
2008388: 80 88 e0 ff btst 0xff, %g3
200838c: 12 80 00 1d bne 2008400 <writev+0x174>
2008390: b0 10 20 00 clr %i0
2008394: a0 10 20 00 clr %l0
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
2008398: d4 06 60 04 ld [ %i1 + 4 ], %o2
200839c: 80 a2 a0 00 cmp %o2, 0
20083a0: 22 80 00 15 be,a 20083f4 <writev+0x168> <== NEVER TAKEN
20083a4: a0 04 20 01 inc %l0 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
20083a8: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
20083ac: d2 06 40 00 ld [ %i1 ], %o1
20083b0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20083b4: 9f c0 40 00 call %g1
20083b8: 90 10 00 1b mov %i3, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
20083bc: 80 a2 20 00 cmp %o0, 0
20083c0: 26 80 00 10 bl,a 2008400 <writev+0x174> <== NEVER TAKEN
20083c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
20083c8: 02 80 00 07 be 20083e4 <writev+0x158> <== NEVER TAKEN
20083cc: b9 3a 20 1f sra %o0, 0x1f, %i4
iop->offset += bytes;
20083d0: c4 1e e0 10 ldd [ %i3 + 0x10 ], %g2
20083d4: 86 80 c0 08 addcc %g3, %o0, %g3
total += bytes;
20083d8: b0 06 00 08 add %i0, %o0, %i0
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
20083dc: 84 40 80 1c addx %g2, %i4, %g2
20083e0: c4 3e e0 10 std %g2, [ %i3 + 0x10 ]
total += bytes;
}
if (bytes != iov[ v ].iov_len)
20083e4: c2 06 60 04 ld [ %i1 + 4 ], %g1
20083e8: 80 a2 00 01 cmp %o0, %g1
20083ec: 12 80 00 05 bne 2008400 <writev+0x174> <== NEVER TAKEN
20083f0: a0 04 20 01 inc %l0
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
20083f4: 80 a4 00 1a cmp %l0, %i2
20083f8: 12 bf ff e8 bne 2008398 <writev+0x10c>
20083fc: b2 06 60 08 add %i1, 8, %i1
2008400: 81 c7 e0 08 ret
2008404: 81 e8 00 00 restore