RTEMS 4.11Annotated Report
Thu Dec 20 15:04:48 2012
0200be94 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
200be94: 9d e3 bf 98 save %sp, -104, %sp
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
200be98: 40 00 02 6e call 200c850 <geteuid>
200be9c: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200bea0: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200bea4: 91 2a 20 10 sll %o0, 0x10, %o0
200bea8: 91 32 20 10 srl %o0, 0x10, %o0
200beac: 80 a0 40 08 cmp %g1, %o0
200beb0: 02 80 00 04 be 200bec0 <IMFS_chown+0x2c>
200beb4: 80 a2 20 00 cmp %o0, 0
200beb8: 12 80 00 0b bne 200bee4 <IMFS_chown+0x50> <== ALWAYS TAKEN
200bebc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
200bec0: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
200bec4: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
200bec8: 90 07 bf f8 add %fp, -8, %o0
200becc: 7f ff de 13 call 2003718 <gettimeofday>
200bed0: 92 10 20 00 clr %o1
200bed4: c2 07 bf f8 ld [ %fp + -8 ], %g1
200bed8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200bedc: 81 c7 e0 08 ret
200bee0: 91 e8 20 00 restore %g0, 0, %o0
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
200bee4: 40 00 11 3d call 20103d8 <__errno>
200bee8: b0 10 3f ff mov -1, %i0
200beec: 82 10 20 01 mov 1, %g1
200bef0: c2 22 00 00 st %g1, [ %o0 ]
200bef4: 81 c7 e0 08 ret
200bef8: 81 e8 00 00 restore
02005884 <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
2005884: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2005888: f4 06 20 50 ld [ %i0 + 0x50 ], %i2
200588c: 39 00 80 94 sethi %hi(0x2025000), %i4
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 ));
2005890: b0 06 20 54 add %i0, 0x54, %i0
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 );
2005894: 80 a6 80 18 cmp %i2, %i0
2005898: 02 80 00 30 be 2005958 <IMFS_dump_directory+0xd4>
200589c: b8 17 20 90 or %i4, 0x90, %i4
20058a0: 37 00 80 8b sethi %hi(0x2022c00), %i3
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20058a4: 29 00 80 8b sethi %hi(0x2022c00), %l4
return;
}
puts("");
20058a8: 21 00 80 8b sethi %hi(0x2022c00), %l0
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
20058ac: 27 00 80 8b sethi %hi(0x2022c00), %l3
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
20058b0: 25 00 80 8b sethi %hi(0x2022c00), %l2
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
20058b4: b6 16 e3 60 or %i3, 0x360, %i3
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20058b8: a8 15 23 d0 or %l4, 0x3d0, %l4
return;
}
puts("");
20058bc: a0 14 22 f8 or %l0, 0x2f8, %l0
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
20058c0: a6 14 e3 b8 or %l3, 0x3b8, %l3
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
20058c4: a4 14 a3 a0 or %l2, 0x3a0, %l2
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
IMFS_dump_directory( the_jnode, level + 1 );
20058c8: a2 06 60 01 add %i1, 1, %l1
!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++ )
20058cc: 80 a6 60 00 cmp %i1, 0
20058d0: 06 80 00 0c bl 2005900 <IMFS_dump_directory+0x7c> <== NEVER TAKEN
20058d4: ba 10 20 00 clr %i5
fprintf(stdout, "...." );
20058d8: c2 07 00 00 ld [ %i4 ], %g1
20058dc: 90 10 00 1b mov %i3, %o0
20058e0: d6 00 60 08 ld [ %g1 + 8 ], %o3
20058e4: 92 10 20 01 mov 1, %o1
20058e8: 40 00 3f 8d call 201571c <fwrite>
20058ec: 94 10 20 04 mov 4, %o2
!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++ )
20058f0: ba 07 60 01 inc %i5
20058f4: 80 a6 40 1d cmp %i1, %i5
20058f8: 36 bf ff f9 bge,a 20058dc <IMFS_dump_directory+0x58>
20058fc: c2 07 00 00 ld [ %i4 ], %g1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
2005900: c2 07 00 00 ld [ %i4 ], %g1
2005904: 90 06 a0 0c add %i2, 0xc, %o0
2005908: 40 00 3c 67 call 2014aa4 <fputs>
200590c: d2 00 60 08 ld [ %g1 + 8 ], %o1
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
2005910: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
2005914: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
2005918: 80 a2 a0 06 cmp %o2, 6
200591c: 28 80 00 11 bleu,a 2005960 <IMFS_dump_directory+0xdc> <== ALWAYS TAKEN
2005920: 95 2a a0 02 sll %o2, 2, %o2
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
2005924: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
2005928: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
200592c: 40 00 3c 0e call 2014964 <fprintf> <== NOT EXECUTED
2005930: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
2005934: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1 <== NOT EXECUTED
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 ) )
2005938: c2 00 40 00 ld [ %g1 ], %g1
200593c: 80 a0 60 00 cmp %g1, 0
2005940: 22 80 00 19 be,a 20059a4 <IMFS_dump_directory+0x120>
2005944: 90 10 00 1a mov %i2, %o0
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 ) {
2005948: f4 06 80 00 ld [ %i2 ], %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 );
200594c: 80 a6 80 18 cmp %i2, %i0
2005950: 12 bf ff e0 bne 20058d0 <IMFS_dump_directory+0x4c>
2005954: 80 a6 60 00 cmp %i1, 0
2005958: 81 c7 e0 08 ret
200595c: 81 e8 00 00 restore
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( IMFS_type( the_jnode ) ) {
2005960: 03 00 80 16 sethi %hi(0x2005800), %g1
2005964: 82 10 60 68 or %g1, 0x68, %g1 ! 2005868 <bsp_interrupt_handler_default+0x18>
2005968: c2 00 40 0a ld [ %g1 + %o2 ], %g1
200596c: 81 c0 40 00 jmp %g1
2005970: 01 00 00 00 nop
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
2005974: c2 07 00 00 ld [ %i4 ], %g1
2005978: 90 10 00 12 mov %l2, %o0
200597c: d6 00 60 08 ld [ %g1 + 8 ], %o3
2005980: 92 10 20 01 mov 1, %o1
2005984: 40 00 3f 66 call 201571c <fwrite>
2005988: 94 10 20 13 mov 0x13, %o2
200598c: c2 06 a0 4c ld [ %i2 + 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 ) )
2005990: c2 00 40 00 ld [ %g1 ], %g1
2005994: 80 a0 60 00 cmp %g1, 0
2005998: 32 bf ff ed bne,a 200594c <IMFS_dump_directory+0xc8> <== ALWAYS TAKEN
200599c: f4 06 80 00 ld [ %i2 ], %i2
IMFS_dump_directory( the_jnode, level + 1 );
20059a0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20059a4: 7f ff ff b8 call 2005884 <IMFS_dump_directory>
20059a8: 92 10 00 11 mov %l1, %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 ) {
20059ac: 10 bf ff e8 b 200594c <IMFS_dump_directory+0xc8>
20059b0: f4 06 80 00 ld [ %i2 ], %i2
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
20059b4: c2 07 00 00 ld [ %i4 ], %g1
20059b8: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
20059bc: d0 00 60 08 ld [ %g1 + 8 ], %o0
20059c0: d6 06 a0 58 ld [ %i2 + 0x58 ], %o3
20059c4: 13 00 80 8b sethi %hi(0x2022c00), %o1
20059c8: 40 00 3b e7 call 2014964 <fprintf>
20059cc: 92 12 63 80 or %o1, 0x380, %o1 ! 2022f80 <Configuration_Initial_Extensions+0x16a0>
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
return;
}
puts("");
20059d0: 40 00 43 54 call 2016720 <puts>
20059d4: 90 10 00 10 mov %l0, %o0
20059d8: 10 bf ff d8 b 2005938 <IMFS_dump_directory+0xb4>
20059dc: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
20059e0: c2 07 00 00 ld [ %i4 ], %g1
20059e4: d4 06 a0 50 ld [ %i2 + 0x50 ], %o2
20059e8: d0 00 60 08 ld [ %g1 + 8 ], %o0
20059ec: d6 06 a0 54 ld [ %i2 + 0x54 ], %o3
20059f0: 13 00 80 8b sethi %hi(0x2022c00), %o1
20059f4: 40 00 3b dc call 2014964 <fprintf>
20059f8: 92 12 63 68 or %o1, 0x368, %o1 ! 2022f68 <Configuration_Initial_Extensions+0x1688>
20059fc: 30 bf ff f5 b,a 20059d0 <IMFS_dump_directory+0x14c>
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( IMFS_type( the_jnode ) ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
2005a00: c2 07 00 00 ld [ %i4 ], %g1
2005a04: 90 10 20 2f mov 0x2f, %o0
2005a08: 40 00 3b f3 call 20149d4 <fputc>
2005a0c: d2 00 60 08 ld [ %g1 + 8 ], %o1
2005a10: 30 bf ff f0 b,a 20059d0 <IMFS_dump_directory+0x14c>
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
2005a14: c2 07 00 00 ld [ %i4 ], %g1
2005a18: 90 10 00 13 mov %l3, %o0
2005a1c: d6 00 60 08 ld [ %g1 + 8 ], %o3
2005a20: 92 10 20 01 mov 1, %o1
2005a24: 40 00 3f 3e call 201571c <fwrite>
2005a28: 94 10 20 12 mov 0x12, %o2
2005a2c: 10 bf ff c3 b 2005938 <IMFS_dump_directory+0xb4>
2005a30: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
2005a34: c2 07 00 00 ld [ %i4 ], %g1
2005a38: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
2005a3c: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005a40: 13 00 80 8b sethi %hi(0x2022c00), %o1
2005a44: 40 00 3b c8 call 2014964 <fprintf>
2005a48: 92 12 63 90 or %o1, 0x390, %o1 ! 2022f90 <Configuration_Initial_Extensions+0x16b0>
2005a4c: 30 bf ff e1 b,a 20059d0 <IMFS_dump_directory+0x14c>
0200c040 <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
200c040: 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;
200c044: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
200c048: 90 10 00 18 mov %i0, %o0
200c04c: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
200c050: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
200c054: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
200c058: 40 00 03 24 call 200cce8 <rtems_filesystem_eval_path_check_access>
200c05c: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
200c060: 80 8a 20 ff btst 0xff, %o0
200c064: 12 80 00 04 bne 200c074 <IMFS_eval_token+0x34>
200c068: 80 a6 e0 01 cmp %i3, 1
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)) {
200c06c: 81 c7 e0 08 ret
200c070: 91 e8 20 01 restore %g0, 1, %o0
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200c074: 02 80 00 58 be 200c1d4 <IMFS_eval_token+0x194>
200c078: 80 a6 e0 02 cmp %i3, 2
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200c07c: 22 80 00 37 be,a 200c158 <IMFS_eval_token+0x118>
200c080: c2 4e 80 00 ldsb [ %i2 ], %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200c084: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
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 );
200c088: b2 07 20 54 add %i4, 0x54, %i1
while ( current != tail ) {
200c08c: 80 a7 40 19 cmp %i5, %i1
200c090: 02 80 00 30 be 200c150 <IMFS_eval_token+0x110>
200c094: 90 07 60 0c add %i5, 0xc, %o0
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
200c098: 92 10 00 1a mov %i2, %o1
200c09c: 40 00 16 66 call 2011a34 <strncmp>
200c0a0: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
200c0a4: 80 a2 20 00 cmp %o0, 0
200c0a8: 12 80 00 26 bne 200c140 <IMFS_eval_token+0x100>
200c0ac: 82 07 40 1b add %i5, %i3, %g1
200c0b0: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
200c0b4: 80 a0 60 00 cmp %g1, 0
200c0b8: 32 80 00 23 bne,a 200c144 <IMFS_eval_token+0x104>
200c0bc: fa 07 40 00 ld [ %i5 ], %i5
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
200c0c0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
bool terminal = !rtems_filesystem_eval_path_has_path( ctx );
200c0c4: c4 06 20 04 ld [ %i0 + 4 ], %g2
200c0c8: c2 00 40 00 ld [ %g1 ], %g1
200c0cc: 80 a0 00 02 cmp %g0, %g2
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
200c0d0: c0 26 20 0c clr [ %i0 + 0xc ]
200c0d4: 84 60 3f ff subx %g0, -1, %g2
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
200c0d8: c8 06 20 10 ld [ %i0 + 0x10 ], %g4
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)) {
200c0dc: 80 a0 60 02 cmp %g1, 2
200c0e0: 02 80 00 43 be 200c1ec <IMFS_eval_token+0x1ac>
200c0e4: 86 10 00 02 mov %g2, %g3
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
200c0e8: 80 a0 60 03 cmp %g1, 3
200c0ec: 02 80 00 28 be 200c18c <IMFS_eval_token+0x14c>
200c0f0: 80 a0 60 00 cmp %g1, 0
IMFS_jnode_types_t type
)
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
200c0f4: 32 80 00 2c bne,a 200c1a4 <IMFS_eval_token+0x164>
200c0f8: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
if ( node->info.directory.mt_fs != NULL ) {
200c0fc: f6 07 60 5c ld [ %i5 + 0x5c ], %i3
200c100: 80 a6 e0 00 cmp %i3, 0
200c104: 02 80 00 27 be 200c1a0 <IMFS_eval_token+0x160>
200c108: 90 10 00 18 mov %i0, %o0
if ( !terminal ) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
access_ok = rtems_filesystem_eval_path_check_access(
200c10c: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
200c110: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
200c114: d8 17 60 3e lduh [ %i5 + 0x3e ], %o4
200c118: 40 00 02 f4 call 200cce8 <rtems_filesystem_eval_path_check_access>
200c11c: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
200c120: 80 8a 20 ff btst 0xff, %o0
200c124: 02 bf ff d2 be 200c06c <IMFS_eval_token+0x2c> <== NEVER TAKEN
200c128: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
200c12c: 92 06 e0 24 add %i3, 0x24, %o1
200c130: 7f ff e2 8b call 2004b5c <rtems_filesystem_eval_path_restart>
200c134: b0 10 20 01 mov 1, %i0
200c138: 81 c7 e0 08 ret
200c13c: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200c140: fa 07 40 00 ld [ %i5 ], %i5
} else {
rtems_chain_control *entries = &dir->info.directory.Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
while ( current != tail ) {
200c144: 80 a6 40 1d cmp %i1, %i5
200c148: 12 bf ff d4 bne 200c098 <IMFS_eval_token+0x58>
200c14c: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
}
}
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
200c150: 81 c7 e0 08 ret
200c154: 91 e8 20 02 restore %g0, 2, %o0
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200c158: 80 a0 60 2e cmp %g1, 0x2e
200c15c: 32 bf ff cb bne,a 200c088 <IMFS_eval_token+0x48>
200c160: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
200c164: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
200c168: 80 a0 60 2e cmp %g1, 0x2e
200c16c: 32 bf ff c7 bne,a 200c088 <IMFS_eval_token+0x48> <== NEVER TAKEN
200c170: fa 07 20 50 ld [ %i4 + 0x50 ], %i5 <== NOT EXECUTED
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
return dir->Parent;
200c174: fa 07 20 08 ld [ %i4 + 8 ], %i5
);
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
200c178: 80 a7 60 00 cmp %i5, 0
200c17c: 02 bf ff f5 be 200c150 <IMFS_eval_token+0x110>
200c180: 01 00 00 00 nop
200c184: 10 bf ff d0 b 200c0c4 <IMFS_eval_token+0x84>
200c188: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
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)) {
200c18c: 80 a0 a0 00 cmp %g2, 0
200c190: 02 80 00 20 be 200c210 <IMFS_eval_token+0x1d0>
200c194: 80 89 20 10 btst 0x10, %g4
200c198: 32 80 00 1f bne,a 200c214 <IMFS_eval_token+0x1d4>
200c19c: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
} else {
rtems_filesystem_global_location_t **fs_root_ptr =
IMFS_is_mount_point( entry, type );
if ( fs_root_ptr == NULL ) {
--dir->reference_count;
200c1a0: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
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;
200c1a4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
200c1a8: 84 00 bf ff add %g2, -1, %g2
200c1ac: c4 37 20 34 sth %g2, [ %i4 + 0x34 ]
++entry->reference_count;
200c1b0: c4 17 60 34 lduh [ %i5 + 0x34 ], %g2
200c1b4: c2 00 60 04 ld [ %g1 + 4 ], %g1
200c1b8: 84 00 a0 01 inc %g2
200c1bc: c4 37 60 34 sth %g2, [ %i5 + 0x34 ]
currentloc->node_access = entry;
200c1c0: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
200c1c4: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200c1c8: b0 08 e0 ff and %g3, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
200c1cc: 81 c7 e0 08 ret
200c1d0: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200c1d4: c2 4e 80 00 ldsb [ %i2 ], %g1
200c1d8: 80 a0 60 2e cmp %g1, 0x2e
200c1dc: 32 bf ff ab bne,a 200c088 <IMFS_eval_token+0x48>
200c1e0: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
200c1e4: 10 bf ff b7 b 200c0c0 <IMFS_eval_token+0x80>
200c1e8: ba 10 00 1c mov %i4, %i5
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)) {
200c1ec: 80 a0 a0 00 cmp %g2, 0
200c1f0: 12 80 00 04 bne 200c200 <IMFS_eval_token+0x1c0>
200c1f4: 80 89 20 08 btst 8, %g4
entry = entry->info.hard_link.link_node;
200c1f8: 10 bf ff ea b 200c1a0 <IMFS_eval_token+0x160>
200c1fc: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
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)) {
200c200: 22 bf ff e9 be,a 200c1a4 <IMFS_eval_token+0x164>
200c204: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
200c208: 10 bf ff e6 b 200c1a0 <IMFS_eval_token+0x160>
200c20c: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
const char *target = entry->info.sym_link.name;
200c210: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
200c214: 40 00 15 d6 call 201196c <strlen>
200c218: 90 10 00 1d mov %i5, %o0
200c21c: 92 10 00 1d mov %i5, %o1
200c220: 94 10 00 08 mov %o0, %o2
200c224: 7f ff e2 67 call 2004bc0 <rtems_filesystem_eval_path_recursive>
200c228: 90 10 00 18 mov %i0, %o0
200c22c: 30 bf ff 90 b,a 200c06c <IMFS_eval_token+0x2c>
0200c248 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
200c248: 9d e3 bf 98 save %sp, -104, %sp
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
200c24c: 40 00 01 81 call 200c850 <geteuid>
200c250: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200c254: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200c258: 91 2a 20 10 sll %o0, 0x10, %o0
200c25c: 91 32 20 10 srl %o0, 0x10, %o0
200c260: 80 a0 40 08 cmp %g1, %o0
200c264: 02 80 00 04 be 200c274 <IMFS_fchmod+0x2c>
200c268: 80 a2 20 00 cmp %o0, 0
200c26c: 12 80 00 0e bne 200c2a4 <IMFS_fchmod+0x5c> <== ALWAYS TAKEN
200c270: 01 00 00 00 nop
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
200c274: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
200c278: 90 07 bf f8 add %fp, -8, %o0
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
200c27c: 82 08 70 00 and %g1, -4096, %g1
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
200c280: 92 10 20 00 clr %o1
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
200c284: b2 0e 6f ff and %i1, 0xfff, %i1
200c288: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
200c28c: 7f ff dd 23 call 2003718 <gettimeofday>
200c290: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
200c294: c2 07 bf f8 ld [ %fp + -8 ], %g1
200c298: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200c29c: 81 c7 e0 08 ret
200c2a0: 91 e8 20 00 restore %g0, 0, %o0
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
200c2a4: 40 00 10 4d call 20103d8 <__errno>
200c2a8: b0 10 3f ff mov -1, %i0
200c2ac: 82 10 20 01 mov 1, %g1
200c2b0: c2 22 00 00 st %g1, [ %o0 ]
200c2b4: 81 c7 e0 08 ret
200c2b8: 81 e8 00 00 restore
02003910 <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
2003910: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
2003914: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
2003918: 96 10 00 18 mov %i0, %o3
200391c: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
2003920: 92 10 00 19 mov %i1, %o1
2003924: 40 00 2d 64 call 200eeb4 <pipe_write>
2003928: 94 10 00 1a mov %i2, %o2
if (err > 0) {
200392c: b0 92 20 00 orcc %o0, 0, %i0
2003930: 04 80 00 09 ble 2003954 <IMFS_fifo_write+0x44>
2003934: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
2003938: 40 00 04 4c call 2004a68 <gettimeofday>
200393c: 92 10 20 00 clr %o1
2003940: c2 07 bf f8 ld [ %fp + -8 ], %g1
2003944: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
2003948: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
200394c: 81 c7 e0 08 ret
2003950: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
2003954: 80 a6 20 00 cmp %i0, 0
2003958: 12 80 00 04 bne 2003968 <IMFS_fifo_write+0x58> <== ALWAYS TAKEN
200395c: 01 00 00 00 nop
}
2003960: 81 c7 e0 08 ret <== NOT EXECUTED
2003964: 81 e8 00 00 restore <== NOT EXECUTED
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
2003968: 40 00 3b 09 call 201258c <__errno>
200396c: 01 00 00 00 nop
2003970: 82 20 00 18 neg %i0, %g1
2003974: c2 22 00 00 st %g1, [ %o0 ]
}
2003978: 81 c7 e0 08 ret
200397c: 91 e8 3f ff restore %g0, -1, %o0
0200c2bc <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
)
{
200c2bc: 9d e3 bf 88 save %sp, -120, %sp
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
200c2c0: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200c2c4: c6 00 a0 08 ld [ %g2 + 8 ], %g3
200c2c8: f2 00 80 00 ld [ %g2 ], %i1
200c2cc: f4 00 a0 04 ld [ %g2 + 4 ], %i2
200c2d0: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
200c2d4: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
200c2d8: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
200c2dc: c2 00 e0 4c ld [ %g3 + 0x4c ], %g1
200c2e0: f2 27 bf e8 st %i1, [ %fp + -24 ]
200c2e4: f4 27 bf ec st %i2, [ %fp + -20 ]
200c2e8: c6 27 bf f0 st %g3, [ %fp + -16 ]
200c2ec: f6 27 bf f4 st %i3, [ %fp + -12 ]
200c2f0: f8 27 bf f8 st %i4, [ %fp + -8 ]
200c2f4: c8 27 bf fc st %g4, [ %fp + -4 ]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
200c2f8: c0 20 a0 08 clr [ %g2 + 8 ]
200c2fc: c4 00 40 00 ld [ %g1 ], %g2
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
jnode = (IMFS_jnode_t *)loc.node_access;
200c300: ba 10 00 03 mov %g3, %i5
200c304: c2 00 60 04 ld [ %g1 + 4 ], %g1
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
200c308: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc.node_access = (void *)jnode;
200c30c: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200c310: 80 a0 a0 00 cmp %g2, 0
200c314: 12 80 00 13 bne 200c360 <IMFS_fsunmount+0xa4> <== NEVER TAKEN
200c318: c2 27 bf f8 st %g1, [ %fp + -8 ]
200c31c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200c320: 84 07 60 54 add %i5, 0x54, %g2
200c324: 80 a0 40 02 cmp %g1, %g2
200c328: 02 80 00 0f be 200c364 <IMFS_fsunmount+0xa8>
200c32c: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200c330: ba 10 00 01 mov %g1, %i5
if ( IMFS_is_directory( jnode ) ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
200c334: 80 a7 60 00 cmp %i5, 0
200c338: 02 80 00 21 be 200c3bc <IMFS_fsunmount+0x100> <== NEVER TAKEN
200c33c: 01 00 00 00 nop
200c340: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
200c344: f8 07 60 08 ld [ %i5 + 8 ], %i4
200c348: c4 00 40 00 ld [ %g1 ], %g2
200c34c: c2 00 60 04 ld [ %g1 + 4 ], %g1
loc.node_access = (void *)jnode;
200c350: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200c354: 80 a0 a0 00 cmp %g2, 0
200c358: 02 bf ff f1 be 200c31c <IMFS_fsunmount+0x60>
200c35c: c2 27 bf f8 st %g1, [ %fp + -8 ]
result = IMFS_rmnod( NULL, &loc );
200c360: 90 10 20 00 clr %o0
200c364: 7f ff db 73 call 2003130 <IMFS_rmnod>
200c368: 92 07 bf e8 add %fp, -24, %o1
if ( result != 0 )
200c36c: 80 a2 20 00 cmp %o0, 0
200c370: 12 80 00 15 bne 200c3c4 <IMFS_fsunmount+0x108> <== NEVER TAKEN
200c374: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
IMFS_node_destroy( jnode );
200c378: 7f ff da 8c call 2002da8 <IMFS_node_destroy>
200c37c: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
200c380: 80 a7 20 00 cmp %i4, 0
200c384: 02 80 00 0e be 200c3bc <IMFS_fsunmount+0x100>
200c388: 01 00 00 00 nop
200c38c: c2 07 20 4c ld [ %i4 + 0x4c ], %g1
200c390: c4 00 40 00 ld [ %g1 ], %g2
if ( IMFS_is_directory( jnode ) ) {
200c394: 80 a0 a0 00 cmp %g2, 0
200c398: 12 bf ff db bne 200c304 <IMFS_fsunmount+0x48> <== NEVER TAKEN
200c39c: ba 10 00 1c mov %i4, %i5
200c3a0: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200c3a4: 86 07 20 54 add %i4, 0x54, %g3
if ( jnode_has_children( jnode ) )
200c3a8: 80 a7 40 03 cmp %i5, %g3
200c3ac: 12 bf ff e3 bne 200c338 <IMFS_fsunmount+0x7c>
200c3b0: 80 a7 60 00 cmp %i5, 0
200c3b4: 10 bf ff d4 b 200c304 <IMFS_fsunmount+0x48>
200c3b8: ba 10 00 1c mov %i4, %i5
200c3bc: 81 c7 e0 08 ret
200c3c0: 81 e8 00 00 restore
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
result = IMFS_rmnod( NULL, &loc );
if ( result != 0 )
rtems_fatal_error_occurred( 0xdeadbeef );
200c3c4: 7f ff ef cc call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
200c3c8: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
02002c94 <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]
)
{
2002c94: 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 ) );
2002c98: 90 10 20 01 mov 1, %o0
2002c9c: 40 00 01 c6 call 20033b4 <calloc>
2002ca0: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
2002ca4: ba 92 20 00 orcc %o0, 0, %i5
2002ca8: 02 80 00 34 be 2002d78 <IMFS_initialize_support+0xe4>
2002cac: 03 00 80 77 sethi %hi(0x201dc00), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
2002cb0: c4 00 63 0c ld [ %g1 + 0x30c ], %g2 ! 201df0c <imfs_instance.6626>
memcpy(
2002cb4: 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++;
2002cb8: 86 00 a0 01 add %g2, 1, %g3
memcpy(
2002cbc: 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++;
2002cc0: c4 27 40 00 st %g2, [ %i5 ]
2002cc4: c6 20 63 0c st %g3, [ %g1 + 0x30c ]
memcpy(
2002cc8: 40 00 38 15 call 2010d1c <memcpy>
2002ccc: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
2002cd0: d2 07 60 08 ld [ %i5 + 8 ], %o1
2002cd4: 90 10 00 1d mov %i5, %o0
2002cd8: 96 10 20 00 clr %o3
2002cdc: 15 00 80 6e sethi %hi(0x201b800), %o2
2002ce0: 9a 10 20 00 clr %o5
2002ce4: 94 12 a2 78 or %o2, 0x278, %o2
2002ce8: 19 00 00 10 sethi %hi(0x4000), %o4
2002cec: 40 00 24 84 call 200befc <IMFS_allocate_node>
2002cf0: 98 13 21 ed or %o4, 0x1ed, %o4 ! 41ed <PROM_START+0x41ed>
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
2002cf4: 80 a2 20 00 cmp %o0, 0
2002cf8: 02 80 00 20 be 2002d78 <IMFS_initialize_support+0xe4> <== NEVER TAKEN
2002cfc: 09 00 80 70 sethi %hi(0x201c000), %g4
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;
2002d00: c4 02 20 4c ld [ %o0 + 0x4c ], %g2
mt_entry->fs_info = fs_info;
mt_entry->ops = op_table;
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
mt_entry->mt_fs_root->location.node_access = root_node;
2002d04: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2002d08: c6 00 a0 04 ld [ %g2 + 4 ], %g3
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
2002d0c: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->ops = op_table;
2002d10: f2 26 20 0c st %i1, [ %i0 + 0xc ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002d14: 05 00 80 75 sethi %hi(0x201d400), %g2
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
mt_entry->ops = op_table;
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
2002d18: 88 11 23 64 or %g4, 0x364, %g4
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002d1c: c4 00 a3 40 ld [ %g2 + 0x340 ], %g2
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
mt_entry->ops = op_table;
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
2002d20: c8 26 20 2c st %g4, [ %i0 + 0x2c ]
mt_entry->mt_fs_root->location.node_access = root_node;
2002d24: d0 20 60 08 st %o0, [ %g1 + 8 ]
/*
* 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) {
2002d28: 80 a0 a0 10 cmp %g2, 0x10
2002d2c: 02 80 00 0f be 2002d68 <IMFS_initialize_support+0xd4>
2002d30: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
2002d34: 80 a0 a0 0f cmp %g2, 0xf
2002d38: 04 80 00 0b ble 2002d64 <IMFS_initialize_support+0xd0>
2002d3c: 82 10 20 20 mov 0x20, %g1
2002d40: 86 10 20 05 mov 5, %g3
/*
* 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) {
2002d44: 80 a0 80 01 cmp %g2, %g1
2002d48: 22 80 00 09 be,a 2002d6c <IMFS_initialize_support+0xd8>
2002d4c: 03 00 80 77 sethi %hi(0x201dc00), %g1
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
2002d50: 26 80 00 06 bl,a 2002d68 <IMFS_initialize_support+0xd4> <== NEVER TAKEN
2002d54: 84 10 20 80 mov 0x80, %g2 <== NOT EXECUTED
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
2002d58: 86 80 ff ff addcc %g3, -1, %g3
2002d5c: 12 bf ff fa bne 2002d44 <IMFS_initialize_support+0xb0> <== ALWAYS TAKEN
2002d60: 83 28 60 01 sll %g1, 1, %g1
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
2002d64: 84 10 20 80 mov 0x80, %g2
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
2002d68: 03 00 80 77 sethi %hi(0x201dc00), %g1
2002d6c: c4 20 63 08 st %g2, [ %g1 + 0x308 ] ! 201df08 <imfs_memfile_bytes_per_block>
const IMFS_node_control *const node_controls [IMFS_TYPE_COUNT]
)
{
static int imfs_instance;
int rv = 0;
2002d70: 81 c7 e0 08 ret
2002d74: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
2002d78: 40 00 35 98 call 20103d8 <__errno>
2002d7c: b0 10 3f ff mov -1, %i0
2002d80: 82 10 20 0c mov 0xc, %g1
2002d84: c2 22 00 00 st %g1, [ %o0 ]
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
2002d88: 81 c7 e0 08 ret
2002d8c: 81 e8 00 00 restore
0200490c <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
200490c: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
2004910: 03 00 80 89 sethi %hi(0x2022400), %g1
2004914: c2 00 61 a4 ld [ %g1 + 0x1a4 ], %g1 ! 20225a4 <rtems_current_user_env>
switch (mode & S_IFMT) {
2004918: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
200491c: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004920: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
2004924: 03 00 00 3c sethi %hi(0xf000), %g1
2004928: 82 0e 40 01 and %i1, %g1, %g1
200492c: 80 a0 40 02 cmp %g1, %g2
2004930: 22 80 00 0c be,a 2004960 <IMFS_make_generic_node+0x54>
2004934: c2 06 80 00 ld [ %i2 ], %g1
2004938: 08 80 00 1d bleu 20049ac <IMFS_make_generic_node+0xa0> <== NEVER TAKEN
200493c: 05 00 00 04 sethi %hi(0x1000), %g2
2004940: 05 00 00 18 sethi %hi(0x6000), %g2
2004944: 80 a0 40 02 cmp %g1, %g2
2004948: 02 80 00 05 be 200495c <IMFS_make_generic_node+0x50>
200494c: 05 00 00 20 sethi %hi(0x8000), %g2
2004950: 80 a0 40 02 cmp %g1, %g2
2004954: 12 80 00 19 bne 20049b8 <IMFS_make_generic_node+0xac> <== ALWAYS TAKEN
2004958: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
200495c: c2 06 80 00 ld [ %i2 ], %g1
2004960: 80 a0 60 07 cmp %g1, 7
2004964: 12 80 00 15 bne 20049b8 <IMFS_make_generic_node+0xac>
2004968: 92 10 00 18 mov %i0, %o1
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 =
200496c: 94 10 20 78 mov 0x78, %o2
2004970: 40 00 08 55 call 2006ac4 <rtems_filesystem_eval_path_start>
2004974: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
2004978: 7f ff ff d2 call 20048c0 <IMFS_is_imfs_instance>
200497c: ba 10 00 08 mov %o0, %i5
2004980: 80 8a 20 ff btst 0xff, %o0
2004984: 12 80 00 13 bne 20049d0 <IMFS_make_generic_node+0xc4>
2004988: d4 1f bf d0 ldd [ %fp + -48 ], %o2
IMFS_update_mtime( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
200498c: 90 07 bf c8 add %fp, -56, %o0
2004990: 92 10 20 86 mov 0x86, %o1
2004994: 40 00 07 90 call 20067d4 <rtems_filesystem_eval_path_error>
2004998: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
200499c: 40 00 08 8a call 2006bc4 <rtems_filesystem_eval_path_cleanup>
20049a0: 90 07 bf c8 add %fp, -56, %o0
20049a4: 81 c7 e0 08 ret
20049a8: 81 e8 00 00 restore
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
20049ac: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20049b0: 22 bf ff ec be,a 2004960 <IMFS_make_generic_node+0x54> <== NOT EXECUTED
20049b4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
} else {
errno = EINVAL;
20049b8: 40 00 41 e1 call 201513c <__errno>
20049bc: b0 10 3f ff mov -1, %i0
20049c0: 82 10 20 16 mov 0x16, %g1
20049c4: c2 22 00 00 st %g1, [ %o0 ]
20049c8: 81 c7 e0 08 ret
20049cc: 81 e8 00 00 restore
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
20049d0: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
20049d4: 90 10 00 1d mov %i5, %o0
20049d8: 92 10 00 1a mov %i2, %o1
20049dc: 98 10 00 19 mov %i1, %o4
20049e0: 9a 07 bf b0 add %fp, -80, %o5
20049e4: 40 00 30 53 call 2010b30 <IMFS_create_node_with_control>
20049e8: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
20049ec: 80 a2 20 00 cmp %o0, 0
20049f0: 02 bf ff eb be 200499c <IMFS_make_generic_node+0x90>
20049f4: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
20049f8: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
20049fc: 40 00 02 96 call 2005454 <gettimeofday>
2004a00: 90 07 bf a8 add %fp, -88, %o0
2004a04: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
2004a08: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
2004a0c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
2004a10: 40 00 02 91 call 2005454 <gettimeofday>
2004a14: 92 10 20 00 clr %o1
2004a18: c2 07 bf a8 ld [ %fp + -88 ], %g1
2004a1c: b0 10 20 00 clr %i0
2004a20: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2004a24: 40 00 08 68 call 2006bc4 <rtems_filesystem_eval_path_cleanup>
2004a28: 90 07 bf c8 add %fp, -56, %o0
2004a2c: 81 c7 e0 08 ret
2004a30: 81 e8 00 00 restore
0200ed44 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200ed44: 9d e3 bf a0 save %sp, -96, %sp
IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );
/*
* Obtain the pointer for the specified block number
*/
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
200ed48: 94 10 20 01 mov 1, %o2
200ed4c: 90 10 00 18 mov %i0, %o0
200ed50: 7f ff fe c9 call 200e874 <IMFS_memfile_get_block_pointer>
200ed54: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
200ed58: c2 02 00 00 ld [ %o0 ], %g1
IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );
/*
* Obtain the pointer for the specified block number
*/
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
200ed5c: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
200ed60: 80 a0 60 00 cmp %g1, 0
200ed64: 12 80 00 08 bne 200ed84 <IMFS_memfile_addblock+0x40>
200ed68: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
200ed6c: 7f ff fe b5 call 200e840 <memfile_alloc_block>
200ed70: 01 00 00 00 nop
if ( !memory )
200ed74: 80 a2 20 00 cmp %o0, 0
200ed78: 02 80 00 05 be 200ed8c <IMFS_memfile_addblock+0x48> <== NEVER TAKEN
200ed7c: 01 00 00 00 nop
return 1;
*block_entry_ptr = memory;
200ed80: d0 27 40 00 st %o0, [ %i5 ]
return 0;
200ed84: 81 c7 e0 08 ret
200ed88: 81 e8 00 00 restore
}
200ed8c: 81 c7 e0 08 ret <== NOT EXECUTED
200ed90: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
0200efb8 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
200efb8: 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 )
200efbc: 25 00 80 77 sethi %hi(0x201dc00), %l2
200efc0: fa 04 a3 08 ld [ %l2 + 0x308 ], %i5 ! 201df08 <imfs_memfile_bytes_per_block>
200efc4: b9 37 60 02 srl %i5, 2, %i4
200efc8: 92 10 00 1c mov %i4, %o1
200efcc: 40 00 28 46 call 20190e4 <.umul>
200efd0: 90 07 20 01 add %i4, 1, %o0
200efd4: 92 10 00 1c mov %i4, %o1
200efd8: 40 00 28 43 call 20190e4 <.umul>
200efdc: 90 02 20 01 inc %o0
200efe0: 92 10 00 1d mov %i5, %o1
200efe4: 40 00 28 40 call 20190e4 <.umul>
200efe8: 90 02 3f ff add %o0, -1, %o0
200efec: 82 10 20 00 clr %g1
200eff0: 80 a0 40 1a cmp %g1, %i2
200eff4: 04 80 00 58 ble 200f154 <IMFS_memfile_extend+0x19c> <== ALWAYS TAKEN
200eff8: b8 10 00 18 mov %i0, %i4
rtems_set_errno_and_return_minus_one( EFBIG );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
200effc: e2 07 20 50 ld [ %i4 + 0x50 ], %l1 <== NOT EXECUTED
200f000: 80 a6 80 11 cmp %i2, %l1
200f004: 04 80 00 3f ble 200f100 <IMFS_memfile_extend+0x148> <== ALWAYS TAKEN
200f008: e0 07 20 54 ld [ %i4 + 0x54 ], %l0
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
200f00c: a7 3f 60 1f sra %i5, 0x1f, %l3 <== NOT EXECUTED
200f010: 96 10 00 1d mov %i5, %o3
200f014: 94 10 00 13 mov %l3, %o2
200f018: 90 10 00 1a mov %i2, %o0
200f01c: 40 00 29 c4 call 201972c <__divdi3>
200f020: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200f024: 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;
200f028: b0 10 00 09 mov %o1, %i0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200f02c: 90 10 00 11 mov %l1, %o0
200f030: 92 10 00 10 mov %l0, %o1
200f034: 40 00 29 be call 201972c <__divdi3>
200f038: 94 10 00 13 mov %l3, %o2
200f03c: a2 10 00 09 mov %o1, %l1
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
200f040: 90 10 00 09 mov %o1, %o0
200f044: 40 00 28 28 call 20190e4 <.umul>
200f048: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200f04c: ba 10 00 11 mov %l1, %i5
200f050: 80 a6 00 11 cmp %i0, %l1
200f054: 1a 80 00 07 bcc 200f070 <IMFS_memfile_extend+0xb8> <== ALWAYS TAKEN
200f058: a0 24 00 08 sub %l0, %o0, %l0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
200f05c: 10 80 00 1d b 200f0d0 <IMFS_memfile_extend+0x118> <== NOT EXECUTED
200f060: 92 10 20 00 clr %o1 <== NOT EXECUTED
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200f064: 80 a6 00 1d cmp %i0, %i5
200f068: 0a 80 00 1a bcs 200f0d0 <IMFS_memfile_extend+0x118>
200f06c: 92 10 20 00 clr %o1
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
200f070: 92 10 00 1d mov %i5, %o1
200f074: 7f ff ff 34 call 200ed44 <IMFS_memfile_addblock>
200f078: 90 10 00 1c mov %i4, %o0
200f07c: 80 a2 20 00 cmp %o0, 0
200f080: 12 80 00 26 bne 200f118 <IMFS_memfile_extend+0x160> <== NEVER TAKEN
200f084: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
200f088: 22 bf ff f7 be,a 200f064 <IMFS_memfile_extend+0xac>
200f08c: ba 07 60 01 inc %i5
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
block_p *block_ptr =
200f090: 92 10 00 1d mov %i5, %o1
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
if ( zero_fill ) {
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200f094: e6 04 a3 08 ld [ %l2 + 0x308 ], %l3
block_p *block_ptr =
200f098: 94 10 20 00 clr %o2
200f09c: 7f ff fd f6 call 200e874 <IMFS_memfile_get_block_pointer>
200f0a0: 90 10 00 1c mov %i4, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
200f0a4: d0 02 00 00 ld [ %o0 ], %o0
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
if ( zero_fill ) {
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200f0a8: a6 24 c0 10 sub %l3, %l0, %l3
block_p *block_ptr =
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
200f0ac: 90 02 00 10 add %o0, %l0, %o0
200f0b0: 92 10 20 00 clr %o1
200f0b4: 40 00 07 57 call 2010e10 <memset>
200f0b8: 94 10 00 13 mov %l3, %o2
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200f0bc: ba 07 60 01 inc %i5
200f0c0: 80 a6 00 1d cmp %i0, %i5
200f0c4: 1a bf ff eb bcc 200f070 <IMFS_memfile_extend+0xb8>
200f0c8: a0 10 20 00 clr %l0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
200f0cc: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
200f0d0: f4 3f 20 50 std %i2, [ %i4 + 0x50 ]
IMFS_update_ctime(the_jnode);
200f0d4: 7f ff d1 91 call 2003718 <gettimeofday>
200f0d8: 90 07 bf f8 add %fp, -8, %o0
200f0dc: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
200f0e0: 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);
200f0e4: c2 27 20 48 st %g1, [ %i4 + 0x48 ]
IMFS_update_mtime(the_jnode);
200f0e8: 7f ff d1 8c call 2003718 <gettimeofday>
200f0ec: 92 10 20 00 clr %o1
200f0f0: c2 07 bf f8 ld [ %fp + -8 ], %g1
200f0f4: c2 27 20 44 st %g1, [ %i4 + 0x44 ]
return 0;
200f0f8: 81 c7 e0 08 ret
200f0fc: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EFBIG );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
200f100: 12 80 00 04 bne 200f110 <IMFS_memfile_extend+0x158> <== NEVER TAKEN
200f104: 80 a6 c0 10 cmp %i3, %l0
200f108: 18 bf ff c2 bgu 200f010 <IMFS_memfile_extend+0x58> <== ALWAYS TAKEN
200f10c: a7 3f 60 1f sra %i5, 0x1f, %l3
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
IMFS_update_mtime(the_jnode);
return 0;
}
200f110: 81 c7 e0 08 ret <== NOT EXECUTED
200f114: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
200f118: 80 a7 40 11 cmp %i5, %l1 <== NOT EXECUTED
200f11c: 0a 80 00 08 bcs 200f13c <IMFS_memfile_extend+0x184> <== NOT EXECUTED
200f120: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
200f124: 7f ff ff 99 call 200ef88 <IMFS_memfile_remove_block> <== NOT EXECUTED
200f128: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
200f12c: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
200f130: 80 a4 40 1d cmp %l1, %i5 <== NOT EXECUTED
200f134: 08 bf ff fc bleu 200f124 <IMFS_memfile_extend+0x16c> <== NOT EXECUTED
200f138: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
200f13c: 40 00 04 a7 call 20103d8 <__errno> <== NOT EXECUTED
200f140: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200f144: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
200f148: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200f14c: 81 c7 e0 08 ret <== NOT EXECUTED
200f150: 81 e8 00 00 restore <== NOT EXECUTED
IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
200f154: 12 80 00 04 bne 200f164 <IMFS_memfile_extend+0x1ac> <== NEVER TAKEN
200f158: 80 a2 00 1b cmp %o0, %i3
200f15c: 38 bf ff a9 bgu,a 200f000 <IMFS_memfile_extend+0x48>
200f160: e2 07 20 50 ld [ %i4 + 0x50 ], %l1
rtems_set_errno_and_return_minus_one( EFBIG );
200f164: 40 00 04 9d call 20103d8 <__errno>
200f168: b0 10 3f ff mov -1, %i0
200f16c: 82 10 20 1b mov 0x1b, %g1
200f170: c2 22 00 00 st %g1, [ %o0 ]
200f174: 81 c7 e0 08 ret
200f178: 81 e8 00 00 restore
0200e874 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
200e874: 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 ) {
200e878: 03 00 80 77 sethi %hi(0x201dc00), %g1
200e87c: fa 00 63 08 ld [ %g1 + 0x308 ], %i5 ! 201df08 <imfs_memfile_bytes_per_block>
200e880: bb 37 60 02 srl %i5, 2, %i5
200e884: 82 07 7f ff add %i5, -1, %g1
200e888: 80 a6 40 01 cmp %i1, %g1
200e88c: 38 80 00 0b bgu,a 200e8b8 <IMFS_memfile_get_block_pointer+0x44>
200e890: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
200e894: 80 a6 a0 00 cmp %i2, 0
200e898: 12 80 00 4e bne 200e9d0 <IMFS_memfile_get_block_pointer+0x15c>
200e89c: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
200e8a0: 80 a2 20 00 cmp %o0, 0
200e8a4: 02 80 00 6d be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200e8a8: 01 00 00 00 nop
return 0;
return &info->indirect[ my_block ];
200e8ac: b3 2e 60 02 sll %i1, 2, %i1
200e8b0: 81 c7 e0 08 ret
200e8b4: 91 ea 00 19 restore %o0, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
200e8b8: 40 00 2a 0b call 20190e4 <.umul>
200e8bc: 92 10 00 1d mov %i5, %o1
200e8c0: 82 02 3f ff add %o0, -1, %g1
200e8c4: 80 a6 40 01 cmp %i1, %g1
200e8c8: 08 80 00 2b bleu 200e974 <IMFS_memfile_get_block_pointer+0x100>
200e8cc: b8 10 00 08 mov %o0, %i4
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
200e8d0: 90 02 20 01 inc %o0
200e8d4: 40 00 2a 04 call 20190e4 <.umul>
200e8d8: 92 10 00 1d mov %i5, %o1
200e8dc: 90 02 3f ff add %o0, -1, %o0
200e8e0: 80 a6 40 08 cmp %i1, %o0
200e8e4: 18 80 00 5d bgu 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200e8e8: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200e8ec: 92 10 00 1d mov %i5, %o1
200e8f0: 40 00 2a e3 call 201947c <.urem>
200e8f4: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e8f8: 92 10 00 1d mov %i5, %o1
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200e8fc: a0 10 00 08 mov %o0, %l0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e900: 40 00 2a 33 call 20191cc <.udiv>
200e904: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
200e908: 92 10 00 1d mov %i5, %o1
200e90c: 40 00 2a 30 call 20191cc <.udiv>
200e910: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e914: 92 10 00 1d mov %i5, %o1
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
200e918: b6 10 00 08 mov %o0, %i3
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e91c: 40 00 2a d8 call 201947c <.urem>
200e920: 90 10 00 1c mov %i4, %o0
p = info->triply_indirect;
if ( malloc_it ) {
200e924: 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;
200e928: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
200e92c: 02 80 00 3d be 200ea20 <IMFS_memfile_get_block_pointer+0x1ac>
200e930: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
200e934: 80 a2 20 00 cmp %o0, 0
200e938: 02 80 00 66 be 200ead0 <IMFS_memfile_get_block_pointer+0x25c>
200e93c: 01 00 00 00 nop
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
200e940: b7 2e e0 02 sll %i3, 2, %i3
200e944: c4 02 00 1b ld [ %o0 + %i3 ], %g2
if ( !p1 ) {
200e948: 80 a0 a0 00 cmp %g2, 0
200e94c: 02 80 00 5a be 200eab4 <IMFS_memfile_get_block_pointer+0x240>
200e950: b6 02 00 1b add %o0, %i3, %i3
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
200e954: bb 2f 60 02 sll %i5, 2, %i5
200e958: d0 00 80 1d ld [ %g2 + %i5 ], %o0
if ( !p2 ) {
200e95c: 80 a2 20 00 cmp %o0, 0
200e960: 02 80 00 47 be 200ea7c <IMFS_memfile_get_block_pointer+0x208>
200e964: ba 00 80 1d add %g2, %i5, %i5
p2 = memfile_alloc_block();
if ( !p2 )
return 0;
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
200e968: b1 2c 20 02 sll %l0, 2, %i0
200e96c: 81 c7 e0 08 ret
200e970: 91 ea 00 18 restore %o0, %i0, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
200e974: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200e978: 92 10 00 1d mov %i5, %o1
200e97c: 40 00 2a c0 call 201947c <.urem>
200e980: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e984: 92 10 00 1d mov %i5, %o1
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200e988: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e98c: 40 00 2a 10 call 20191cc <.udiv>
200e990: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
200e994: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( malloc_it ) {
200e998: 80 a6 a0 00 cmp %i2, 0
200e99c: 02 80 00 17 be 200e9f8 <IMFS_memfile_get_block_pointer+0x184>
200e9a0: ba 10 00 08 mov %o0, %i5
if ( !p ) {
200e9a4: 80 a0 60 00 cmp %g1, 0
200e9a8: 02 80 00 3c be 200ea98 <IMFS_memfile_get_block_pointer+0x224>
200e9ac: 01 00 00 00 nop
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
200e9b0: bb 2f 60 02 sll %i5, 2, %i5
200e9b4: d0 00 40 1d ld [ %g1 + %i5 ], %o0
if ( !p1 ) {
200e9b8: 80 a2 20 00 cmp %o0, 0
200e9bc: 02 80 00 29 be 200ea60 <IMFS_memfile_get_block_pointer+0x1ec>
200e9c0: ba 00 40 1d add %g1, %i5, %i5
if ( !p1 )
return 0;
p[ doubly ] = (block_p) p1;
}
return (block_p *)&p1[ singly ];
200e9c4: b1 2f 20 02 sll %i4, 2, %i0
200e9c8: 81 c7 e0 08 ret
200e9cc: 91 ea 00 18 restore %o0, %i0, %o0
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
200e9d0: 80 a2 20 00 cmp %o0, 0
200e9d4: 32 bf ff b7 bne,a 200e8b0 <IMFS_memfile_get_block_pointer+0x3c>
200e9d8: b3 2e 60 02 sll %i1, 2, %i1
p = memfile_alloc_block();
200e9dc: 7f ff ff 99 call 200e840 <memfile_alloc_block>
200e9e0: 01 00 00 00 nop
if ( !p )
200e9e4: 80 a2 20 00 cmp %o0, 0
200e9e8: 02 80 00 1c be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200e9ec: 01 00 00 00 nop
return 0;
info->indirect = p;
200e9f0: 10 bf ff af b 200e8ac <IMFS_memfile_get_block_pointer+0x38>
200e9f4: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
200e9f8: 80 a0 60 00 cmp %g1, 0
200e9fc: 02 80 00 17 be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200ea00: bb 2a 20 02 sll %o0, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
200ea04: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p )
200ea08: 80 a0 60 00 cmp %g1, 0
200ea0c: 02 80 00 13 be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200ea10: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
200ea14: b1 2f 20 02 sll %i4, 2, %i0
200ea18: 81 c7 e0 08 ret
200ea1c: 91 e8 40 18 restore %g1, %i0, %o0
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
200ea20: 80 a2 20 00 cmp %o0, 0
200ea24: 02 80 00 0d be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200ea28: b7 2e e0 02 sll %i3, 2, %i3
return 0;
p1 = (block_p *) p[ triply ];
200ea2c: c2 02 00 1b ld [ %o0 + %i3 ], %g1
if ( !p1 )
200ea30: 80 a0 60 00 cmp %g1, 0
200ea34: 02 80 00 09 be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200ea38: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
200ea3c: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
200ea40: 80 a0 60 00 cmp %g1, 0
200ea44: 02 80 00 05 be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200ea48: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
200ea4c: b1 2c 20 02 sll %l0, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
200ea50: 81 c7 e0 08 ret
200ea54: 91 e8 40 18 restore %g1, %i0, %o0
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
return 0;
200ea58: 81 c7 e0 08 ret <== NOT EXECUTED
200ea5c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
200ea60: 7f ff ff 78 call 200e840 <memfile_alloc_block>
200ea64: 01 00 00 00 nop
if ( !p1 )
200ea68: 80 a2 20 00 cmp %o0, 0
200ea6c: 02 bf ff fb be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200ea70: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
200ea74: 10 bf ff d4 b 200e9c4 <IMFS_memfile_get_block_pointer+0x150>
200ea78: d0 27 40 00 st %o0, [ %i5 ]
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
200ea7c: 7f ff ff 71 call 200e840 <memfile_alloc_block>
200ea80: 01 00 00 00 nop
if ( !p2 )
200ea84: 80 a2 20 00 cmp %o0, 0
200ea88: 02 bf ff f4 be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200ea8c: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
200ea90: 10 bf ff b6 b 200e968 <IMFS_memfile_get_block_pointer+0xf4>
200ea94: d0 27 40 00 st %o0, [ %i5 ]
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
200ea98: 7f ff ff 6a call 200e840 <memfile_alloc_block>
200ea9c: 01 00 00 00 nop
if ( !p )
200eaa0: 82 92 20 00 orcc %o0, 0, %g1
200eaa4: 02 bf ff ed be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200eaa8: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
200eaac: 10 bf ff c1 b 200e9b0 <IMFS_memfile_get_block_pointer+0x13c>
200eab0: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
200eab4: 7f ff ff 63 call 200e840 <memfile_alloc_block>
200eab8: 01 00 00 00 nop
if ( !p1 )
200eabc: 84 92 20 00 orcc %o0, 0, %g2
200eac0: 02 bf ff e6 be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200eac4: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
200eac8: 10 bf ff a3 b 200e954 <IMFS_memfile_get_block_pointer+0xe0>
200eacc: c4 26 c0 00 st %g2, [ %i3 ]
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
200ead0: 7f ff ff 5c call 200e840 <memfile_alloc_block>
200ead4: 01 00 00 00 nop
if ( !p )
200ead8: 80 a2 20 00 cmp %o0, 0
200eadc: 02 bf ff df be 200ea58 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
200eae0: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
200eae4: 10 bf ff 97 b 200e940 <IMFS_memfile_get_block_pointer+0xcc>
200eae8: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
0200eaec <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200eaec: 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;
200eaf0: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
200eaf4: a4 10 00 18 mov %i0, %l2
* 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 ) {
200eaf8: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200eafc: a0 10 00 19 mov %i1, %l0
200eb00: a2 10 00 1a mov %i2, %l1
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
200eb04: 80 a0 60 05 cmp %g1, 5
200eb08: 02 80 00 68 be 200eca8 <IMFS_memfile_read+0x1bc>
200eb0c: a6 10 00 1b mov %i3, %l3
/*
* 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 )
200eb10: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
200eb14: 86 10 20 00 clr %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;
200eb18: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
200eb1c: c8 06 20 54 ld [ %i0 + 0x54 ], %g4
200eb20: 80 a0 c0 02 cmp %g3, %g2
200eb24: 04 80 00 42 ble 200ec2c <IMFS_memfile_read+0x140> <== ALWAYS TAKEN
200eb28: ba 07 00 1a add %i4, %i2, %i5
my_length = the_jnode->info.file.size - start;
200eb2c: b8 21 00 01 sub %g4, %g1, %i4 <== NOT EXECUTED
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200eb30: 33 00 80 77 sethi %hi(0x201dc00), %i1 <== NOT EXECUTED
200eb34: fa 06 63 08 ld [ %i1 + 0x308 ], %i5 ! 201df08 <imfs_memfile_bytes_per_block>
200eb38: 90 10 00 10 mov %l0, %o0
200eb3c: b7 3f 60 1f sra %i5, 0x1f, %i3
200eb40: 96 10 00 1d mov %i5, %o3
200eb44: 94 10 00 1b mov %i3, %o2
200eb48: 40 00 2b e4 call 2019ad8 <__moddi3>
200eb4c: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200eb50: 90 10 00 10 mov %l0, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200eb54: a8 10 00 09 mov %o1, %l4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200eb58: 94 10 00 1b mov %i3, %o2
200eb5c: 92 10 00 11 mov %l1, %o1
200eb60: 40 00 2a f3 call 201972c <__divdi3>
200eb64: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
200eb68: 80 a5 20 00 cmp %l4, 0
200eb6c: 02 80 00 37 be 200ec48 <IMFS_memfile_read+0x15c>
200eb70: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
200eb74: ba 27 40 14 sub %i5, %l4, %i5
200eb78: 80 a7 00 1d cmp %i4, %i5
200eb7c: 18 80 00 59 bgu 200ece0 <IMFS_memfile_read+0x1f4>
200eb80: a0 10 00 1c mov %i4, %l0
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200eb84: 90 10 00 12 mov %l2, %o0
200eb88: 92 10 00 1a mov %i2, %o1
200eb8c: 94 10 20 00 clr %o2
200eb90: 7f ff ff 39 call 200e874 <IMFS_memfile_get_block_pointer>
200eb94: b0 10 20 00 clr %i0
if ( !block_ptr )
200eb98: 80 a2 20 00 cmp %o0, 0
200eb9c: 02 80 00 22 be 200ec24 <IMFS_memfile_read+0x138> <== NEVER TAKEN
200eba0: 94 10 00 10 mov %l0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
200eba4: d2 02 00 00 ld [ %o0 ], %o1
200eba8: 90 10 00 13 mov %l3, %o0
200ebac: 40 00 08 5c call 2010d1c <memcpy>
200ebb0: 92 02 40 14 add %o1, %l4, %o1
200ebb4: fa 06 63 08 ld [ %i1 + 0x308 ], %i5
dest += to_copy;
200ebb8: b6 04 c0 10 add %l3, %l0, %i3
block++;
200ebbc: b4 06 a0 01 inc %i2
my_length -= to_copy;
200ebc0: b8 27 00 10 sub %i4, %l0, %i4
copied += to_copy;
200ebc4: b0 10 00 10 mov %l0, %i0
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200ebc8: 80 a7 00 1d cmp %i4, %i5
200ebcc: 1a 80 00 0e bcc 200ec04 <IMFS_memfile_read+0x118>
200ebd0: 94 10 20 00 clr %o2
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
200ebd4: 10 80 00 21 b 200ec58 <IMFS_memfile_read+0x16c>
200ebd8: 80 a7 20 00 cmp %i4, 0
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
200ebdc: d2 00 40 00 ld [ %g1 ], %o1
200ebe0: 40 00 08 4f call 2010d1c <memcpy>
200ebe4: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200ebe8: c2 06 63 08 ld [ %i1 + 0x308 ], %g1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
200ebec: b6 06 c0 1d add %i3, %i5, %i3
block++;
200ebf0: b4 06 a0 01 inc %i2
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200ebf4: 80 a0 40 1c cmp %g1, %i4
200ebf8: 18 80 00 17 bgu 200ec54 <IMFS_memfile_read+0x168>
200ebfc: b0 06 00 1d add %i0, %i5, %i0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200ec00: 94 10 20 00 clr %o2
200ec04: 92 10 00 1a mov %i2, %o1
200ec08: 7f ff ff 1b call 200e874 <IMFS_memfile_get_block_pointer>
200ec0c: 90 10 00 12 mov %l2, %o0
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
200ec10: 94 10 00 1d mov %i5, %o2
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200ec14: 82 10 00 08 mov %o0, %g1
if ( !block_ptr )
200ec18: 80 a0 60 00 cmp %g1, 0
200ec1c: 12 bf ff f0 bne 200ebdc <IMFS_memfile_read+0xf0> <== ALWAYS TAKEN
200ec20: 90 10 00 1b mov %i3, %o0
}
IMFS_update_atime( the_jnode );
return copied;
}
200ec24: 81 c7 e0 08 ret <== NOT EXECUTED
200ec28: 81 e8 00 00 restore <== NOT EXECUTED
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
200ec2c: 12 bf ff c2 bne 200eb34 <IMFS_memfile_read+0x48> <== NEVER TAKEN
200ec30: 33 00 80 77 sethi %hi(0x201dc00), %i1
200ec34: 80 a7 40 04 cmp %i5, %g4
200ec38: 08 bf ff c0 bleu 200eb38 <IMFS_memfile_read+0x4c>
200ec3c: fa 06 63 08 ld [ %i1 + 0x308 ], %i5
my_length = the_jnode->info.file.size - start;
200ec40: 10 bf ff bd b 200eb34 <IMFS_memfile_read+0x48>
200ec44: b8 21 00 01 sub %g4, %g1, %i4
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
200ec48: b6 10 00 13 mov %l3, %i3
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
200ec4c: 10 bf ff df b 200ebc8 <IMFS_memfile_read+0xdc>
200ec50: b0 10 20 00 clr %i0
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
200ec54: 80 a7 20 00 cmp %i4, 0
200ec58: 02 80 00 0e be 200ec90 <IMFS_memfile_read+0x1a4>
200ec5c: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200ec60: 90 10 00 12 mov %l2, %o0
200ec64: 92 10 00 1a mov %i2, %o1
200ec68: 7f ff ff 03 call 200e874 <IMFS_memfile_get_block_pointer>
200ec6c: 94 10 20 00 clr %o2
if ( !block_ptr )
200ec70: 80 a2 20 00 cmp %o0, 0
200ec74: 02 bf ff ec be 200ec24 <IMFS_memfile_read+0x138> <== NEVER TAKEN
200ec78: 94 10 00 1c mov %i4, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
200ec7c: d2 02 00 00 ld [ %o0 ], %o1
200ec80: 90 10 00 1b mov %i3, %o0
200ec84: 40 00 08 26 call 2010d1c <memcpy>
200ec88: b0 06 00 1c add %i0, %i4, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
200ec8c: 90 07 bf f8 add %fp, -8, %o0
200ec90: 7f ff d2 a2 call 2003718 <gettimeofday>
200ec94: 92 10 20 00 clr %o1
200ec98: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ec9c: c2 24 a0 40 st %g1, [ %l2 + 0x40 ]
return copied;
}
200eca0: 81 c7 e0 08 ret
200eca4: 81 e8 00 00 restore
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
200eca8: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
200ecac: 82 10 20 00 clr %g1
200ecb0: 86 a6 c0 11 subcc %i3, %l1, %g3
200ecb4: 84 66 80 19 subx %i2, %i1, %g2
200ecb8: 80 a0 40 02 cmp %g1, %g2
200ecbc: 04 80 00 0b ble 200ece8 <IMFS_memfile_read+0x1fc> <== ALWAYS TAKEN
200ecc0: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
my_length = the_jnode->info.linearfile.size - start;
200ecc4: b0 26 c0 11 sub %i3, %l1, %i0 <== NOT EXECUTED
memcpy(dest, &file_ptr[start], my_length);
200ecc8: 92 02 40 11 add %o1, %l1, %o1
200eccc: 94 10 00 18 mov %i0, %o2
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
200ecd0: 40 00 08 13 call 2010d1c <memcpy>
200ecd4: 90 10 00 13 mov %l3, %o0
copied += my_length;
}
IMFS_update_atime( the_jnode );
200ecd8: 10 bf ff ee b 200ec90 <IMFS_memfile_read+0x1a4>
200ecdc: 90 07 bf f8 add %fp, -8, %o0
200ece0: 10 bf ff a9 b 200eb84 <IMFS_memfile_read+0x98>
200ece4: a0 10 00 1d mov %i5, %l0
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
200ece8: 12 80 00 04 bne 200ecf8 <IMFS_memfile_read+0x20c> <== NEVER TAKEN
200ecec: 80 a7 00 03 cmp %i4, %g3
200ecf0: 38 bf ff f6 bgu,a 200ecc8 <IMFS_memfile_read+0x1dc> <== ALWAYS TAKEN
200ecf4: b0 26 c0 11 sub %i3, %l1, %i0
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
200ecf8: 10 bf ff f4 b 200ecc8 <IMFS_memfile_read+0x1dc> <== NOT EXECUTED
200ecfc: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
0200ee10 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
200ee10: 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;
200ee14: 39 00 80 77 sethi %hi(0x201dc00), %i4
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
200ee18: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
/*
* 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;
200ee1c: f4 07 23 08 ld [ %i4 + 0x308 ], %i2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
200ee20: 80 a0 60 00 cmp %g1, 0
200ee24: 02 80 00 05 be 200ee38 <IMFS_memfile_remove+0x28>
200ee28: b5 36 a0 02 srl %i2, 2, %i2
memfile_free_blocks_in_table( &info->indirect, to_free );
200ee2c: 90 06 20 58 add %i0, 0x58, %o0
200ee30: 7f ff ff e2 call 200edb8 <memfile_free_blocks_in_table>
200ee34: 92 10 00 1a mov %i2, %o1
}
if ( info->doubly_indirect ) {
200ee38: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200ee3c: 80 a0 60 00 cmp %g1, 0
200ee40: 02 80 00 1b be 200eeac <IMFS_memfile_remove+0x9c>
200ee44: c4 07 23 08 ld [ %i4 + 0x308 ], %g2
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
200ee48: 85 30 a0 02 srl %g2, 2, %g2
200ee4c: 80 a0 a0 00 cmp %g2, 0
200ee50: 02 80 00 14 be 200eea0 <IMFS_memfile_remove+0x90> <== NEVER TAKEN
200ee54: 90 10 20 00 clr %o0
200ee58: 37 00 80 77 sethi %hi(0x201dc00), %i3
200ee5c: ba 10 20 00 clr %i5
200ee60: 10 80 00 03 b 200ee6c <IMFS_memfile_remove+0x5c>
200ee64: b6 16 e3 08 or %i3, 0x308, %i3
200ee68: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( info->doubly_indirect[i] ) {
200ee6c: 91 2a 20 02 sll %o0, 2, %o0
200ee70: c4 00 40 08 ld [ %g1 + %o0 ], %g2
200ee74: 80 a0 a0 00 cmp %g2, 0
200ee78: 02 80 00 04 be 200ee88 <IMFS_memfile_remove+0x78> <== NEVER TAKEN
200ee7c: 90 00 40 08 add %g1, %o0, %o0
memfile_free_blocks_in_table(
200ee80: 7f ff ff ce call 200edb8 <memfile_free_blocks_in_table>
200ee84: 92 10 00 1a mov %i2, %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++ ) {
200ee88: c2 06 c0 00 ld [ %i3 ], %g1
200ee8c: ba 07 60 01 inc %i5
200ee90: 83 30 60 02 srl %g1, 2, %g1
200ee94: 80 a7 40 01 cmp %i5, %g1
200ee98: 0a bf ff f4 bcs 200ee68 <IMFS_memfile_remove+0x58>
200ee9c: 90 10 00 1d mov %i5, %o0
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 );
200eea0: 90 06 20 5c add %i0, 0x5c, %o0
200eea4: 7f ff ff c5 call 200edb8 <memfile_free_blocks_in_table>
200eea8: 92 10 00 1a mov %i2, %o1
}
if ( info->triply_indirect ) {
200eeac: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
200eeb0: 80 a2 20 00 cmp %o0, 0
200eeb4: 02 80 00 33 be 200ef80 <IMFS_memfile_remove+0x170>
200eeb8: c4 07 23 08 ld [ %i4 + 0x308 ], %g2
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
200eebc: 85 30 a0 02 srl %g2, 2, %g2
200eec0: 80 a0 a0 00 cmp %g2, 0
200eec4: 22 80 00 2d be,a 200ef78 <IMFS_memfile_remove+0x168> <== NEVER TAKEN
200eec8: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
200eecc: f8 02 00 00 ld [ %o0 ], %i4
if ( !p ) /* ensure we have a valid pointer */
200eed0: 80 a7 20 00 cmp %i4, 0
200eed4: 22 80 00 29 be,a 200ef78 <IMFS_memfile_remove+0x168> <== NEVER TAKEN
200eed8: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
200eedc: 37 00 80 77 sethi %hi(0x201dc00), %i3
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
200eee0: a0 10 20 00 clr %l0
if ( !p ) /* ensure we have a valid pointer */
200eee4: b2 10 20 00 clr %i1
200eee8: b6 16 e3 08 or %i3, 0x308, %i3
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
200eeec: 80 a0 a0 00 cmp %g2, 0
200eef0: 22 80 00 13 be,a 200ef3c <IMFS_memfile_remove+0x12c> <== NEVER TAKEN
200eef4: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED
200eef8: 90 10 20 00 clr %o0
200eefc: ba 10 20 00 clr %i5
if ( p[j] ) {
200ef00: 91 2a 20 02 sll %o0, 2, %o0
200ef04: c2 07 00 08 ld [ %i4 + %o0 ], %g1
200ef08: 80 a0 60 00 cmp %g1, 0
200ef0c: 02 80 00 04 be 200ef1c <IMFS_memfile_remove+0x10c> <== NEVER TAKEN
200ef10: 90 07 00 08 add %i4, %o0, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
200ef14: 7f ff ff a9 call 200edb8 <memfile_free_blocks_in_table>
200ef18: 92 10 00 1a mov %i2, %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++ ) {
200ef1c: c2 06 c0 00 ld [ %i3 ], %g1
200ef20: ba 07 60 01 inc %i5
200ef24: 83 30 60 02 srl %g1, 2, %g1
200ef28: 80 a7 40 01 cmp %i5, %g1
200ef2c: 0a bf ff f5 bcs 200ef00 <IMFS_memfile_remove+0xf0>
200ef30: 90 10 00 1d mov %i5, %o0
200ef34: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
200ef38: 90 02 00 10 add %o0, %l0, %o0
200ef3c: 7f ff ff 9f call 200edb8 <memfile_free_blocks_in_table>
200ef40: 92 10 00 1a mov %i2, %o1
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
200ef44: c4 06 c0 00 ld [ %i3 ], %g2
200ef48: b2 06 60 01 inc %i1
200ef4c: 85 30 a0 02 srl %g2, 2, %g2
200ef50: 80 a6 40 02 cmp %i1, %g2
200ef54: 1a 80 00 09 bcc 200ef78 <IMFS_memfile_remove+0x168>
200ef58: 90 06 20 60 add %i0, 0x60, %o0
p = (block_p *) info->triply_indirect[i];
200ef5c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
* 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(
200ef60: a1 2e 60 02 sll %i1, 2, %l0
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
200ef64: f8 02 00 10 ld [ %o0 + %l0 ], %i4
if ( !p ) /* ensure we have a valid pointer */
200ef68: 80 a7 20 00 cmp %i4, 0
200ef6c: 12 bf ff e1 bne 200eef0 <IMFS_memfile_remove+0xe0> <== ALWAYS TAKEN
200ef70: 80 a0 a0 00 cmp %g2, 0
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
200ef74: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
200ef78: 7f ff ff 90 call 200edb8 <memfile_free_blocks_in_table>
200ef7c: 92 10 00 1a mov %i2, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
200ef80: 81 c7 e0 08 ret
200ef84: 81 e8 00 00 restore
0200ef88 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200ef88: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200ef8c: 94 10 20 00 clr %o2 <== NOT EXECUTED
200ef90: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200ef94: 7f ff fe 38 call 200e874 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
200ef98: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200ef9c: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
200efa0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
200efa4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
IMFS_assert( block_ptr );
ptr = *block_ptr;
*block_ptr = 0;
memfile_free_block( ptr );
200efa8: 7f ff ff 7b call 200ed94 <memfile_free_block> <== NOT EXECUTED
200efac: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
200efb0: 81 c7 e0 08 ret <== NOT EXECUTED
200efb4: 81 e8 00 00 restore <== NOT EXECUTED
0200f17c <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
200f17c: 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 ) {
200f180: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200f184: 84 10 20 00 clr %g2
/*
* 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;
200f188: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
200f18c: 80 a0 80 01 cmp %g2, %g1
200f190: 14 80 00 5e bg 200f308 <IMFS_memfile_write+0x18c> <== NEVER TAKEN
200f194: c6 06 20 54 ld [ %i0 + 0x54 ], %g3
200f198: 80 a0 80 01 cmp %g2, %g1
200f19c: 02 80 00 59 be 200f300 <IMFS_memfile_write+0x184> <== ALWAYS TAKEN
200f1a0: 80 a2 c0 03 cmp %o3, %g3
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200f1a4: 21 00 80 77 sethi %hi(0x201dc00), %l0 <== NOT EXECUTED
200f1a8: fa 04 23 08 ld [ %l0 + 0x308 ], %i5 ! 201df08 <imfs_memfile_bytes_per_block>
200f1ac: 90 10 00 19 mov %i1, %o0
200f1b0: a3 3f 60 1f sra %i5, 0x1f, %l1
200f1b4: 92 10 00 1a mov %i2, %o1
200f1b8: 94 10 00 11 mov %l1, %o2
200f1bc: 40 00 2a 47 call 2019ad8 <__moddi3>
200f1c0: 96 10 00 1d mov %i5, %o3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200f1c4: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200f1c8: a4 10 00 09 mov %o1, %l2
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200f1cc: 94 10 00 11 mov %l1, %o2
200f1d0: 92 10 00 1a mov %i2, %o1
200f1d4: 40 00 29 56 call 201972c <__divdi3>
200f1d8: 96 10 00 1d mov %i5, %o3
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
200f1dc: b2 10 20 00 clr %i1
/*
* 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 ) {
200f1e0: 80 a4 a0 00 cmp %l2, 0
200f1e4: 02 80 00 16 be 200f23c <IMFS_memfile_write+0xc0>
200f1e8: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
200f1ec: b2 27 40 12 sub %i5, %l2, %i1
200f1f0: 80 a6 40 1c cmp %i1, %i4
200f1f4: 38 80 00 02 bgu,a 200f1fc <IMFS_memfile_write+0x80>
200f1f8: b2 10 00 1c mov %i4, %i1
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200f1fc: 90 10 00 18 mov %i0, %o0
200f200: 92 10 00 1a mov %i2, %o1
200f204: 7f ff fd 9c call 200e874 <IMFS_memfile_get_block_pointer>
200f208: 94 10 20 00 clr %o2
if ( !block_ptr )
200f20c: 80 a2 20 00 cmp %o0, 0
200f210: 02 80 00 22 be 200f298 <IMFS_memfile_write+0x11c> <== NEVER TAKEN
200f214: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
200f218: d0 02 00 00 ld [ %o0 ], %o0
200f21c: 92 10 00 1b mov %i3, %o1
200f220: 90 02 00 12 add %o0, %l2, %o0
200f224: 40 00 06 be call 2010d1c <memcpy>
200f228: 94 10 00 19 mov %i1, %o2
200f22c: fa 04 23 08 ld [ %l0 + 0x308 ], %i5
src += to_copy;
200f230: b6 06 c0 19 add %i3, %i1, %i3
block++;
200f234: b4 06 a0 01 inc %i2
my_length -= to_copy;
200f238: b8 27 00 19 sub %i4, %i1, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200f23c: 80 a7 00 1d cmp %i4, %i5
200f240: 1a 80 00 0e bcc 200f278 <IMFS_memfile_write+0xfc>
200f244: 92 10 00 1a mov %i2, %o1
* 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 ) {
200f248: 10 80 00 17 b 200f2a4 <IMFS_memfile_write+0x128>
200f24c: 80 a7 20 00 cmp %i4, 0
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
200f250: d0 02 00 00 ld [ %o0 ], %o0
200f254: 40 00 06 b2 call 2010d1c <memcpy>
200f258: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200f25c: c2 04 23 08 ld [ %l0 + 0x308 ], %g1
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
200f260: b6 06 c0 1d add %i3, %i5, %i3
block++;
200f264: b4 06 a0 01 inc %i2
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200f268: 80 a0 40 1c cmp %g1, %i4
200f26c: 18 80 00 0d bgu 200f2a0 <IMFS_memfile_write+0x124>
200f270: b2 06 40 1d add %i1, %i5, %i1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200f274: 92 10 00 1a mov %i2, %o1
200f278: 94 10 20 00 clr %o2
200f27c: 7f ff fd 7e call 200e874 <IMFS_memfile_get_block_pointer>
200f280: 90 10 00 18 mov %i0, %o0
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
200f284: 92 10 00 1b mov %i3, %o1
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
200f288: 80 a2 20 00 cmp %o0, 0
200f28c: 12 bf ff f1 bne 200f250 <IMFS_memfile_write+0xd4> <== ALWAYS TAKEN
200f290: 94 10 00 1d mov %i5, %o2
200f294: 82 10 00 19 mov %i1, %g1 <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200f298: 81 c7 e0 08 ret <== NOT EXECUTED
200f29c: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
* 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 ) {
200f2a0: 80 a7 20 00 cmp %i4, 0
200f2a4: 02 80 00 0f be 200f2e0 <IMFS_memfile_write+0x164>
200f2a8: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200f2ac: 90 10 00 18 mov %i0, %o0
200f2b0: 92 10 00 1a mov %i2, %o1
200f2b4: 7f ff fd 70 call 200e874 <IMFS_memfile_get_block_pointer>
200f2b8: 94 10 20 00 clr %o2
if ( !block_ptr )
200f2bc: 80 a2 20 00 cmp %o0, 0
200f2c0: 02 bf ff f6 be 200f298 <IMFS_memfile_write+0x11c> <== NEVER TAKEN
200f2c4: 82 10 00 19 mov %i1, %g1
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
200f2c8: d0 02 00 00 ld [ %o0 ], %o0
200f2cc: 92 10 00 1b mov %i3, %o1
200f2d0: 94 10 00 1c mov %i4, %o2
200f2d4: 40 00 06 92 call 2010d1c <memcpy>
200f2d8: b2 06 40 1c add %i1, %i4, %i1
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
200f2dc: 90 07 bf f8 add %fp, -8, %o0
200f2e0: 7f ff d1 0e call 2003718 <gettimeofday>
200f2e4: 92 10 20 00 clr %o1
200f2e8: c4 07 bf f8 ld [ %fp + -8 ], %g2
return copied;
200f2ec: 82 10 00 19 mov %i1, %g1
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
200f2f0: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
200f2f4: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
return copied;
}
200f2f8: 81 c7 e0 08 ret
200f2fc: 91 e8 00 01 restore %g0, %g1, %o0
* 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 ) {
200f300: 08 bf ff aa bleu 200f1a8 <IMFS_memfile_write+0x2c>
200f304: 21 00 80 77 sethi %hi(0x201dc00), %l0
bool zero_fill = start > the_jnode->info.file.size;
200f308: 80 a6 40 01 cmp %i1, %g1
200f30c: 04 80 00 0b ble 200f338 <IMFS_memfile_write+0x1bc> <== ALWAYS TAKEN
200f310: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
200f314: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200f318: 92 0a 60 01 and %o1, 1, %o1
200f31c: 7f ff ff 27 call 200efb8 <IMFS_memfile_extend>
200f320: 94 10 20 00 clr %o2
if ( status )
200f324: 82 92 20 00 orcc %o0, 0, %g1
200f328: 02 bf ff a0 be 200f1a8 <IMFS_memfile_write+0x2c>
200f32c: 21 00 80 77 sethi %hi(0x201dc00), %l0
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200f330: 81 c7 e0 08 ret
200f334: 91 e8 00 01 restore %g0, %g1, %o0
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
200f338: 02 80 00 0b be 200f364 <IMFS_memfile_write+0x1e8> <== ALWAYS TAKEN
200f33c: 80 a6 80 03 cmp %i2, %g3
200f340: 92 10 20 00 clr %o1 <== NOT EXECUTED
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
200f344: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200f348: 92 0a 60 01 and %o1, 1, %o1
200f34c: 7f ff ff 1b call 200efb8 <IMFS_memfile_extend>
200f350: 94 10 20 00 clr %o2
if ( status )
200f354: 82 92 20 00 orcc %o0, 0, %g1
200f358: 02 bf ff 94 be 200f1a8 <IMFS_memfile_write+0x2c>
200f35c: 21 00 80 77 sethi %hi(0x201dc00), %l0
200f360: 30 bf ff f4 b,a 200f330 <IMFS_memfile_write+0x1b4>
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
200f364: 18 bf ff ed bgu 200f318 <IMFS_memfile_write+0x19c>
200f368: 90 10 00 18 mov %i0, %o0
200f36c: 10 bf ff f7 b 200f348 <IMFS_memfile_write+0x1cc>
200f370: 92 10 20 00 clr %o1
02002e98 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2002e98: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
2002e9c: 03 00 00 3c sethi %hi(0xf000), %g1
2002ea0: 05 00 00 10 sethi %hi(0x4000), %g2
2002ea4: 82 0e c0 01 and %i3, %g1, %g1
2002ea8: 80 a0 40 02 cmp %g1, %g2
2002eac: 02 80 00 2b be 2002f58 <IMFS_mknod+0xc0>
2002eb0: 05 00 00 20 sethi %hi(0x8000), %g2
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
2002eb4: 80 a0 40 02 cmp %g1, %g2
2002eb8: 02 80 00 2a be 2002f60 <IMFS_mknod+0xc8>
2002ebc: 09 00 00 2c sethi %hi(0xb000), %g4
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
2002ec0: 05 00 00 08 sethi %hi(0x2000), %g2
2002ec4: 88 0e c0 04 and %i3, %g4, %g4
2002ec8: 80 a1 00 02 cmp %g4, %g2
2002ecc: 02 80 00 07 be 2002ee8 <IMFS_mknod+0x50>
2002ed0: 05 00 00 04 sethi %hi(0x1000), %g2
rtems_filesystem_split_dev_t(
dev,
info->device.major,
info->device.minor
);
} else if (S_ISFIFO( mode )) {
2002ed4: 80 a0 40 02 cmp %g1, %g2
2002ed8: 22 80 00 06 be,a 2002ef0 <IMFS_mknod+0x58> <== ALWAYS TAKEN
2002edc: 86 10 20 06 mov 6, %g3
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
2002ee0: 10 80 00 05 b 2002ef4 <IMFS_mknod+0x5c> <== NOT EXECUTED
2002ee4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
*type = IMFS_DEVICE;
rtems_filesystem_split_dev_t(
2002ee8: f8 3f bf e8 std %i4, [ %fp + -24 ]
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
*type = IMFS_DEVICE;
2002eec: 86 10 20 01 mov 1, %g3
2002ef0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
2002ef4: 82 00 e0 02 add %g3, 2, %g1
2002ef8: c4 00 a0 08 ld [ %g2 + 8 ], %g2
2002efc: 83 28 60 02 sll %g1, 2, %g1
2002f00: d2 00 80 01 ld [ %g2 + %g1 ], %o1
2002f04: 90 10 00 18 mov %i0, %o0
2002f08: 94 10 00 19 mov %i1, %o2
2002f0c: 96 10 00 1a mov %i2, %o3
2002f10: 98 10 00 1b mov %i3, %o4
2002f14: 40 00 24 2f call 200bfd0 <IMFS_create_node_with_control>
2002f18: 9a 07 bf e8 add %fp, -24, %o5
IMFS_jnode_t *new_node;
get_type_and_info_by_mode_and_dev( mode, dev, &type, &info );
new_node = IMFS_create_node( parentloc, type, name, namelen, mode, &info );
if ( new_node != NULL ) {
2002f1c: 80 a2 20 00 cmp %o0, 0
2002f20: 02 80 00 12 be 2002f68 <IMFS_mknod+0xd0>
2002f24: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = parentloc->node_access;
2002f28: fa 06 20 08 ld [ %i0 + 8 ], %i5
IMFS_update_ctime( parent );
2002f2c: 40 00 01 fb call 2003718 <gettimeofday>
2002f30: 90 07 bf e0 add %fp, -32, %o0
2002f34: c2 07 bf e0 ld [ %fp + -32 ], %g1
IMFS_update_mtime( parent );
2002f38: 90 07 bf e0 add %fp, -32, %o0
new_node = IMFS_create_node( parentloc, type, name, namelen, mode, &info );
if ( new_node != NULL ) {
IMFS_jnode_t *parent = parentloc->node_access;
IMFS_update_ctime( parent );
2002f3c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
2002f40: 40 00 01 f6 call 2003718 <gettimeofday>
2002f44: 92 10 20 00 clr %o1
2002f48: c2 07 bf e0 ld [ %fp + -32 ], %g1
2002f4c: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
2002f50: 81 c7 e0 08 ret
2002f54: 91 e8 20 00 restore %g0, 0, %o0
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
2002f58: 10 bf ff e6 b 2002ef0 <IMFS_mknod+0x58>
2002f5c: 86 10 20 00 clr %g3
} else if ( S_ISREG( mode ) ) {
*type = IMFS_MEMORY_FILE;
2002f60: 10 bf ff e4 b 2002ef0 <IMFS_mknod+0x58>
2002f64: 86 10 20 04 mov 4, %g3
} else {
rv = -1;
}
return rv;
}
2002f68: 81 c7 e0 08 ret
2002f6c: 91 e8 3f ff restore %g0, -1, %o0
02002f70 <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
2002f70: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
2002f74: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2002f78: 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;
2002f7c: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
2002f80: c4 00 80 00 ld [ %g2 ], %g2
2002f84: 80 a0 a0 00 cmp %g2, 0
2002f88: 12 80 00 0f bne 2002fc4 <IMFS_mount+0x54>
2002f8c: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
2002f90: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
2002f94: 80 a0 a0 00 cmp %g2, 0
2002f98: 12 80 00 05 bne 2002fac <IMFS_mount+0x3c> <== NEVER TAKEN
2002f9c: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
2002fa0: 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;
2002fa4: 81 c7 e0 08 ret
2002fa8: 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;
2002fac: 40 00 35 0b call 20103d8 <__errno> <== NOT EXECUTED
2002fb0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2002fb4: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
2002fb8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2002fbc: 81 c7 e0 08 ret <== NOT EXECUTED
2002fc0: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
2002fc4: 40 00 35 05 call 20103d8 <__errno>
2002fc8: b0 10 3f ff mov -1, %i0
2002fcc: 82 10 20 14 mov 0x14, %g1
2002fd0: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2002fd4: 81 c7 e0 08 ret
2002fd8: 81 e8 00 00 restore
0200c460 <IMFS_node_remove_directory>:
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
200c460: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
200c464: 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 );
200c468: 82 06 20 54 add %i0, 0x54, %g1
200c46c: 80 a0 80 01 cmp %g2, %g1
200c470: 12 80 00 08 bne 200c490 <IMFS_node_remove_directory+0x30>
200c474: 01 00 00 00 nop
errno = ENOTEMPTY;
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
200c478: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200c47c: 80 a0 60 00 cmp %g1, 0
200c480: 12 80 00 0a bne 200c4a8 <IMFS_node_remove_directory+0x48> <== NEVER TAKEN
200c484: 01 00 00 00 nop
errno = EBUSY;
node = NULL;
}
return node;
}
200c488: 81 c7 e0 08 ret
200c48c: 81 e8 00 00 restore
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
errno = ENOTEMPTY;
200c490: 40 00 0f d2 call 20103d8 <__errno>
200c494: b0 10 20 00 clr %i0
200c498: 82 10 20 5a mov 0x5a, %g1
200c49c: c2 22 00 00 st %g1, [ %o0 ]
200c4a0: 81 c7 e0 08 ret
200c4a4: 81 e8 00 00 restore
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
errno = EBUSY;
200c4a8: 40 00 0f cc call 20103d8 <__errno> <== NOT EXECUTED
200c4ac: b0 10 20 00 clr %i0 <== NOT EXECUTED
200c4b0: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
200c4b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
node = NULL;
}
return node;
}
200c4b8: 81 c7 e0 08 ret <== NOT EXECUTED
200c4bc: 81 e8 00 00 restore <== NOT EXECUTED
02002fdc <IMFS_node_type>:
rtems_filesystem_node_types_t IMFS_node_type(
const rtems_filesystem_location_info_t *loc
)
{
const IMFS_jnode_t *node = loc->node_access;
2002fdc: c4 02 20 08 ld [ %o0 + 8 ], %g2
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
2002fe0: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
2002fe4: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_types_t imfs_type = IMFS_type( node );
rtems_filesystem_node_types_t type;
switch ( imfs_type ) {
2002fe8: 80 a0 60 02 cmp %g1, 2
2002fec: 02 80 00 06 be 2003004 <IMFS_node_type+0x28>
2002ff0: 80 a0 60 05 cmp %g1, 5
2002ff4: 02 80 00 08 be 2003014 <IMFS_node_type+0x38> <== NEVER TAKEN
2002ff8: 90 10 20 04 mov 4, %o0
type = imfs_type;
break;
}
return type;
}
2002ffc: 81 c3 e0 08 retl
2003000: 90 10 00 01 mov %g1, %o0
2003004: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
2003008: c2 00 60 4c ld [ %g1 + 0x4c ], %g1
rtems_filesystem_node_types_t type;
switch ( imfs_type ) {
case IMFS_HARD_LINK:
type = IMFS_type( node->info.hard_link.link_node );
break;
200300c: 81 c3 e0 08 retl
2003010: d0 00 40 00 ld [ %g1 ], %o0
2003014: 81 c3 e0 08 retl <== NOT EXECUTED
0200301c <IMFS_readlink>:
node = loc->node_access;
IMFS_assert( node->control->imfs_type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
200301c: 80 a2 a0 00 cmp %o2, 0
2003020: 02 80 00 16 be 2003078 <IMFS_readlink+0x5c> <== NEVER TAKEN
2003024: c8 02 20 08 ld [ %o0 + 8 ], %g4
2003028: c2 01 20 50 ld [ %g4 + 0x50 ], %g1
200302c: c4 48 40 00 ldsb [ %g1 ], %g2
2003030: 80 a0 a0 00 cmp %g2, 0
2003034: 02 80 00 11 be 2003078 <IMFS_readlink+0x5c> <== NEVER TAKEN
2003038: c2 08 40 00 ldub [ %g1 ], %g1
200303c: 84 10 20 00 clr %g2
2003040: 10 80 00 07 b 200305c <IMFS_readlink+0x40>
2003044: 90 10 20 00 clr %o0
2003048: c2 01 20 50 ld [ %g4 + 0x50 ], %g1
200304c: c6 48 40 08 ldsb [ %g1 + %o0 ], %g3
2003050: 80 a0 e0 00 cmp %g3, 0
2003054: 02 80 00 07 be 2003070 <IMFS_readlink+0x54>
2003058: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
buf[i] = node->info.sym_link.name[i];
200305c: c2 2a 40 02 stb %g1, [ %o1 + %g2 ]
node = loc->node_access;
IMFS_assert( node->control->imfs_type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
2003060: 90 02 20 01 inc %o0
2003064: 80 a2 00 0a cmp %o0, %o2
2003068: 12 bf ff f8 bne 2003048 <IMFS_readlink+0x2c>
200306c: 84 10 00 08 mov %o0, %g2
buf[i] = node->info.sym_link.name[i];
return i;
}
2003070: 81 c3 e0 08 retl
2003074: 01 00 00 00 nop
2003078: 81 c3 e0 08 retl <== NOT EXECUTED
200307c: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
02003080 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
2003080: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
2003084: fa 06 60 08 ld [ %i1 + 8 ], %i5
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
2003088: c2 07 60 08 ld [ %i5 + 8 ], %g1
200308c: 80 a0 60 00 cmp %g1, 0
2003090: 02 80 00 22 be 2003118 <IMFS_rename+0x98> <== NEVER TAKEN
2003094: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
2003098: 80 a7 20 1f cmp %i4, 0x1f
200309c: 18 80 00 19 bgu 2003100 <IMFS_rename+0x80> <== NEVER TAKEN
20030a0: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
20030a4: 92 10 00 1b mov %i3, %o1
20030a8: 40 00 37 1d call 2010d1c <memcpy>
20030ac: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
20030b0: b8 07 40 1c add %i5, %i4, %i4
20030b4: c0 2f 20 0c clrb [ %i4 + 0xc ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
20030b8: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
20030bc: c4 07 40 00 ld [ %i5 ], %g2
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
20030c0: 86 06 a0 54 add %i2, 0x54, %g3
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
20030c4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
20030c8: c4 20 40 00 st %g2, [ %g1 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
20030cc: c2 06 a0 58 ld [ %i2 + 0x58 ], %g1
static inline void IMFS_add_to_directory(
IMFS_jnode_t *dir,
IMFS_jnode_t *node
)
{
node->Parent = dir;
20030d0: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
20030d4: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
20030d8: fa 26 a0 58 st %i5, [ %i2 + 0x58 ]
old_last->next = the_node;
20030dc: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
20030e0: c2 27 60 04 st %g1, [ %i5 + 4 ]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
20030e4: 90 07 bf f8 add %fp, -8, %o0
20030e8: 40 00 01 8c call 2003718 <gettimeofday>
20030ec: 92 10 20 00 clr %o1
20030f0: c2 07 bf f8 ld [ %fp + -8 ], %g1
20030f4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
20030f8: 81 c7 e0 08 ret
20030fc: 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;
2003100: 40 00 34 b6 call 20103d8 <__errno> <== NOT EXECUTED
2003104: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003108: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
200310c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2003110: 81 c7 e0 08 ret <== NOT EXECUTED
2003114: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
2003118: 40 00 34 b0 call 20103d8 <__errno> <== NOT EXECUTED
200311c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003120: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003124: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003128: 81 c7 e0 08 ret <== NOT EXECUTED
200312c: 81 e8 00 00 restore <== NOT EXECUTED
0200321c <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
200321c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
2003220: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2003224: 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;
2003228: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
200322c: c4 00 80 00 ld [ %g2 ], %g2
2003230: 80 a0 a0 00 cmp %g2, 0
2003234: 12 80 00 0f bne 2003270 <IMFS_unmount+0x54> <== NEVER TAKEN
2003238: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
200323c: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
2003240: 80 a0 80 18 cmp %g2, %i0
2003244: 12 80 00 05 bne 2003258 <IMFS_unmount+0x3c> <== NEVER TAKEN
2003248: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
200324c: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
2003250: 81 c7 e0 08 ret
2003254: 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;
2003258: 40 00 34 60 call 20103d8 <__errno> <== NOT EXECUTED
200325c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003260: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003264: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2003268: 81 c7 e0 08 ret <== NOT EXECUTED
200326c: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
2003270: 40 00 34 5a call 20103d8 <__errno> <== NOT EXECUTED
2003274: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003278: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
200327c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003280: 81 c7 e0 08 ret <== NOT EXECUTED
2003284: 81 e8 00 00 restore <== NOT EXECUTED
02003918 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
2003918: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
200391c: 03 00 80 6d sethi %hi(0x201b400), %g1
2003920: c2 08 60 f9 ldub [ %g1 + 0xf9 ], %g1 ! 201b4f9 <Configuration+0x31>
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Control *heap = RTEMS_Malloc_Heap;
2003924: 05 00 80 75 sethi %hi(0x201d400), %g2
if ( !rtems_configuration_get_unified_work_area() ) {
2003928: 80 a0 60 00 cmp %g1, 0
200392c: 12 80 00 17 bne 2003988 <RTEMS_Malloc_Initialize+0x70>
2003930: f6 00 a3 00 ld [ %g2 + 0x300 ], %i3
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
2003934: 80 a6 60 00 cmp %i1, 0
2003938: 02 80 00 23 be 20039c4 <RTEMS_Malloc_Initialize+0xac>
200393c: 21 00 80 23 sethi %hi(0x2008c00), %l0
2003940: ba 10 20 00 clr %i5
2003944: a0 14 22 6c or %l0, 0x26c, %l0
2003948: b8 10 00 10 mov %l0, %i4
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
200394c: d2 06 00 00 ld [ %i0 ], %o1
2003950: d4 06 20 04 ld [ %i0 + 4 ], %o2
2003954: 90 10 00 1b mov %i3, %o0
2003958: 9f c7 00 00 call %i4
200395c: 96 10 20 08 mov 8, %o3
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
2003960: 80 a2 20 00 cmp %o0, 0
2003964: 32 80 00 02 bne,a 200396c <RTEMS_Malloc_Initialize+0x54> <== ALWAYS TAKEN
2003968: b8 10 00 1a mov %i2, %i4
if ( !rtems_configuration_get_unified_work_area() ) {
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
200396c: ba 07 60 01 inc %i5
2003970: 80 a7 40 19 cmp %i5, %i1
2003974: 12 bf ff f6 bne 200394c <RTEMS_Malloc_Initialize+0x34> <== NEVER TAKEN
2003978: b0 06 20 08 add %i0, 8, %i0
if ( space_available > 0 ) {
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
200397c: 80 a7 00 10 cmp %i4, %l0
2003980: 02 80 00 12 be 20039c8 <RTEMS_Malloc_Initialize+0xb0> <== NEVER TAKEN
2003984: 90 10 20 00 clr %o0
}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
2003988: 03 00 80 77 sethi %hi(0x201dc00), %g1
200398c: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 ! 201dee0 <rtems_malloc_statistics_helpers>
2003990: 80 a0 60 00 cmp %g1, 0
2003994: 02 80 00 05 be 20039a8 <RTEMS_Malloc_Initialize+0x90>
2003998: 3b 00 80 78 sethi %hi(0x201e000), %i5
(*rtems_malloc_statistics_helpers->initialize)();
200399c: c2 00 40 00 ld [ %g1 ], %g1
20039a0: 9f c0 40 00 call %g1
20039a4: 01 00 00 00 nop
}
MSBUMP( space_available, _Protected_heap_Get_size( heap ) );
20039a8: f8 07 61 a0 ld [ %i5 + 0x1a0 ], %i4
20039ac: 40 00 18 4c call 2009adc <_Protected_heap_Get_size>
20039b0: 90 10 00 1b mov %i3, %o0
20039b4: 90 02 00 1c add %o0, %i4, %o0
20039b8: d0 27 61 a0 st %o0, [ %i5 + 0x1a0 ]
20039bc: 81 c7 e0 08 ret
20039c0: 81 e8 00 00 restore
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
_Internal_error_Occurred(
20039c4: 90 10 20 00 clr %o0
20039c8: 92 10 20 01 mov 1, %o1
20039cc: 40 00 15 c5 call 20090e0 <_Internal_error_Occurred>
20039d0: 94 10 20 17 mov 0x17, %o2
02025ce8 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
2025ce8: 9d e3 bf 98 save %sp, -104, %sp
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
2025cec: 80 a6 3f ff cmp %i0, -1
2025cf0: 02 80 00 56 be 2025e48 <Stack_check_Dump_threads_usage+0x160>
2025cf4: ba 06 20 b4 add %i0, 0xb4, %i5
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
2025cf8: e2 06 21 40 ld [ %i0 + 0x140 ], %l1
2025cfc: f8 06 20 b8 ld [ %i0 + 0xb8 ], %i4
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
2025d00: f4 07 40 00 ld [ %i5 ], %i2
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
2025d04: 82 07 20 20 add %i4, 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);
2025d08: b4 06 bf f0 add %i2, -16, %i2
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
2025d0c: 86 0e bf fc and %i2, -4, %g3
2025d10: 86 00 40 03 add %g1, %g3, %g3
2025d14: 80 a0 40 03 cmp %g1, %g3
2025d18: 1a 80 00 10 bcc 2025d58 <Stack_check_Dump_threads_usage+0x70><== NEVER TAKEN
2025d1c: 05 29 69 69 sethi %hi(0xa5a5a400), %g2
if (*base != U32_PATTERN)
2025d20: c8 07 20 20 ld [ %i4 + 0x20 ], %g4
2025d24: 84 10 a1 a5 or %g2, 0x1a5, %g2
2025d28: 80 a1 00 02 cmp %g4, %g2
2025d2c: 22 80 00 08 be,a 2025d4c <Stack_check_Dump_threads_usage+0x64><== ALWAYS TAKEN
2025d30: 82 00 60 04 add %g1, 4, %g1
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
2025d34: 10 80 00 37 b 2025e10 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
2025d38: a0 07 20 10 add %i4, 0x10, %l0 <== NOT EXECUTED
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
2025d3c: 80 a0 80 04 cmp %g2, %g4
2025d40: 12 80 00 34 bne 2025e10 <Stack_check_Dump_threads_usage+0x128>
2025d44: a0 07 20 10 add %i4, 0x10, %l0
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
2025d48: 82 00 60 04 add %g1, 4, %g1
2025d4c: 80 a0 c0 01 cmp %g3, %g1
2025d50: 38 bf ff fb bgu,a 2025d3c <Stack_check_Dump_threads_usage+0x54><== ALWAYS TAKEN
2025d54: c4 00 40 00 ld [ %g1 ], %g2
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
2025d58: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
2025d5c: 02 80 00 31 be 2025e20 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
2025d60: a0 10 20 00 clr %l0 <== NOT EXECUTED
#endif
{
(*print_handler)(
2025d64: f2 06 20 08 ld [ %i0 + 8 ], %i1
2025d68: 39 00 81 9a sethi %hi(0x2066800), %i4
2025d6c: 37 00 81 9a sethi %hi(0x2066800), %i3
2025d70: e4 07 23 c4 ld [ %i4 + 0x3c4 ], %l2
2025d74: f0 06 e3 c8 ld [ %i3 + 0x3c8 ], %i0
2025d78: 94 07 bf f8 add %fp, -8, %o2
2025d7c: 92 10 20 05 mov 5, %o1
2025d80: 7f ff a8 29 call 200fe24 <rtems_object_get_name>
2025d84: 90 10 00 19 mov %i1, %o0
2025d88: 13 00 81 76 sethi %hi(0x205d800), %o1
2025d8c: 96 10 00 08 mov %o0, %o3
2025d90: 94 10 00 19 mov %i1, %o2
2025d94: 90 10 00 12 mov %l2, %o0
2025d98: 9f c6 00 00 call %i0
2025d9c: 92 12 63 90 or %o1, 0x390, %o1
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2025da0: d4 07 60 04 ld [ %i5 + 4 ], %o2
2025da4: d6 07 40 00 ld [ %i5 ], %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2025da8: c4 06 e3 c8 ld [ %i3 + 0x3c8 ], %g2
2025dac: d0 07 23 c4 ld [ %i4 + 0x3c4 ], %o0
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2025db0: 96 02 ff ff add %o3, -1, %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2025db4: 13 00 81 76 sethi %hi(0x205d800), %o1
2025db8: 96 02 80 0b add %o2, %o3, %o3
2025dbc: 92 12 63 b0 or %o1, 0x3b0, %o1
2025dc0: 98 10 00 11 mov %l1, %o4
2025dc4: 9f c0 80 00 call %g2
2025dc8: 9a 10 00 1a mov %i2, %o5
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
2025dcc: 05 00 81 9a sethi %hi(0x2066800), %g2
2025dd0: c4 00 a3 c0 ld [ %g2 + 0x3c0 ], %g2 ! 2066bc0 <Stack_check_Initialized>
(*print_handler)( print_context, "Unavailable\n" );
2025dd4: c2 06 e3 c8 ld [ %i3 + 0x3c8 ], %g1
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
2025dd8: 80 a0 a0 00 cmp %g2, 0
2025ddc: 12 80 00 07 bne 2025df8 <Stack_check_Dump_threads_usage+0x110><== ALWAYS TAKEN
2025de0: d0 07 23 c4 ld [ %i4 + 0x3c4 ], %o0
(*print_handler)( print_context, "Unavailable\n" );
2025de4: 13 00 81 76 sethi %hi(0x205d800), %o1 <== NOT EXECUTED
2025de8: 9f c0 40 00 call %g1 <== NOT EXECUTED
2025dec: 92 12 63 d0 or %o1, 0x3d0, %o1 ! 205dbd0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
2025df0: 81 c7 e0 08 ret <== NOT EXECUTED
2025df4: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
2025df8: 94 10 00 10 mov %l0, %o2
2025dfc: 13 00 81 76 sethi %hi(0x205d800), %o1
2025e00: 9f c0 40 00 call %g1
2025e04: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 205dbe0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x310>
2025e08: 81 c7 e0 08 ret
2025e0c: 81 e8 00 00 restore
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
2025e10: 80 a6 20 00 cmp %i0, 0
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 );
2025e14: a0 04 00 1a add %l0, %i2, %l0
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
2025e18: 12 bf ff d3 bne 2025d64 <Stack_check_Dump_threads_usage+0x7c>
2025e1c: a0 24 00 01 sub %l0, %g1, %l0
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 );
2025e20: 37 00 81 9a sethi %hi(0x2066800), %i3
2025e24: 39 00 81 9a sethi %hi(0x2066800), %i4
2025e28: c2 06 e3 c8 ld [ %i3 + 0x3c8 ], %g1
2025e2c: d0 07 23 c4 ld [ %i4 + 0x3c4 ], %o0
2025e30: 94 10 3f ff mov -1, %o2
2025e34: 13 00 81 76 sethi %hi(0x205d800), %o1
2025e38: 9f c0 40 00 call %g1
2025e3c: 92 12 63 a0 or %o1, 0x3a0, %o1 ! 205dba0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x2d0>
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2025e40: 10 bf ff d9 b 2025da4 <Stack_check_Dump_threads_usage+0xbc>
2025e44: d4 07 60 04 ld [ %i5 + 4 ], %o2
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
2025e48: 3b 00 81 9f sethi %hi(0x2067c00), %i5
2025e4c: ba 17 61 bc or %i5, 0x1bc, %i5 ! 2067dbc <Stack_check_Interrupt_stack>
2025e50: f8 07 60 04 ld [ %i5 + 4 ], %i4
2025e54: 80 a7 20 00 cmp %i4, 0
2025e58: 02 bf ff e6 be 2025df0 <Stack_check_Dump_threads_usage+0x108><== NEVER TAKEN
2025e5c: a2 10 20 00 clr %l1
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
2025e60: 10 bf ff a8 b 2025d00 <Stack_check_Dump_threads_usage+0x18>
2025e64: b0 10 20 00 clr %i0
02025f5c <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)
{
2025f5c: 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");
2025f60: 11 00 81 76 sethi %hi(0x205d800), %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);
2025f64: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5
char name[32];
printk("BLOWN STACK!!!\n");
2025f68: 7f ff 78 d8 call 20042c8 <printk>
2025f6c: 90 12 23 e8 or %o0, 0x3e8, %o0
printk("task control block: 0x%08" PRIxPTR "\n", running);
2025f70: 92 10 00 18 mov %i0, %o1
2025f74: 11 00 81 76 sethi %hi(0x205d800), %o0
2025f78: 7f ff 78 d4 call 20042c8 <printk>
2025f7c: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 205dbf8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328>
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
2025f80: d2 06 20 08 ld [ %i0 + 8 ], %o1
2025f84: 11 00 81 77 sethi %hi(0x205dc00), %o0
2025f88: 7f ff 78 d0 call 20042c8 <printk>
2025f8c: 90 12 20 18 or %o0, 0x18, %o0 ! 205dc18 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348>
printk(
2025f90: d2 06 20 0c ld [ %i0 + 0xc ], %o1
2025f94: 11 00 81 77 sethi %hi(0x205dc00), %o0
2025f98: 7f ff 78 cc call 20042c8 <printk>
2025f9c: 90 12 20 30 or %o0, 0x30, %o0 ! 205dc30 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360>
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
2025fa0: d0 06 20 08 ld [ %i0 + 8 ], %o0
2025fa4: 94 07 bf e0 add %fp, -32, %o2
2025fa8: 7f ff a7 9f call 200fe24 <rtems_object_get_name>
2025fac: 92 10 20 20 mov 0x20, %o1
2025fb0: 92 10 00 08 mov %o0, %o1
2025fb4: 11 00 81 77 sethi %hi(0x205dc00), %o0
2025fb8: 7f ff 78 c4 call 20042c8 <printk>
2025fbc: 90 12 20 48 or %o0, 0x48, %o0 ! 205dc48 <RTEMS_BDPART_MBR_MASTER_TYPE+0x378>
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
2025fc0: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2
2025fc4: 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(
2025fc8: 11 00 81 77 sethi %hi(0x205dc00), %o0
2025fcc: 96 02 80 09 add %o2, %o1, %o3
2025fd0: 7f ff 78 be call 20042c8 <printk>
2025fd4: 90 12 20 60 or %o0, 0x60, %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) {
2025fd8: 80 a6 60 00 cmp %i1, 0
2025fdc: 02 80 00 05 be 2025ff0 <Stack_check_report_blown_task+0x94><== ALWAYS TAKEN
2025fe0: 92 10 20 10 mov 0x10, %o1
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
2025fe4: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
2025fe8: 7f ff 88 18 call 2008048 <rtems_fatal>
2025fec: 90 10 20 09 mov 9, %o0
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
2025ff0: 11 00 81 77 sethi %hi(0x205dc00), %o0
2025ff4: 94 07 60 08 add %i5, 8, %o2
2025ff8: 90 12 20 90 or %o0, 0x90, %o0
2025ffc: 7f ff 78 b3 call 20042c8 <printk>
2026000: 96 07 60 18 add %i5, 0x18, %o3
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
2026004: 10 bf ff f9 b 2025fe8 <Stack_check_report_blown_task+0x8c>
2026008: d2 06 20 0c ld [ %i0 + 0xc ], %o1
0200854c <_API_extensions_Add_post_switch>:
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200854c: c2 02 00 00 ld [ %o0 ], %g1
2008550: 80 a0 60 00 cmp %g1, 0
2008554: 22 80 00 04 be,a 2008564 <_API_extensions_Add_post_switch+0x18>
2008558: c2 02 20 04 ld [ %o0 + 4 ], %g1
200855c: 81 c3 e0 08 retl
2008560: 01 00 00 00 nop
2008564: 80 a0 60 00 cmp %g1, 0
2008568: 12 bf ff fd bne 200855c <_API_extensions_Add_post_switch+0x10><== NEVER TAKEN
200856c: 03 00 80 78 sethi %hi(0x201e000), %g1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2008570: 82 10 63 94 or %g1, 0x394, %g1 ! 201e394 <_API_extensions_Post_switch_list>
2008574: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2008578: 86 00 60 04 add %g1, 4, %g3
tail->previous = the_node;
200857c: d0 20 60 08 st %o0, [ %g1 + 8 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
2008580: c6 22 00 00 st %g3, [ %o0 ]
tail->previous = the_node;
old_last->next = the_node;
2008584: d0 20 80 00 st %o0, [ %g2 ]
the_node->previous = old_last;
2008588: 81 c3 e0 08 retl
200858c: c4 22 20 04 st %g2, [ %o0 + 4 ]
02008590 <_API_extensions_Run_postdriver>:
}
}
#endif
void _API_extensions_Run_postdriver( void )
{
2008590: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2008594: 39 00 80 79 sethi %hi(0x201e400), %i4
2008598: fa 07 20 e8 ld [ %i4 + 0xe8 ], %i5 ! 201e4e8 <_API_extensions_List>
200859c: b8 17 20 e8 or %i4, 0xe8, %i4
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
20085a0: b8 07 20 04 add %i4, 4, %i4
20085a4: 80 a7 40 1c cmp %i5, %i4
20085a8: 02 80 00 09 be 20085cc <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN
20085ac: 01 00 00 00 nop
* Currently all APIs configure this hook so it is always non-NULL.
*/
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
20085b0: c2 07 60 08 ld [ %i5 + 8 ], %g1
20085b4: 9f c0 40 00 call %g1
20085b8: 01 00 00 00 nop
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
20085bc: fa 07 40 00 ld [ %i5 ], %i5
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
20085c0: 80 a7 40 1c cmp %i5, %i4
20085c4: 32 bf ff fc bne,a 20085b4 <_API_extensions_Run_postdriver+0x24>
20085c8: c2 07 60 08 ld [ %i5 + 8 ], %g1
20085cc: 81 c7 e0 08 ret
20085d0: 81 e8 00 00 restore
0200ac38 <_CORE_RWLock_Release>:
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
200ac38: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
200ac3c: 03 00 80 86 sethi %hi(0x2021800), %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 );
200ac40: 7f ff e3 5d call 20039b4 <sparc_disable_interrupts>
200ac44: fa 00 60 70 ld [ %g1 + 0x70 ], %i5 ! 2021870 <_Per_CPU_Information+0x10>
200ac48: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
200ac4c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
200ac50: 80 a0 60 00 cmp %g1, 0
200ac54: 02 80 00 2b be 200ad00 <_CORE_RWLock_Release+0xc8>
200ac58: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
200ac5c: 22 80 00 22 be,a 200ace4 <_CORE_RWLock_Release+0xac>
200ac60: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
200ac64: 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;
200ac68: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
200ac6c: 7f ff e3 56 call 20039c4 <sparc_enable_interrupts>
200ac70: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
200ac74: 40 00 08 28 call 200cd14 <_Thread_queue_Dequeue>
200ac78: 90 10 00 18 mov %i0, %o0
if ( next ) {
200ac7c: 80 a2 20 00 cmp %o0, 0
200ac80: 22 80 00 24 be,a 200ad10 <_CORE_RWLock_Release+0xd8>
200ac84: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
200ac88: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
200ac8c: 80 a0 60 01 cmp %g1, 1
200ac90: 02 80 00 22 be 200ad18 <_CORE_RWLock_Release+0xe0>
200ac94: 84 10 20 01 mov 1, %g2
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
200ac98: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200ac9c: 82 00 60 01 inc %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
200aca0: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
200aca4: 10 80 00 09 b 200acc8 <_CORE_RWLock_Release+0x90>
200aca8: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
200acac: 80 a0 60 01 cmp %g1, 1
200acb0: 02 80 00 0b be 200acdc <_CORE_RWLock_Release+0xa4> <== NEVER TAKEN
200acb4: 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;
200acb8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200acbc: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
200acc0: 40 00 09 25 call 200d154 <_Thread_queue_Extract>
200acc4: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
200acc8: 40 00 09 74 call 200d298 <_Thread_queue_First>
200accc: 90 10 00 18 mov %i0, %o0
if ( !next ||
200acd0: 92 92 20 00 orcc %o0, 0, %o1
200acd4: 32 bf ff f6 bne,a 200acac <_CORE_RWLock_Release+0x74>
200acd8: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
200acdc: 81 c7 e0 08 ret
200ace0: 91 e8 20 00 restore %g0, 0, %o0
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
200ace4: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
200ace8: 80 a0 60 00 cmp %g1, 0
200acec: 02 bf ff de be 200ac64 <_CORE_RWLock_Release+0x2c>
200acf0: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
200acf4: 7f ff e3 34 call 20039c4 <sparc_enable_interrupts>
200acf8: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
200acfc: 30 80 00 05 b,a 200ad10 <_CORE_RWLock_Release+0xd8>
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
200ad00: 7f ff e3 31 call 20039c4 <sparc_enable_interrupts>
200ad04: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
200ad08: 82 10 20 02 mov 2, %g1
200ad0c: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
200ad10: 81 c7 e0 08 ret
200ad14: 81 e8 00 00 restore
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
if ( next ) {
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
200ad18: 82 10 20 02 mov 2, %g1
200ad1c: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
200ad20: 81 c7 e0 08 ret
200ad24: 91 e8 20 00 restore %g0, 0, %o0
0200ad28 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
200ad28: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200ad2c: 90 10 00 18 mov %i0, %o0
200ad30: 40 00 07 1b call 200c99c <_Thread_Get>
200ad34: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200ad38: c2 07 bf fc ld [ %fp + -4 ], %g1
200ad3c: 80 a0 60 00 cmp %g1, 0
200ad40: 12 80 00 08 bne 200ad60 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
200ad44: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200ad48: 40 00 09 95 call 200d39c <_Thread_queue_Process_timeout>
200ad4c: 01 00 00 00 nop
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200ad50: 03 00 80 84 sethi %hi(0x2021000), %g1
200ad54: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2021340 <_Thread_Dispatch_disable_level>
--level;
200ad58: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
200ad5c: c4 20 63 40 st %g2, [ %g1 + 0x340 ]
200ad60: 81 c7 e0 08 ret
200ad64: 81 e8 00 00 restore
020088f0 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
20088f0: 9d e3 bf a0 save %sp, -96, %sp
* 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 )
20088f4: 3b 00 80 78 sethi %hi(0x201e000), %i5
20088f8: c2 07 63 20 ld [ %i5 + 0x320 ], %g1 ! 201e320 <_Thread_Dispatch_disable_level>
20088fc: 80 a0 60 00 cmp %g1, 0
2008900: 02 80 00 1f be 200897c <_CORE_mutex_Seize+0x8c>
2008904: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
2008908: 80 a6 a0 00 cmp %i2, 0
200890c: 02 80 00 2c be 20089bc <_CORE_mutex_Seize+0xcc>
2008910: 90 10 00 18 mov %i0, %o0
2008914: 03 00 80 7a sethi %hi(0x201e800), %g1
2008918: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 201e838 <_System_state_Current>
200891c: 80 a0 60 01 cmp %g1, 1
2008920: 38 80 00 2e bgu,a 20089d8 <_CORE_mutex_Seize+0xe8>
2008924: 90 10 20 00 clr %o0
2008928: 40 00 15 00 call 200dd28 <_CORE_mutex_Seize_interrupt_trylock>
200892c: 92 07 a0 54 add %fp, 0x54, %o1
2008930: 80 a2 20 00 cmp %o0, 0
2008934: 02 80 00 27 be 20089d0 <_CORE_mutex_Seize+0xe0> <== ALWAYS TAKEN
2008938: 01 00 00 00 nop
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200893c: c4 07 63 20 ld [ %i5 + 0x320 ], %g2
2008940: 03 00 80 7a sethi %hi(0x201e800), %g1
2008944: c2 00 60 50 ld [ %g1 + 0x50 ], %g1 ! 201e850 <_Per_CPU_Information+0x10>
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;
2008948: 86 10 20 01 mov 1, %g3
200894c: c6 26 20 30 st %g3, [ %i0 + 0x30 ]
2008950: f0 20 60 44 st %i0, [ %g1 + 0x44 ]
2008954: f2 20 60 20 st %i1, [ %g1 + 0x20 ]
++level;
2008958: 82 00 a0 01 add %g2, 1, %g1
_Thread_Dispatch_disable_level = level;
200895c: c2 27 63 20 st %g1, [ %i5 + 0x320 ]
2008960: 7f ff e7 2f call 200261c <sparc_enable_interrupts>
2008964: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
2008968: 90 10 00 18 mov %i0, %o0
200896c: 7f ff ff ba call 2008854 <_CORE_mutex_Seize_interrupt_blocking>
2008970: 92 10 00 1b mov %i3, %o1
2008974: 81 c7 e0 08 ret
2008978: 81 e8 00 00 restore
200897c: 90 10 00 18 mov %i0, %o0
2008980: 40 00 14 ea call 200dd28 <_CORE_mutex_Seize_interrupt_trylock>
2008984: 92 07 a0 54 add %fp, 0x54, %o1
2008988: 80 a2 20 00 cmp %o0, 0
200898c: 02 bf ff fa be 2008974 <_CORE_mutex_Seize+0x84>
2008990: 80 a6 a0 00 cmp %i2, 0
2008994: 12 bf ff ea bne 200893c <_CORE_mutex_Seize+0x4c>
2008998: 01 00 00 00 nop
200899c: 7f ff e7 20 call 200261c <sparc_enable_interrupts>
20089a0: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
20089a4: 03 00 80 7a sethi %hi(0x201e800), %g1
20089a8: c2 00 60 50 ld [ %g1 + 0x50 ], %g1 ! 201e850 <_Per_CPU_Information+0x10>
20089ac: 84 10 20 01 mov 1, %g2
20089b0: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
20089b4: 81 c7 e0 08 ret
20089b8: 81 e8 00 00 restore
20089bc: 40 00 14 db call 200dd28 <_CORE_mutex_Seize_interrupt_trylock>
20089c0: 92 07 a0 54 add %fp, 0x54, %o1
20089c4: 80 a2 20 00 cmp %o0, 0
20089c8: 12 bf ff f5 bne 200899c <_CORE_mutex_Seize+0xac> <== NEVER TAKEN
20089cc: 01 00 00 00 nop
20089d0: 81 c7 e0 08 ret
20089d4: 81 e8 00 00 restore
20089d8: 92 10 20 00 clr %o1
20089dc: 40 00 01 c1 call 20090e0 <_Internal_error_Occurred>
20089e0: 94 10 20 12 mov 0x12, %o2
02008b60 <_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
)
{
2008b60: 9d e3 bf a0 save %sp, -96, %sp
2008b64: ba 10 00 18 mov %i0, %i5
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
2008b68: b0 10 20 00 clr %i0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
2008b6c: 40 00 07 ed call 200ab20 <_Thread_queue_Dequeue>
2008b70: 90 10 00 1d mov %i5, %o0
2008b74: 80 a2 20 00 cmp %o0, 0
2008b78: 02 80 00 04 be 2008b88 <_CORE_semaphore_Surrender+0x28>
2008b7c: 01 00 00 00 nop
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
2008b80: 81 c7 e0 08 ret
2008b84: 81 e8 00 00 restore
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
2008b88: 7f ff e6 a1 call 200260c <sparc_disable_interrupts>
2008b8c: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
2008b90: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
2008b94: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
2008b98: 80 a0 40 02 cmp %g1, %g2
2008b9c: 1a 80 00 05 bcc 2008bb0 <_CORE_semaphore_Surrender+0x50> <== NEVER TAKEN
2008ba0: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
2008ba4: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
2008ba8: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
2008bac: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
2008bb0: 7f ff e6 9b call 200261c <sparc_enable_interrupts>
2008bb4: 01 00 00 00 nop
}
return status;
}
2008bb8: 81 c7 e0 08 ret
2008bbc: 81 e8 00 00 restore
02008720 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
2008720: 9d e3 bf a0 save %sp, -96, %sp
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
2008724: c0 26 20 04 clr [ %i0 + 4 ]
size_t node_size
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
2008728: ba 06 20 04 add %i0, 4, %i5
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
200872c: 80 a6 a0 00 cmp %i2, 0
2008730: 02 80 00 13 be 200877c <_Chain_Initialize+0x5c> <== NEVER TAKEN
2008734: 92 06 bf ff add %i2, -1, %o1
2008738: 86 10 00 09 mov %o1, %g3
200873c: 82 10 00 19 mov %i1, %g1
2008740: 84 10 00 18 mov %i0, %g2
current->next = next;
2008744: c2 20 80 00 st %g1, [ %g2 ]
next->previous = current;
2008748: c4 20 60 04 st %g2, [ %g1 + 4 ]
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
200874c: 86 00 ff ff add %g3, -1, %g3
2008750: 84 10 00 01 mov %g1, %g2
2008754: 80 a0 ff ff cmp %g3, -1
2008758: 12 bf ff fb bne 2008744 <_Chain_Initialize+0x24>
200875c: 82 00 40 1b add %g1, %i3, %g1
#include <rtems/system.h>
#include <rtems/score/address.h>
#include <rtems/score/chain.h>
#include <rtems/score/isr.h>
void _Chain_Initialize(
2008760: 40 00 42 61 call 20190e4 <.umul>
2008764: 90 10 00 1b mov %i3, %o0
2008768: 90 06 40 08 add %i1, %o0, %o0
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
200876c: fa 22 00 00 st %i5, [ %o0 ]
tail->previous = current;
2008770: d0 26 20 08 st %o0, [ %i0 + 8 ]
2008774: 81 c7 e0 08 ret
2008778: 81 e8 00 00 restore
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
200877c: 10 bf ff fc b 200876c <_Chain_Initialize+0x4c> <== NOT EXECUTED
2008780: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
020076cc <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
20076cc: 9d e3 bf a0 save %sp, -96, %sp
rtems_event_set seized_events;
rtems_option option_set;
option_set = the_thread->Wait.option;
_ISR_Disable( level );
20076d0: 7f ff eb cf call 200260c <sparc_disable_interrupts>
20076d4: fa 06 20 30 ld [ %i0 + 0x30 ], %i5
RTEMS_INLINE_ROUTINE void _Event_sets_Post(
rtems_event_set the_new_events,
rtems_event_set *the_event_set
)
{
*the_event_set |= the_new_events;
20076d8: c2 06 80 00 ld [ %i2 ], %g1
20076dc: b2 16 40 01 or %i1, %g1, %i1
20076e0: f2 26 80 00 st %i1, [ %i2 ]
_Event_sets_Post( event_in, &event->pending_events );
pending_events = event->pending_events;
event_condition = the_thread->Wait.count;
20076e4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
20076e8: 84 8e 40 01 andcc %i1, %g1, %g2
20076ec: 02 80 00 35 be 20077c0 <_Event_Surrender+0xf4>
20076f0: 07 00 80 7a sethi %hi(0x201e800), %g3
/*
* 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() &&
20076f4: 86 10 e0 40 or %g3, 0x40, %g3 ! 201e840 <_Per_CPU_Information>
20076f8: c8 00 e0 08 ld [ %g3 + 8 ], %g4
20076fc: 80 a1 20 00 cmp %g4, 0
2007700: 32 80 00 1c bne,a 2007770 <_Event_Surrender+0xa4>
2007704: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
2007708: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
200770c: 80 8f 00 03 btst %i4, %g3
2007710: 02 80 00 2c be 20077c0 <_Event_Surrender+0xf4>
2007714: 80 a0 40 02 cmp %g1, %g2
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
2007718: 02 80 00 04 be 2007728 <_Event_Surrender+0x5c>
200771c: 80 8f 60 02 btst 2, %i5
2007720: 02 80 00 28 be 20077c0 <_Event_Surrender+0xf4> <== NEVER TAKEN
2007724: 01 00 00 00 nop
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007728: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
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) );
200772c: b2 2e 40 02 andn %i1, %g2, %i1
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
event->pending_events = _Event_sets_Clear(
2007730: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
2007734: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007738: c4 20 40 00 st %g2, [ %g1 ]
_ISR_Flash( level );
200773c: 7f ff eb b8 call 200261c <sparc_enable_interrupts>
2007740: 01 00 00 00 nop
2007744: 7f ff eb b2 call 200260c <sparc_disable_interrupts>
2007748: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
200774c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
2007750: 80 a0 60 02 cmp %g1, 2
2007754: 02 80 00 1d be 20077c8 <_Event_Surrender+0xfc>
2007758: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
200775c: 7f ff eb b0 call 200261c <sparc_enable_interrupts>
2007760: 33 04 01 ff sethi %hi(0x1007fc00), %i1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
2007764: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_END+0xdc7fff8>
2007768: 40 00 0a ff call 200a364 <_Thread_Clear_state>
200776c: 81 e8 00 00 restore
/*
* 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() &&
2007770: 80 a6 00 03 cmp %i0, %g3
2007774: 32 bf ff e6 bne,a 200770c <_Event_Surrender+0x40>
2007778: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
200777c: c6 06 c0 00 ld [ %i3 ], %g3
2007780: 86 00 ff ff add %g3, -1, %g3
/*
* 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 ) &&
2007784: 80 a0 e0 01 cmp %g3, 1
2007788: 38 bf ff e1 bgu,a 200770c <_Event_Surrender+0x40>
200778c: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
2007790: 80 a0 40 02 cmp %g1, %g2
2007794: 02 80 00 04 be 20077a4 <_Event_Surrender+0xd8>
2007798: 80 8f 60 02 btst 2, %i5
200779c: 02 80 00 09 be 20077c0 <_Event_Surrender+0xf4> <== NEVER TAKEN
20077a0: 01 00 00 00 nop
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20077a4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
20077a8: b2 2e 40 02 andn %i1, %g2, %i1
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
event->pending_events = _Event_sets_Clear(
20077ac: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
20077b0: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20077b4: c4 20 40 00 st %g2, [ %g1 ]
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
20077b8: 82 10 20 03 mov 3, %g1
20077bc: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
20077c0: 7f ff eb 97 call 200261c <sparc_enable_interrupts>
20077c4: 91 e8 00 08 restore %g0, %o0, %o0
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
20077c8: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
20077cc: 7f ff eb 94 call 200261c <sparc_enable_interrupts>
20077d0: 33 04 01 ff sethi %hi(0x1007fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
20077d4: 40 00 0f 9a call 200b63c <_Watchdog_Remove>
20077d8: 90 06 20 48 add %i0, 0x48, %o0
20077dc: b2 16 63 f8 or %i1, 0x3f8, %i1
20077e0: 40 00 0a e1 call 200a364 <_Thread_Clear_state>
20077e4: 81 e8 00 00 restore
020077e8 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
20077e8: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
Thread_blocking_operation_States *sync_state;
sync_state = arg;
the_thread = _Thread_Get( id, &location );
20077ec: 90 10 00 18 mov %i0, %o0
20077f0: 40 00 0b ee call 200a7a8 <_Thread_Get>
20077f4: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
20077f8: c2 07 bf fc ld [ %fp + -4 ], %g1
20077fc: 80 a0 60 00 cmp %g1, 0
2007800: 12 80 00 15 bne 2007854 <_Event_Timeout+0x6c> <== NEVER TAKEN
2007804: 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 );
2007808: 7f ff eb 81 call 200260c <sparc_disable_interrupts>
200780c: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
2007810: 03 00 80 7a sethi %hi(0x201e800), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
2007814: c2 00 60 50 ld [ %g1 + 0x50 ], %g1 ! 201e850 <_Per_CPU_Information+0x10>
2007818: 80 a7 40 01 cmp %i5, %g1
200781c: 02 80 00 10 be 200785c <_Event_Timeout+0x74>
2007820: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
2007824: 82 10 20 06 mov 6, %g1
2007828: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
200782c: 7f ff eb 7c call 200261c <sparc_enable_interrupts>
2007830: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
2007834: 90 10 00 1d mov %i5, %o0
2007838: 13 04 01 ff sethi %hi(0x1007fc00), %o1
200783c: 40 00 0a ca call 200a364 <_Thread_Clear_state>
2007840: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1007fff8 <RAM_END+0xdc7fff8>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2007844: 03 00 80 78 sethi %hi(0x201e000), %g1
2007848: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 201e320 <_Thread_Dispatch_disable_level>
--level;
200784c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
2007850: c4 20 63 20 st %g2, [ %g1 + 0x320 ]
2007854: 81 c7 e0 08 ret
2007858: 81 e8 00 00 restore
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
200785c: c2 06 40 00 ld [ %i1 ], %g1
2007860: 80 a0 60 01 cmp %g1, 1
2007864: 12 bf ff f1 bne 2007828 <_Event_Timeout+0x40>
2007868: 82 10 20 06 mov 6, %g1
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
200786c: 82 10 20 02 mov 2, %g1
2007870: 10 bf ff ed b 2007824 <_Event_Timeout+0x3c>
2007874: c2 26 40 00 st %g1, [ %i1 ]
0200de88 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
200de88: 9d e3 bf 98 save %sp, -104, %sp
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
200de8c: a2 06 60 04 add %i1, 4, %l1
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
200de90: a0 10 00 18 mov %i0, %l0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
200de94: 80 a6 40 11 cmp %i1, %l1
200de98: 18 80 00 85 bgu 200e0ac <_Heap_Allocate_aligned_with_boundary+0x224>
200de9c: ea 06 20 10 ld [ %i0 + 0x10 ], %l5
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
200dea0: 80 a6 e0 00 cmp %i3, 0
200dea4: 12 80 00 7c bne 200e094 <_Heap_Allocate_aligned_with_boundary+0x20c>
200dea8: 80 a6 40 1b cmp %i1, %i3
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
200deac: fa 04 20 08 ld [ %l0 + 8 ], %i5
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
200deb0: 80 a4 00 1d cmp %l0, %i5
200deb4: 02 80 00 18 be 200df14 <_Heap_Allocate_aligned_with_boundary+0x8c>
200deb8: b8 10 20 00 clr %i4
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
200debc: ac 10 20 04 mov 4, %l6
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
200dec0: ae 05 60 07 add %l5, 7, %l7
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
200dec4: ac 25 80 19 sub %l6, %i1, %l6
200dec8: 10 80 00 0b b 200def4 <_Heap_Allocate_aligned_with_boundary+0x6c>
200decc: ec 27 bf fc st %l6, [ %fp + -4 ]
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
if ( alignment == 0 ) {
200ded0: 12 80 00 18 bne 200df30 <_Heap_Allocate_aligned_with_boundary+0xa8>
200ded4: b0 07 60 08 add %i5, 8, %i0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
200ded8: 80 a6 20 00 cmp %i0, 0
200dedc: 12 80 00 4d bne 200e010 <_Heap_Allocate_aligned_with_boundary+0x188><== ALWAYS TAKEN
200dee0: b8 07 20 01 inc %i4
break;
}
block = block->next;
200dee4: fa 07 60 08 ld [ %i5 + 8 ], %i5
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
200dee8: 80 a4 00 1d cmp %l0, %i5
200deec: 22 80 00 0b be,a 200df18 <_Heap_Allocate_aligned_with_boundary+0x90>
200def0: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
200def4: c2 07 60 04 ld [ %i5 + 4 ], %g1
200def8: 80 a4 40 01 cmp %l1, %g1
200defc: 0a bf ff f5 bcs 200ded0 <_Heap_Allocate_aligned_with_boundary+0x48>
200df00: 80 a6 a0 00 cmp %i2, 0
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
200df04: fa 07 60 08 ld [ %i5 + 8 ], %i5
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
200df08: 80 a4 00 1d cmp %l0, %i5
200df0c: 12 bf ff fa bne 200def4 <_Heap_Allocate_aligned_with_boundary+0x6c>
200df10: b8 07 20 01 inc %i4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
200df14: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
200df18: 80 a0 40 1c cmp %g1, %i4
200df1c: 1a 80 00 03 bcc 200df28 <_Heap_Allocate_aligned_with_boundary+0xa0>
200df20: b0 10 20 00 clr %i0
stats->max_search = search_count;
200df24: f8 24 20 44 st %i4, [ %l0 + 0x44 ]
}
return (void *) alloc_begin;
200df28: 81 c7 e0 08 ret
200df2c: 81 e8 00 00 restore
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
200df30: e8 04 20 14 ld [ %l0 + 0x14 ], %l4
- 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;
200df34: a4 08 7f fe and %g1, -2, %l2
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
200df38: c2 07 bf fc ld [ %fp + -4 ], %g1
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
200df3c: 84 25 c0 14 sub %l7, %l4, %g2
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
200df40: a4 07 40 12 add %i5, %l2, %l2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200df44: 92 10 00 1a mov %i2, %o1
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
200df48: b0 00 40 12 add %g1, %l2, %i0
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
200df4c: a4 00 80 12 add %g2, %l2, %l2
200df50: 40 00 2d 4b call 201947c <.urem>
200df54: 90 10 00 18 mov %i0, %o0
200df58: b0 26 00 08 sub %i0, %o0, %i0
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
200df5c: 80 a4 80 18 cmp %l2, %i0
200df60: 1a 80 00 06 bcc 200df78 <_Heap_Allocate_aligned_with_boundary+0xf0>
200df64: a6 07 60 08 add %i5, 8, %l3
200df68: 90 10 00 12 mov %l2, %o0
200df6c: 40 00 2d 44 call 201947c <.urem>
200df70: 92 10 00 1a mov %i2, %o1
200df74: b0 24 80 08 sub %l2, %o0, %i0
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
200df78: 80 a6 e0 00 cmp %i3, 0
200df7c: 02 80 00 37 be 200e058 <_Heap_Allocate_aligned_with_boundary+0x1d0>
200df80: 80 a4 c0 18 cmp %l3, %i0
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
200df84: 86 06 00 19 add %i0, %i1, %g3
200df88: 92 10 00 1b mov %i3, %o1
200df8c: 90 10 00 03 mov %g3, %o0
200df90: 40 00 2d 3b call 201947c <.urem>
200df94: c6 27 bf f8 st %g3, [ %fp + -8 ]
200df98: c6 07 bf f8 ld [ %fp + -8 ], %g3
200df9c: 90 20 c0 08 sub %g3, %o0, %o0
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
200dfa0: 80 a6 00 08 cmp %i0, %o0
200dfa4: 1a 80 00 2c bcc 200e054 <_Heap_Allocate_aligned_with_boundary+0x1cc>
200dfa8: a4 04 c0 19 add %l3, %i1, %l2
200dfac: 80 a2 00 03 cmp %o0, %g3
200dfb0: 2a 80 00 12 bcs,a 200dff8 <_Heap_Allocate_aligned_with_boundary+0x170>
200dfb4: 80 a4 80 08 cmp %l2, %o0
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
200dfb8: 10 80 00 28 b 200e058 <_Heap_Allocate_aligned_with_boundary+0x1d0>
200dfbc: 80 a4 c0 18 cmp %l3, %i0
200dfc0: 92 10 00 1a mov %i2, %o1
200dfc4: 40 00 2d 2e call 201947c <.urem>
200dfc8: 90 10 00 18 mov %i0, %o0
200dfcc: 92 10 00 1b mov %i3, %o1
200dfd0: b0 26 00 08 sub %i0, %o0, %i0
if ( boundary_line < boundary_floor ) {
return 0;
}
alloc_begin = boundary_line - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
200dfd4: ac 06 00 19 add %i0, %i1, %l6
200dfd8: 40 00 2d 29 call 201947c <.urem>
200dfdc: 90 10 00 16 mov %l6, %o0
200dfe0: 90 25 80 08 sub %l6, %o0, %o0
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
200dfe4: 80 a2 00 16 cmp %o0, %l6
200dfe8: 1a 80 00 1b bcc 200e054 <_Heap_Allocate_aligned_with_boundary+0x1cc>
200dfec: 80 a6 00 08 cmp %i0, %o0
200dff0: 1a 80 00 19 bcc 200e054 <_Heap_Allocate_aligned_with_boundary+0x1cc>
200dff4: 80 a4 80 08 cmp %l2, %o0
if ( boundary_line < boundary_floor ) {
200dff8: 08 bf ff f2 bleu 200dfc0 <_Heap_Allocate_aligned_with_boundary+0x138>
200dffc: b0 22 00 19 sub %o0, %i1, %i0
return 0;
200e000: b0 10 20 00 clr %i0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
200e004: 80 a6 20 00 cmp %i0, 0
200e008: 02 bf ff b7 be 200dee4 <_Heap_Allocate_aligned_with_boundary+0x5c><== ALWAYS TAKEN
200e00c: b8 07 20 01 inc %i4
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
200e010: c6 04 20 48 ld [ %l0 + 0x48 ], %g3
stats->searches += search_count;
200e014: c4 04 20 4c ld [ %l0 + 0x4c ], %g2
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
200e018: 86 00 e0 01 inc %g3
stats->searches += search_count;
200e01c: 84 00 80 1c add %g2, %i4, %g2
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
200e020: c6 24 20 48 st %g3, [ %l0 + 0x48 ]
stats->searches += search_count;
200e024: c4 24 20 4c st %g2, [ %l0 + 0x4c ]
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
200e028: 90 10 00 10 mov %l0, %o0
200e02c: 92 10 00 1d mov %i5, %o1
200e030: 94 10 00 18 mov %i0, %o2
200e034: 7f ff eb df call 2008fb0 <_Heap_Block_allocate>
200e038: 96 10 00 19 mov %i1, %o3
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
200e03c: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
200e040: 80 a0 40 1c cmp %g1, %i4
200e044: 2a bf ff b9 bcs,a 200df28 <_Heap_Allocate_aligned_with_boundary+0xa0>
200e048: f8 24 20 44 st %i4, [ %l0 + 0x44 ]
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
200e04c: 81 c7 e0 08 ret
200e050: 81 e8 00 00 restore
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
200e054: 80 a4 c0 18 cmp %l3, %i0
200e058: 18 bf ff ea bgu 200e000 <_Heap_Allocate_aligned_with_boundary+0x178>
200e05c: 82 10 3f f8 mov -8, %g1
200e060: 90 10 00 18 mov %i0, %o0
200e064: a4 20 40 1d sub %g1, %i5, %l2
200e068: 92 10 00 15 mov %l5, %o1
200e06c: 40 00 2d 04 call 201947c <.urem>
200e070: a4 04 80 18 add %l2, %i0, %l2
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
if ( free_size >= min_block_size || free_size == 0 ) {
200e074: 90 a4 80 08 subcc %l2, %o0, %o0
200e078: 02 bf ff 99 be 200dedc <_Heap_Allocate_aligned_with_boundary+0x54>
200e07c: 80 a6 20 00 cmp %i0, 0
200e080: 80 a2 00 14 cmp %o0, %l4
200e084: 1a bf ff 96 bcc 200dedc <_Heap_Allocate_aligned_with_boundary+0x54>
200e088: 80 a6 20 00 cmp %i0, 0
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
return 0;
200e08c: 10 bf ff de b 200e004 <_Heap_Allocate_aligned_with_boundary+0x17c>
200e090: b0 10 20 00 clr %i0
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
200e094: 18 80 00 06 bgu 200e0ac <_Heap_Allocate_aligned_with_boundary+0x224>
200e098: 80 a6 a0 00 cmp %i2, 0
return NULL;
}
if ( alignment == 0 ) {
200e09c: 22 bf ff 84 be,a 200deac <_Heap_Allocate_aligned_with_boundary+0x24>
200e0a0: b4 10 00 15 mov %l5, %i2
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
200e0a4: 10 bf ff 83 b 200deb0 <_Heap_Allocate_aligned_with_boundary+0x28>
200e0a8: fa 04 20 08 ld [ %l0 + 8 ], %i5
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
/* Integer overflow occured */
return NULL;
200e0ac: 81 c7 e0 08 ret
200e0b0: 91 e8 20 00 restore %g0, 0, %o0
0200e0c0 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
200e0c0: 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;
200e0c4: c0 27 bf f8 clr [ %fp + -8 ]
Heap_Block *extend_last_block = NULL;
200e0c8: c0 27 bf fc clr [ %fp + -4 ]
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
200e0cc: b8 10 00 18 mov %i0, %i4
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
200e0d0: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
200e0d4: a0 06 40 1a add %i1, %i2, %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;
200e0d8: e4 06 20 10 ld [ %i0 + 0x10 ], %l2
uintptr_t const min_block_size = heap->min_block_size;
200e0dc: d6 06 20 14 ld [ %i0 + 0x14 ], %o3
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
200e0e0: 80 a6 40 10 cmp %i1, %l0
200e0e4: 08 80 00 04 bleu 200e0f4 <_Heap_Extend+0x34>
200e0e8: f0 06 20 30 ld [ %i0 + 0x30 ], %i0
return 0;
200e0ec: 81 c7 e0 08 ret
200e0f0: 91 e8 20 00 restore %g0, 0, %o0
}
extend_area_ok = _Heap_Get_first_and_last_block(
200e0f4: 90 10 00 19 mov %i1, %o0
200e0f8: 92 10 00 1a mov %i2, %o1
200e0fc: 94 10 00 12 mov %l2, %o2
200e100: 98 07 bf f8 add %fp, -8, %o4
200e104: 7f ff eb 40 call 2008e04 <_Heap_Get_first_and_last_block>
200e108: 9a 07 bf fc add %fp, -4, %o5
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
200e10c: 80 8a 20 ff btst 0xff, %o0
200e110: 02 bf ff f7 be 200e0ec <_Heap_Extend+0x2c>
200e114: ba 10 00 11 mov %l1, %i5
200e118: aa 10 20 00 clr %l5
200e11c: ac 10 20 00 clr %l6
200e120: a6 10 20 00 clr %l3
200e124: 10 80 00 10 b 200e164 <_Heap_Extend+0xa4>
200e128: a8 10 20 00 clr %l4
return 0;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
200e12c: 2a 80 00 02 bcs,a 200e134 <_Heap_Extend+0x74>
200e130: ac 10 00 1d mov %i5, %l6
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
200e134: 80 a6 c0 19 cmp %i3, %i1
200e138: 22 80 00 1e be,a 200e1b0 <_Heap_Extend+0xf0>
200e13c: e0 27 40 00 st %l0, [ %i5 ]
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
200e140: 80 a6 40 1b cmp %i1, %i3
200e144: 38 80 00 02 bgu,a 200e14c <_Heap_Extend+0x8c>
200e148: 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;
200e14c: fa 02 20 04 ld [ %o0 + 4 ], %i5
200e150: 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);
200e154: ba 02 00 1d add %o0, %i5, %i5
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
200e158: 80 a4 40 1d cmp %l1, %i5
200e15c: 22 80 00 1c be,a 200e1cc <_Heap_Extend+0x10c>
200e160: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
200e164: 80 a7 40 11 cmp %i5, %l1
200e168: 22 80 00 03 be,a 200e174 <_Heap_Extend+0xb4>
200e16c: f4 07 20 18 ld [ %i4 + 0x18 ], %i2
200e170: b4 10 00 1d mov %i5, %i2
uintptr_t const sub_area_end = start_block->prev_size;
200e174: f6 07 40 00 ld [ %i5 ], %i3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200e178: 92 10 00 12 mov %l2, %o1
200e17c: 40 00 2d 79 call 2019760 <.urem>
200e180: 90 10 00 1b mov %i3, %o0
200e184: 82 06 ff f8 add %i3, -8, %g1
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
200e188: 80 a6 80 10 cmp %i2, %l0
200e18c: 0a 80 00 64 bcs 200e31c <_Heap_Extend+0x25c>
200e190: 90 20 40 08 sub %g1, %o0, %o0
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
}
if ( extend_area_end == sub_area_begin ) {
200e194: 80 a6 80 10 cmp %i2, %l0
200e198: 12 bf ff e5 bne 200e12c <_Heap_Extend+0x6c>
200e19c: 80 a4 00 1b cmp %l0, %i3
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
200e1a0: 80 a6 c0 19 cmp %i3, %i1
200e1a4: 12 bf ff e7 bne 200e140 <_Heap_Extend+0x80> <== ALWAYS TAKEN
200e1a8: a8 10 00 1d mov %i5, %l4
start_block->prev_size = extend_area_end;
200e1ac: e0 27 40 00 st %l0, [ %i5 ] <== NOT EXECUTED
- 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;
200e1b0: fa 02 20 04 ld [ %o0 + 4 ], %i5
200e1b4: 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);
200e1b8: ba 02 00 1d add %o0, %i5, %i5
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
200e1bc: 80 a4 40 1d cmp %l1, %i5
200e1c0: 12 bf ff e9 bne 200e164 <_Heap_Extend+0xa4> <== NEVER TAKEN
200e1c4: a6 10 00 08 mov %o0, %l3
if ( extend_area_begin < heap->area_begin ) {
200e1c8: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
200e1cc: 80 a6 40 01 cmp %i1, %g1
200e1d0: 3a 80 00 4e bcc,a 200e308 <_Heap_Extend+0x248>
200e1d4: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
heap->area_begin = extend_area_begin;
200e1d8: f2 27 20 18 st %i1, [ %i4 + 0x18 ]
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
200e1dc: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e1e0: c4 07 bf fc ld [ %fp + -4 ], %g2
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 ) {
200e1e4: c8 07 20 20 ld [ %i4 + 0x20 ], %g4
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
200e1e8: 86 20 80 01 sub %g2, %g1, %g3
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
200e1ec: e0 20 40 00 st %l0, [ %g1 ]
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
200e1f0: ba 10 e0 01 or %g3, 1, %i5
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 =
200e1f4: fa 20 60 04 st %i5, [ %g1 + 4 ]
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
200e1f8: c6 20 80 00 st %g3, [ %g2 ]
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 ) {
200e1fc: 80 a1 00 01 cmp %g4, %g1
200e200: 08 80 00 3c bleu 200e2f0 <_Heap_Extend+0x230>
200e204: c0 20 a0 04 clr [ %g2 + 4 ]
heap->first_block = extend_first_block;
200e208: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
200e20c: 80 a5 20 00 cmp %l4, 0
200e210: 02 80 00 47 be 200e32c <_Heap_Extend+0x26c>
200e214: 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;
200e218: fa 07 20 10 ld [ %i4 + 0x10 ], %i5
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
200e21c: 92 10 00 1d mov %i5, %o1
200e220: 40 00 2d 50 call 2019760 <.urem>
200e224: 90 10 00 19 mov %i1, %o0
if ( remainder != 0 ) {
200e228: 80 a2 20 00 cmp %o0, 0
200e22c: 02 80 00 04 be 200e23c <_Heap_Extend+0x17c>
200e230: c4 05 00 00 ld [ %l4 ], %g2
return value - remainder + alignment;
200e234: b2 06 40 1d add %i1, %i5, %i1
200e238: 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 =
200e23c: 82 06 7f f8 add %i1, -8, %g1
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;
200e240: c4 26 7f f8 st %g2, [ %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 =
200e244: 84 25 00 01 sub %l4, %g1, %g2
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;
200e248: 84 10 a0 01 or %g2, 1, %g2
_Heap_Free_block( heap, new_first_block );
200e24c: 90 10 00 1c mov %i4, %o0
200e250: 92 10 00 01 mov %g1, %o1
200e254: 7f ff ff 85 call 200e068 <_Heap_Free_block>
200e258: c4 26 7f fc st %g2, [ %i1 + -4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
200e25c: 80 a4 e0 00 cmp %l3, 0
200e260: 02 80 00 3a be 200e348 <_Heap_Extend+0x288>
200e264: a0 04 3f f8 add %l0, -8, %l0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200e268: d2 07 20 10 ld [ %i4 + 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(
200e26c: a0 24 00 13 sub %l0, %l3, %l0
200e270: 40 00 2d 3c call 2019760 <.urem>
200e274: 90 10 00 10 mov %l0, %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)
200e278: c2 04 e0 04 ld [ %l3 + 4 ], %g1
200e27c: a0 24 00 08 sub %l0, %o0, %l0
200e280: 82 20 40 10 sub %g1, %l0, %g1
| HEAP_PREV_BLOCK_USED;
200e284: 82 10 60 01 or %g1, 1, %g1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
200e288: 84 04 00 13 add %l0, %l3, %g2
200e28c: c2 20 a0 04 st %g1, [ %g2 + 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;
200e290: c2 04 e0 04 ld [ %l3 + 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 );
200e294: 90 10 00 1c mov %i4, %o0
200e298: 82 08 60 01 and %g1, 1, %g1
200e29c: 92 10 00 13 mov %l3, %o1
block->size_and_flag = size | flag;
200e2a0: a0 14 00 01 or %l0, %g1, %l0
200e2a4: 7f ff ff 71 call 200e068 <_Heap_Free_block>
200e2a8: e0 24 e0 04 st %l0, [ %l3 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200e2ac: 80 a4 e0 00 cmp %l3, 0
200e2b0: 02 80 00 33 be 200e37c <_Heap_Extend+0x2bc>
200e2b4: 80 a5 20 00 cmp %l4, 0
*/
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
200e2b8: c2 07 20 24 ld [ %i4 + 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(
200e2bc: fa 07 20 20 ld [ %i4 + 0x20 ], %i5
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;
200e2c0: c8 00 60 04 ld [ %g1 + 4 ], %g4
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
200e2c4: c4 07 20 2c ld [ %i4 + 0x2c ], %g2
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
200e2c8: c6 07 20 30 ld [ %i4 + 0x30 ], %g3
* 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(
200e2cc: ba 27 40 01 sub %i5, %g1, %i5
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;
200e2d0: 88 09 20 01 and %g4, 1, %g4
block->size_and_flag = size | flag;
200e2d4: 88 17 40 04 or %i5, %g4, %g4
200e2d8: c8 20 60 04 st %g4, [ %g1 + 4 ]
200e2dc: b0 20 c0 18 sub %g3, %i0, %i0
/* Statistics */
stats->size += extended_size;
200e2e0: 82 00 80 18 add %g2, %i0, %g1
200e2e4: c2 27 20 2c st %g1, [ %i4 + 0x2c ]
return extended_size;
}
200e2e8: 81 c7 e0 08 ret
200e2ec: 81 e8 00 00 restore
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 ) {
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
200e2f0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
200e2f4: 80 a0 40 02 cmp %g1, %g2
200e2f8: 2a bf ff c5 bcs,a 200e20c <_Heap_Extend+0x14c>
200e2fc: c4 27 20 24 st %g2, [ %i4 + 0x24 ]
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
200e300: 10 bf ff c4 b 200e210 <_Heap_Extend+0x150>
200e304: 80 a5 20 00 cmp %l4, 0
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
200e308: 80 a4 00 01 cmp %l0, %g1
200e30c: 38 bf ff b4 bgu,a 200e1dc <_Heap_Extend+0x11c>
200e310: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
200e314: 10 bf ff b3 b 200e1e0 <_Heap_Extend+0x120>
200e318: c2 07 bf f8 ld [ %fp + -8 ], %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 (
200e31c: 80 a6 40 1b cmp %i1, %i3
200e320: 1a bf ff 9e bcc 200e198 <_Heap_Extend+0xd8>
200e324: 80 a6 80 10 cmp %i2, %l0
200e328: 30 bf ff 71 b,a 200e0ec <_Heap_Extend+0x2c>
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 ) {
200e32c: 80 a5 a0 00 cmp %l6, 0
200e330: 02 bf ff cc be 200e260 <_Heap_Extend+0x1a0>
200e334: 80 a4 e0 00 cmp %l3, 0
{
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;
200e338: ac 25 80 02 sub %l6, %g2, %l6
200e33c: 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 =
200e340: 10 bf ff c8 b 200e260 <_Heap_Extend+0x1a0>
200e344: ec 20 a0 04 st %l6, [ %g2 + 4 ]
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
200e348: 80 a5 60 00 cmp %l5, 0
200e34c: 02 bf ff d8 be 200e2ac <_Heap_Extend+0x1ec>
200e350: c4 07 bf f8 ld [ %fp + -8 ], %g2
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;
200e354: c6 05 60 04 ld [ %l5 + 4 ], %g3
_Heap_Link_above(
200e358: c2 07 bf fc ld [ %fp + -4 ], %g1
200e35c: 86 08 e0 01 and %g3, 1, %g3
)
{
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 );
200e360: 84 20 80 15 sub %g2, %l5, %g2
block->size_and_flag = size | flag;
200e364: 84 10 80 03 or %g2, %g3, %g2
200e368: c4 25 60 04 st %g2, [ %l5 + 4 ]
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
200e36c: c4 00 60 04 ld [ %g1 + 4 ], %g2
200e370: 84 10 a0 01 or %g2, 1, %g2
200e374: 10 bf ff ce b 200e2ac <_Heap_Extend+0x1ec>
200e378: c4 20 60 04 st %g2, [ %g1 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200e37c: 32 bf ff d0 bne,a 200e2bc <_Heap_Extend+0x1fc>
200e380: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
_Heap_Free_block( heap, extend_first_block );
200e384: d2 07 bf f8 ld [ %fp + -8 ], %o1
200e388: 7f ff ff 38 call 200e068 <_Heap_Free_block>
200e38c: 90 10 00 1c mov %i4, %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
200e390: 10 bf ff cb b 200e2bc <_Heap_Extend+0x1fc>
200e394: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
0200e0b4 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
200e0b4: 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 ) {
200e0b8: 80 a6 60 00 cmp %i1, 0
200e0bc: 02 80 00 3c be 200e1ac <_Heap_Free+0xf8>
200e0c0: 82 10 20 01 mov 1, %g1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200e0c4: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200e0c8: 40 00 2c ed call 201947c <.urem>
200e0cc: 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
200e0d0: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200e0d4: 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);
200e0d8: 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;
200e0dc: 80 a2 00 02 cmp %o0, %g2
200e0e0: 0a 80 00 30 bcs 200e1a0 <_Heap_Free+0xec>
200e0e4: 82 10 20 00 clr %g1
200e0e8: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
200e0ec: 80 a2 00 04 cmp %o0, %g4
200e0f0: 38 80 00 2d bgu,a 200e1a4 <_Heap_Free+0xf0> <== NEVER TAKEN
200e0f4: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
- 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;
200e0f8: f6 02 20 04 ld [ %o0 + 4 ], %i3
200e0fc: ba 0e ff fe and %i3, -2, %i5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200e100: 86 02 00 1d add %o0, %i5, %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;
200e104: 80 a0 80 03 cmp %g2, %g3
200e108: 38 80 00 27 bgu,a 200e1a4 <_Heap_Free+0xf0> <== NEVER TAKEN
200e10c: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
200e110: 80 a1 00 03 cmp %g4, %g3
200e114: 2a 80 00 24 bcs,a 200e1a4 <_Heap_Free+0xf0> <== NEVER TAKEN
200e118: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
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;
200e11c: f8 00 e0 04 ld [ %g3 + 4 ], %i4
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
200e120: 80 8f 20 01 btst 1, %i4
200e124: 02 80 00 1f be 200e1a0 <_Heap_Free+0xec> <== NEVER TAKEN
200e128: 80 a1 00 03 cmp %g4, %g3
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
200e12c: 02 80 00 23 be 200e1b8 <_Heap_Free+0x104>
200e130: b8 0f 3f fe and %i4, -2, %i4
200e134: 82 00 c0 1c add %g3, %i4, %g1
200e138: c2 00 60 04 ld [ %g1 + 4 ], %g1
200e13c: 80 88 60 01 btst 1, %g1
200e140: 12 80 00 1f bne 200e1bc <_Heap_Free+0x108>
200e144: 80 8e e0 01 btst 1, %i3
if ( !_Heap_Is_prev_used( block ) ) {
200e148: 02 80 00 20 be 200e1c8 <_Heap_Free+0x114>
200e14c: b2 10 20 01 mov 1, %i1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
200e150: c4 00 e0 08 ld [ %g3 + 8 ], %g2
Heap_Block *prev = old_block->prev;
200e154: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
new_block->next = next;
200e158: c4 22 20 08 st %g2, [ %o0 + 8 ]
new_block->prev = prev;
200e15c: c2 22 20 0c st %g1, [ %o0 + 0xc ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
200e160: b8 07 00 1d add %i4, %i5, %i4
next->prev = new_block;
200e164: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
prev->next = new_block;
200e168: d0 20 60 08 st %o0, [ %g1 + 8 ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200e16c: 84 17 20 01 or %i4, 1, %g2
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
200e170: f8 22 00 1c st %i4, [ %o0 + %i4 ]
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;
200e174: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
200e178: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
200e17c: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
++stats->frees;
stats->free_size += block_size;
200e180: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
200e184: 82 00 60 01 inc %g1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
200e188: 84 00 bf ff add %g2, -1, %g2
++stats->frees;
stats->free_size += block_size;
200e18c: ba 00 c0 1d add %g3, %i5, %i5
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
200e190: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
200e194: c4 26 20 40 st %g2, [ %i0 + 0x40 ]
++stats->frees;
stats->free_size += block_size;
200e198: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
return( true );
200e19c: 82 10 20 01 mov 1, %g1
200e1a0: b0 08 60 ff and %g1, 0xff, %i0
200e1a4: 81 c7 e0 08 ret
200e1a8: 81 e8 00 00 restore
200e1ac: b0 08 60 ff and %g1, 0xff, %i0
200e1b0: 81 c7 e0 08 ret
200e1b4: 81 e8 00 00 restore
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
200e1b8: 80 8e e0 01 btst 1, %i3
200e1bc: 32 80 00 1e bne,a 200e234 <_Heap_Free+0x180>
200e1c0: c4 06 20 08 ld [ %i0 + 8 ], %g2
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
200e1c4: b2 10 20 00 clr %i1
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
uintptr_t const prev_size = block->prev_size;
200e1c8: f4 02 00 00 ld [ %o0 ], %i2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200e1cc: b6 22 00 1a sub %o0, %i2, %i3
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;
200e1d0: 80 a0 80 1b cmp %g2, %i3
200e1d4: 18 bf ff f3 bgu 200e1a0 <_Heap_Free+0xec> <== NEVER TAKEN
200e1d8: 82 10 20 00 clr %g1
200e1dc: 80 a1 00 1b cmp %g4, %i3
200e1e0: 2a bf ff f1 bcs,a 200e1a4 <_Heap_Free+0xf0> <== NEVER TAKEN
200e1e4: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
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;
200e1e8: c4 06 e0 04 ld [ %i3 + 4 ], %g2
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) ) {
200e1ec: 80 88 a0 01 btst 1, %g2
200e1f0: 02 bf ff ec be 200e1a0 <_Heap_Free+0xec> <== NEVER TAKEN
200e1f4: 80 8e 60 ff btst 0xff, %i1
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
200e1f8: 22 80 00 21 be,a 200e27c <_Heap_Free+0x1c8>
200e1fc: b4 07 40 1a add %i5, %i2, %i2
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
200e200: c2 00 e0 08 ld [ %g3 + 8 ], %g1
Heap_Block *prev = block->prev;
200e204: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200e208: c6 06 20 38 ld [ %i0 + 0x38 ], %g3
prev->next = next;
200e20c: c2 20 a0 08 st %g1, [ %g2 + 8 ]
next->prev = prev;
200e210: c4 20 60 0c st %g2, [ %g1 + 0xc ]
200e214: 82 00 ff ff add %g3, -1, %g1
200e218: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
200e21c: b8 07 40 1c add %i5, %i4, %i4
200e220: b4 07 00 1a add %i4, %i2, %i2
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200e224: 82 16 a0 01 or %i2, 1, %g1
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
200e228: f4 26 c0 1a st %i2, [ %i3 + %i2 ]
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;
200e22c: 10 bf ff d3 b 200e178 <_Heap_Free+0xc4>
200e230: c2 26 e0 04 st %g1, [ %i3 + 4 ]
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;
200e234: 82 17 60 01 or %i5, 1, %g1
200e238: c2 22 20 04 st %g1, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200e23c: c8 00 e0 04 ld [ %g3 + 4 ], %g4
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
200e240: f0 22 20 0c st %i0, [ %o0 + 0xc ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
200e244: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
200e248: c4 22 20 08 st %g2, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
200e24c: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
} 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;
200e250: 84 09 3f fe and %g4, -2, %g2
next_block->prev_size = block_size;
200e254: fa 22 00 1d st %i5, [ %o0 + %i5 ]
} 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;
200e258: c4 20 e0 04 st %g2, [ %g3 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
200e25c: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
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;
200e260: 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;
200e264: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
200e268: 80 a0 40 02 cmp %g1, %g2
200e26c: 08 bf ff c3 bleu 200e178 <_Heap_Free+0xc4>
200e270: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
200e274: 10 bf ff c1 b 200e178 <_Heap_Free+0xc4>
200e278: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
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;
200e27c: 82 16 a0 01 or %i2, 1, %g1
200e280: c2 26 e0 04 st %g1, [ %i3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200e284: c2 00 e0 04 ld [ %g3 + 4 ], %g1
next_block->prev_size = size;
200e288: f4 22 00 1d st %i2, [ %o0 + %i5 ]
_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;
200e28c: 82 08 7f fe and %g1, -2, %g1
200e290: 10 bf ff ba b 200e178 <_Heap_Free+0xc4>
200e294: c2 20 e0 04 st %g1, [ %g3 + 4 ]
02012ee4 <_Heap_Get_free_information>:
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
2012ee4: c2 02 20 08 ld [ %o0 + 8 ], %g1
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
2012ee8: c0 22 40 00 clr [ %o1 ]
info->largest = 0;
2012eec: c0 22 60 04 clr [ %o1 + 4 ]
info->total = 0;
2012ef0: c0 22 60 08 clr [ %o1 + 8 ]
for(the_block = _Heap_Free_list_first(the_heap);
2012ef4: 88 10 20 01 mov 1, %g4
2012ef8: 9a 10 20 00 clr %o5
2012efc: 80 a2 00 01 cmp %o0, %g1
2012f00: 12 80 00 04 bne 2012f10 <_Heap_Get_free_information+0x2c> <== ALWAYS TAKEN
2012f04: 86 10 20 00 clr %g3
2012f08: 30 80 00 10 b,a 2012f48 <_Heap_Get_free_information+0x64><== NOT EXECUTED
2012f0c: 88 10 00 0c mov %o4, %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;
2012f10: c4 00 60 04 ld [ %g1 + 4 ], %g2
2012f14: 98 01 20 01 add %g4, 1, %o4
2012f18: 84 08 bf fe and %g2, -2, %g2
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
if ( info->largest < the_size )
2012f1c: 80 a0 80 0d cmp %g2, %o5
2012f20: 08 80 00 03 bleu 2012f2c <_Heap_Get_free_information+0x48>
2012f24: 86 00 c0 02 add %g3, %g2, %g3
info->largest = the_size;
2012f28: c4 22 60 04 st %g2, [ %o1 + 4 ]
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
the_block != tail;
the_block = the_block->next)
2012f2c: c2 00 60 08 ld [ %g1 + 8 ], %g1
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
2012f30: 80 a2 00 01 cmp %o0, %g1
2012f34: 32 bf ff f6 bne,a 2012f0c <_Heap_Get_free_information+0x28>
2012f38: da 02 60 04 ld [ %o1 + 4 ], %o5
2012f3c: c8 22 40 00 st %g4, [ %o1 ]
2012f40: 81 c3 e0 08 retl
2012f44: c6 22 60 08 st %g3, [ %o1 + 8 ]
2012f48: 81 c3 e0 08 retl <== NOT EXECUTED
0200ad34 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
200ad34: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
200ad38: 80 a6 a0 00 cmp %i2, 0
200ad3c: 02 80 00 35 be 200ae10 <_Heap_Greedy_allocate+0xdc>
200ad40: b8 10 00 18 mov %i0, %i4
200ad44: ba 10 20 00 clr %i5
200ad48: b6 10 20 00 clr %i3
#include "config.h"
#endif
#include <rtems/score/heap.h>
Heap_Block *_Heap_Greedy_allocate(
200ad4c: 83 2f 60 02 sll %i5, 2, %g1
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
200ad50: d2 06 40 01 ld [ %i1 + %g1 ], %o1
200ad54: 94 10 20 00 clr %o2
200ad58: 96 10 20 00 clr %o3
200ad5c: 40 00 1f d6 call 2012cb4 <_Heap_Allocate_aligned_with_boundary>
200ad60: 90 10 00 1c mov %i4, %o0
size_t i;
for (i = 0; i < block_count; ++i) {
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
200ad64: 82 92 20 00 orcc %o0, 0, %g1
200ad68: 22 80 00 09 be,a 200ad8c <_Heap_Greedy_allocate+0x58> <== NEVER TAKEN
200ad6c: ba 07 60 01 inc %i5 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200ad70: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
200ad74: 40 00 4d 42 call 201e27c <.urem>
200ad78: b0 00 7f f8 add %g1, -8, %i0
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
200ad7c: 90 26 00 08 sub %i0, %o0, %o0
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
200ad80: f6 22 20 08 st %i3, [ %o0 + 8 ]
200ad84: b6 10 00 08 mov %o0, %i3
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
200ad88: ba 07 60 01 inc %i5
200ad8c: 80 a7 40 1a cmp %i5, %i2
200ad90: 12 bf ff f0 bne 200ad50 <_Heap_Greedy_allocate+0x1c>
200ad94: 83 2f 60 02 sll %i5, 2, %g1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
200ad98: fa 07 20 08 ld [ %i4 + 8 ], %i5
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
200ad9c: 80 a7 00 1d cmp %i4, %i5
200ada0: 02 80 00 17 be 200adfc <_Heap_Greedy_allocate+0xc8> <== NEVER TAKEN
200ada4: b0 10 20 00 clr %i0
200ada8: 10 80 00 03 b 200adb4 <_Heap_Greedy_allocate+0x80>
200adac: b4 10 20 00 clr %i2
200adb0: ba 10 00 01 mov %g1, %i5
- 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;
200adb4: d6 07 60 04 ld [ %i5 + 4 ], %o3
_Heap_Block_allocate(
200adb8: 92 10 00 1d mov %i5, %o1
200adbc: 96 0a ff fe and %o3, -2, %o3
200adc0: 94 07 60 08 add %i5, 8, %o2
200adc4: 90 10 00 1c mov %i4, %o0
200adc8: 40 00 00 e0 call 200b148 <_Heap_Block_allocate>
200adcc: 96 02 ff f8 add %o3, -8, %o3
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
200add0: f4 27 60 08 st %i2, [ %i5 + 8 ]
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
200add4: c2 07 20 08 ld [ %i4 + 8 ], %g1
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
200add8: 80 a7 00 01 cmp %i4, %g1
200addc: 12 bf ff f5 bne 200adb0 <_Heap_Greedy_allocate+0x7c>
200ade0: b4 10 00 1d mov %i5, %i2
200ade4: 10 80 00 06 b 200adfc <_Heap_Greedy_allocate+0xc8>
200ade8: b0 10 00 1d mov %i5, %i0
}
while ( allocated_blocks != NULL ) {
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
200adec: 92 06 e0 08 add %i3, 8, %o1
200adf0: 90 10 00 1c mov %i4, %o0
200adf4: 40 00 20 3b call 2012ee0 <_Heap_Free>
200adf8: b6 10 00 1a mov %i2, %i3
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
200adfc: 80 a6 e0 00 cmp %i3, 0
200ae00: 32 bf ff fb bne,a 200adec <_Heap_Greedy_allocate+0xb8>
200ae04: f4 06 e0 08 ld [ %i3 + 8 ], %i2
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
200ae08: 81 c7 e0 08 ret
200ae0c: 81 e8 00 00 restore
const uintptr_t *block_sizes,
size_t block_count
)
{
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *allocated_blocks = NULL;
200ae10: 10 bf ff e2 b 200ad98 <_Heap_Greedy_allocate+0x64>
200ae14: b6 10 20 00 clr %i3
0200ae18 <_Heap_Greedy_free>:
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
200ae18: 9d e3 bf a0 save %sp, -96, %sp
while ( blocks != NULL ) {
200ae1c: 80 a6 60 00 cmp %i1, 0
200ae20: 02 80 00 09 be 200ae44 <_Heap_Greedy_free+0x2c> <== NEVER TAKEN
200ae24: 01 00 00 00 nop
Heap_Block *current = blocks;
blocks = blocks->next;
200ae28: fa 06 60 08 ld [ %i1 + 8 ], %i5
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
200ae2c: 92 06 60 08 add %i1, 8, %o1
200ae30: 40 00 20 2c call 2012ee0 <_Heap_Free>
200ae34: 90 10 00 18 mov %i0, %o0
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
while ( blocks != NULL ) {
200ae38: b2 97 60 00 orcc %i5, 0, %i1
200ae3c: 32 bf ff fc bne,a 200ae2c <_Heap_Greedy_free+0x14>
200ae40: fa 06 60 08 ld [ %i1 + 8 ], %i5
200ae44: 81 c7 e0 08 ret
200ae48: 81 e8 00 00 restore
02012fb0 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
2012fb0: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *current = heap->first_block;
2012fb4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
Heap_Block *end = heap->last_block;
2012fb8: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
bool stop = false;
while ( !stop && current != end ) {
2012fbc: 80 a0 40 1c cmp %g1, %i4
2012fc0: 32 80 00 08 bne,a 2012fe0 <_Heap_Iterate+0x30> <== ALWAYS TAKEN
2012fc4: d2 00 60 04 ld [ %g1 + 4 ], %o1
2012fc8: 30 80 00 10 b,a 2013008 <_Heap_Iterate+0x58> <== NOT EXECUTED
2012fcc: 90 1a 20 01 xor %o0, 1, %o0
2012fd0: 80 8a 20 ff btst 0xff, %o0
2012fd4: 02 80 00 0d be 2013008 <_Heap_Iterate+0x58> <== NEVER TAKEN
2012fd8: 01 00 00 00 nop
2012fdc: d2 00 60 04 ld [ %g1 + 4 ], %o1
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 );
2012fe0: 90 10 00 01 mov %g1, %o0
2012fe4: 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);
2012fe8: ba 00 40 09 add %g1, %o1, %i5
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
2012fec: d4 07 60 04 ld [ %i5 + 4 ], %o2
2012ff0: 96 10 00 1a mov %i2, %o3
2012ff4: 9f c6 40 00 call %i1
2012ff8: 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 ) {
2012ffc: 80 a7 00 1d cmp %i4, %i5
2013000: 12 bf ff f3 bne 2012fcc <_Heap_Iterate+0x1c>
2013004: 82 10 00 1d mov %i5, %g1
2013008: 81 c7 e0 08 ret
201300c: 81 e8 00 00 restore
0200e3c0 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
200e3c0: 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);
200e3c4: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200e3c8: 40 00 2c 2d call 201947c <.urem>
200e3cc: 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
200e3d0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200e3d4: 84 06 7f f8 add %i1, -8, %g2
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
200e3d8: 90 20 80 08 sub %g2, %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;
200e3dc: 80 a2 00 01 cmp %o0, %g1
200e3e0: 0a 80 00 16 bcs 200e438 <_Heap_Size_of_alloc_area+0x78>
200e3e4: 84 10 20 00 clr %g2
200e3e8: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
200e3ec: 80 a2 00 03 cmp %o0, %g3
200e3f0: 18 80 00 13 bgu 200e43c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
200e3f4: b0 08 a0 ff and %g2, 0xff, %i0
- 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;
200e3f8: c8 02 20 04 ld [ %o0 + 4 ], %g4
200e3fc: 88 09 3f fe and %g4, -2, %g4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200e400: 90 02 00 04 add %o0, %g4, %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;
200e404: 80 a0 40 08 cmp %g1, %o0
200e408: 18 80 00 0d bgu 200e43c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
200e40c: 01 00 00 00 nop
200e410: 80 a0 c0 08 cmp %g3, %o0
200e414: 0a 80 00 0a bcs 200e43c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
200e418: 01 00 00 00 nop
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;
200e41c: c2 02 20 04 ld [ %o0 + 4 ], %g1
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
200e420: 80 88 60 01 btst 1, %g1
200e424: 02 80 00 06 be 200e43c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
200e428: 90 22 00 19 sub %o0, %i1, %o0
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
200e42c: 84 10 20 01 mov 1, %g2
|| !_Heap_Is_prev_used( next_block )
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
200e430: 90 02 20 04 add %o0, 4, %o0
200e434: d0 26 80 00 st %o0, [ %i2 ]
200e438: b0 08 a0 ff and %g2, 0xff, %i0
200e43c: 81 c7 e0 08 ret
200e440: 81 e8 00 00 restore
02009d80 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
2009d80: 9d e3 bf 80 save %sp, -128, %sp
uintptr_t const page_size = heap->page_size;
2009d84: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
uintptr_t const min_block_size = heap->min_block_size;
2009d88: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
Heap_Block *const first_block = heap->first_block;
2009d8c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
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;
2009d90: 80 a6 a0 00 cmp %i2, 0
2009d94: 02 80 00 0c be 2009dc4 <_Heap_Walk+0x44>
2009d98: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
if ( !_System_state_Is_up( _System_state_Get() ) ) {
2009d9c: 03 00 80 83 sethi %hi(0x2020c00), %g1
2009da0: c4 00 61 58 ld [ %g1 + 0x158 ], %g2 ! 2020d58 <_System_state_Current>
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;
2009da4: 07 00 80 27 sethi %hi(0x2009c00), %g3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
2009da8: 82 10 20 01 mov 1, %g1
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
2009dac: 80 a0 a0 03 cmp %g2, 3
2009db0: 02 80 00 0c be 2009de0 <_Heap_Walk+0x60> <== ALWAYS TAKEN
2009db4: ae 10 e1 1c or %g3, 0x11c, %l7
2009db8: b0 08 60 ff and %g1, 0xff, %i0
2009dbc: 81 c7 e0 08 ret
2009dc0: 81 e8 00 00 restore
2009dc4: 03 00 80 83 sethi %hi(0x2020c00), %g1
2009dc8: c4 00 61 58 ld [ %g1 + 0x158 ], %g2 ! 2020d58 <_System_state_Current>
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;
2009dcc: 07 00 80 27 sethi %hi(0x2009c00), %g3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
2009dd0: 82 10 20 01 mov 1, %g1
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
2009dd4: 80 a0 a0 03 cmp %g2, 3
2009dd8: 12 bf ff f8 bne 2009db8 <_Heap_Walk+0x38>
2009ddc: ae 10 e1 14 or %g3, 0x114, %l7
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)(
2009de0: da 06 20 18 ld [ %i0 + 0x18 ], %o5
2009de4: c8 06 20 1c ld [ %i0 + 0x1c ], %g4
2009de8: c4 06 20 08 ld [ %i0 + 8 ], %g2
2009dec: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2009df0: 90 10 00 19 mov %i1, %o0
2009df4: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
2009df8: f8 23 a0 60 st %i4, [ %sp + 0x60 ]
2009dfc: e2 23 a0 64 st %l1, [ %sp + 0x64 ]
2009e00: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
2009e04: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2009e08: 92 10 20 00 clr %o1
2009e0c: 96 10 00 1b mov %i3, %o3
2009e10: 15 00 80 74 sethi %hi(0x201d000), %o2
2009e14: 98 10 00 10 mov %l0, %o4
2009e18: 9f c5 c0 00 call %l7
2009e1c: 94 12 a3 a0 or %o2, 0x3a0, %o2
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
2009e20: 80 a6 e0 00 cmp %i3, 0
2009e24: 02 80 00 2a be 2009ecc <_Heap_Walk+0x14c>
2009e28: 80 8e e0 07 btst 7, %i3
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
2009e2c: 12 80 00 2f bne 2009ee8 <_Heap_Walk+0x168>
2009e30: 90 10 00 10 mov %l0, %o0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
2009e34: 7f ff df 4f call 2001b70 <.urem>
2009e38: 92 10 00 1b mov %i3, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
2009e3c: 80 a2 20 00 cmp %o0, 0
2009e40: 12 80 00 32 bne 2009f08 <_Heap_Walk+0x188>
2009e44: 90 07 20 08 add %i4, 8, %o0
2009e48: 7f ff df 4a call 2001b70 <.urem>
2009e4c: 92 10 00 1b mov %i3, %o1
);
return false;
}
if (
2009e50: 80 a2 20 00 cmp %o0, 0
2009e54: 32 80 00 35 bne,a 2009f28 <_Heap_Walk+0x1a8>
2009e58: 90 10 00 19 mov %i1, %o0
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;
2009e5c: ec 07 20 04 ld [ %i4 + 4 ], %l6
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
2009e60: b4 8d a0 01 andcc %l6, 1, %i2
2009e64: 22 80 00 38 be,a 2009f44 <_Heap_Walk+0x1c4>
2009e68: 90 10 00 19 mov %i1, %o0
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
2009e6c: c2 04 60 04 ld [ %l1 + 4 ], %g1
2009e70: 82 08 7f fe and %g1, -2, %g1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
2009e74: 82 04 40 01 add %l1, %g1, %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;
2009e78: fa 00 60 04 ld [ %g1 + 4 ], %i5
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
2009e7c: 80 8f 60 01 btst 1, %i5
2009e80: 02 80 00 0c be 2009eb0 <_Heap_Walk+0x130>
2009e84: 80 a7 00 01 cmp %i4, %g1
);
return false;
}
if (
2009e88: 02 80 00 35 be 2009f5c <_Heap_Walk+0x1dc>
2009e8c: 90 10 00 19 mov %i1, %o0
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
2009e90: 92 10 20 01 mov 1, %o1
2009e94: 15 00 80 75 sethi %hi(0x201d400), %o2
2009e98: 9f c5 c0 00 call %l7
2009e9c: 94 12 a1 18 or %o2, 0x118, %o2 ! 201d518 <__log2table+0x2d8>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009ea0: 82 10 20 00 clr %g1
2009ea4: b0 08 60 ff and %g1, 0xff, %i0
2009ea8: 81 c7 e0 08 ret
2009eac: 81 e8 00 00 restore
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
2009eb0: 90 10 00 19 mov %i1, %o0
2009eb4: 92 10 20 01 mov 1, %o1
2009eb8: 15 00 80 75 sethi %hi(0x201d400), %o2
2009ebc: 9f c5 c0 00 call %l7
2009ec0: 94 12 a1 00 or %o2, 0x100, %o2 ! 201d500 <__log2table+0x2c0>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009ec4: 10 bf ff f8 b 2009ea4 <_Heap_Walk+0x124>
2009ec8: 82 10 20 00 clr %g1
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
2009ecc: 90 10 00 19 mov %i1, %o0
2009ed0: 92 10 20 01 mov 1, %o1
2009ed4: 15 00 80 75 sethi %hi(0x201d400), %o2
2009ed8: 9f c5 c0 00 call %l7
2009edc: 94 12 a0 38 or %o2, 0x38, %o2 ! 201d438 <__log2table+0x1f8>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009ee0: 10 bf ff f1 b 2009ea4 <_Heap_Walk+0x124>
2009ee4: 82 10 20 00 clr %g1
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
2009ee8: 90 10 00 19 mov %i1, %o0
2009eec: 92 10 20 01 mov 1, %o1
2009ef0: 15 00 80 75 sethi %hi(0x201d400), %o2
2009ef4: 96 10 00 1b mov %i3, %o3
2009ef8: 9f c5 c0 00 call %l7
2009efc: 94 12 a0 50 or %o2, 0x50, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009f00: 10 bf ff e9 b 2009ea4 <_Heap_Walk+0x124>
2009f04: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
2009f08: 90 10 00 19 mov %i1, %o0
2009f0c: 92 10 20 01 mov 1, %o1
2009f10: 15 00 80 75 sethi %hi(0x201d400), %o2
2009f14: 96 10 00 10 mov %l0, %o3
2009f18: 9f c5 c0 00 call %l7
2009f1c: 94 12 a0 70 or %o2, 0x70, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009f20: 10 bf ff e1 b 2009ea4 <_Heap_Walk+0x124>
2009f24: 82 10 20 00 clr %g1
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
2009f28: 92 10 20 01 mov 1, %o1
2009f2c: 15 00 80 75 sethi %hi(0x201d400), %o2
2009f30: 96 10 00 1c mov %i4, %o3
2009f34: 9f c5 c0 00 call %l7
2009f38: 94 12 a0 98 or %o2, 0x98, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009f3c: 10 bf ff da b 2009ea4 <_Heap_Walk+0x124>
2009f40: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
2009f44: 92 10 20 01 mov 1, %o1
2009f48: 15 00 80 75 sethi %hi(0x201d400), %o2
2009f4c: 9f c5 c0 00 call %l7
2009f50: 94 12 a0 d0 or %o2, 0xd0, %o2 ! 201d4d0 <__log2table+0x290>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009f54: 10 bf ff d4 b 2009ea4 <_Heap_Walk+0x124>
2009f58: 82 10 20 00 clr %g1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
2009f5c: fa 06 20 08 ld [ %i0 + 8 ], %i5
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
2009f60: e8 06 20 10 ld [ %i0 + 0x10 ], %l4
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 ) {
2009f64: 80 a6 00 1d cmp %i0, %i5
2009f68: 02 80 00 0d be 2009f9c <_Heap_Walk+0x21c>
2009f6c: da 06 20 20 ld [ %i0 + 0x20 ], %o5
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;
2009f70: 80 a3 40 1d cmp %o5, %i5
2009f74: 28 80 00 bf bleu,a 200a270 <_Heap_Walk+0x4f0> <== ALWAYS TAKEN
2009f78: e6 06 20 24 ld [ %i0 + 0x24 ], %l3
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
2009f7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2009f80: 92 10 20 01 mov 1, %o1
2009f84: 15 00 80 75 sethi %hi(0x201d400), %o2
2009f88: 96 10 00 1d mov %i5, %o3
2009f8c: 9f c5 c0 00 call %l7
2009f90: 94 12 a1 48 or %o2, 0x148, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
2009f94: 10 bf ff c4 b 2009ea4 <_Heap_Walk+0x124>
2009f98: 82 10 20 00 clr %g1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
2009f9c: 27 00 80 75 sethi %hi(0x201d400), %l3
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
2009fa0: 25 00 80 75 sethi %hi(0x201d400), %l2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
2009fa4: aa 10 00 1c mov %i4, %l5
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
2009fa8: a6 14 e3 78 or %l3, 0x378, %l3
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
2009fac: a4 14 a3 60 or %l2, 0x360, %l2
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
2009fb0: 29 00 80 75 sethi %hi(0x201d400), %l4
- 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;
2009fb4: ac 0d bf fe and %l6, -2, %l6
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
2009fb8: ba 05 80 15 add %l6, %l5, %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;
2009fbc: 80 a3 40 1d cmp %o5, %i5
2009fc0: 28 80 00 0b bleu,a 2009fec <_Heap_Walk+0x26c> <== ALWAYS TAKEN
2009fc4: de 06 20 24 ld [ %i0 + 0x24 ], %o7
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
2009fc8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2009fcc: 92 10 20 01 mov 1, %o1
2009fd0: 96 10 00 15 mov %l5, %o3
2009fd4: 15 00 80 75 sethi %hi(0x201d400), %o2
2009fd8: 98 10 00 1d mov %i5, %o4
2009fdc: 9f c5 c0 00 call %l7
2009fe0: 94 12 a1 f0 or %o2, 0x1f0, %o2
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
2009fe4: 10 bf ff 75 b 2009db8 <_Heap_Walk+0x38>
2009fe8: 82 10 20 00 clr %g1
2009fec: 80 a3 c0 1d cmp %o7, %i5
2009ff0: 0a bf ff f7 bcs 2009fcc <_Heap_Walk+0x24c>
2009ff4: 90 10 00 19 mov %i1, %o0
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;
2009ff8: 9e 1d 40 11 xor %l5, %l1, %o7
2009ffc: 80 a0 00 0f cmp %g0, %o7
200a000: 9a 40 20 00 addx %g0, 0, %o5
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
200a004: 90 10 00 16 mov %l6, %o0
200a008: da 27 bf fc st %o5, [ %fp + -4 ]
200a00c: 7f ff de d9 call 2001b70 <.urem>
200a010: 92 10 00 1b mov %i3, %o1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
200a014: 80 a2 20 00 cmp %o0, 0
200a018: 02 80 00 18 be 200a078 <_Heap_Walk+0x2f8>
200a01c: da 07 bf fc ld [ %fp + -4 ], %o5
200a020: 80 8b 60 ff btst 0xff, %o5
200a024: 12 80 00 8b bne 200a250 <_Heap_Walk+0x4d0>
200a028: 90 10 00 19 mov %i1, %o0
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;
200a02c: de 07 60 04 ld [ %i5 + 4 ], %o7
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
200a030: 80 8b e0 01 btst 1, %o7
200a034: 02 80 00 2b be 200a0e0 <_Heap_Walk+0x360>
200a038: 80 a6 a0 00 cmp %i2, 0
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
200a03c: 22 80 00 21 be,a 200a0c0 <_Heap_Walk+0x340>
200a040: da 05 40 00 ld [ %l5 ], %o5
(*printer)(
200a044: 90 10 00 19 mov %i1, %o0
200a048: 92 10 20 00 clr %o1
200a04c: 94 10 00 12 mov %l2, %o2
200a050: 96 10 00 15 mov %l5, %o3
200a054: 9f c5 c0 00 call %l7
200a058: 98 10 00 16 mov %l6, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
200a05c: 80 a7 00 1d cmp %i4, %i5
200a060: 02 80 00 51 be 200a1a4 <_Heap_Walk+0x424>
200a064: aa 10 00 1d mov %i5, %l5
200a068: ec 07 60 04 ld [ %i5 + 4 ], %l6
200a06c: da 06 20 20 ld [ %i0 + 0x20 ], %o5
200a070: 10 bf ff d1 b 2009fb4 <_Heap_Walk+0x234>
200a074: b4 0d a0 01 and %l6, 1, %i2
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
200a078: 80 a5 80 10 cmp %l6, %l0
200a07c: 0a 80 00 69 bcs 200a220 <_Heap_Walk+0x4a0>
200a080: 80 8b 60 ff btst 0xff, %o5
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
200a084: 80 a5 40 1d cmp %l5, %i5
200a088: 2a bf ff ea bcs,a 200a030 <_Heap_Walk+0x2b0>
200a08c: de 07 60 04 ld [ %i5 + 4 ], %o7
200a090: 80 8b 60 ff btst 0xff, %o5
200a094: 22 bf ff e7 be,a 200a030 <_Heap_Walk+0x2b0>
200a098: de 07 60 04 ld [ %i5 + 4 ], %o7
(*printer)(
200a09c: 90 10 00 19 mov %i1, %o0
200a0a0: 92 10 20 01 mov 1, %o1
200a0a4: 96 10 00 15 mov %l5, %o3
200a0a8: 15 00 80 75 sethi %hi(0x201d400), %o2
200a0ac: 98 10 00 1d mov %i5, %o4
200a0b0: 9f c5 c0 00 call %l7
200a0b4: 94 12 a2 80 or %o2, 0x280, %o2
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
200a0b8: 10 bf ff 40 b 2009db8 <_Heap_Walk+0x38>
200a0bc: 82 10 20 00 clr %g1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
200a0c0: 96 10 00 15 mov %l5, %o3
200a0c4: 90 10 00 19 mov %i1, %o0
200a0c8: 92 10 20 00 clr %o1
200a0cc: 94 10 00 13 mov %l3, %o2
200a0d0: 9f c5 c0 00 call %l7
200a0d4: 98 10 00 16 mov %l6, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
200a0d8: 10 bf ff e2 b 200a060 <_Heap_Walk+0x2e0>
200a0dc: 80 a7 00 1d cmp %i4, %i5
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 ?
200a0e0: da 05 60 0c ld [ %l5 + 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)(
200a0e4: de 06 20 08 ld [ %i0 + 8 ], %o7
200a0e8: 80 a3 c0 0d cmp %o7, %o5
200a0ec: 02 80 00 3d be 200a1e0 <_Heap_Walk+0x460>
200a0f0: d8 06 20 0c ld [ %i0 + 0xc ], %o4
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
200a0f4: 80 a6 00 0d cmp %i0, %o5
200a0f8: 02 80 00 40 be 200a1f8 <_Heap_Walk+0x478>
200a0fc: 96 15 23 28 or %l4, 0x328, %o3
block->next,
block->next == last_free_block ?
200a100: de 05 60 08 ld [ %l5 + 8 ], %o7
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
200a104: 80 a3 00 0f cmp %o4, %o7
200a108: 02 80 00 33 be 200a1d4 <_Heap_Walk+0x454>
200a10c: 80 a6 00 0f cmp %i0, %o7
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
200a110: 02 80 00 37 be 200a1ec <_Heap_Walk+0x46c>
200a114: 98 15 23 28 or %l4, 0x328, %o4
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
200a118: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
200a11c: d8 23 a0 64 st %o4, [ %sp + 0x64 ]
200a120: de 23 a0 60 st %o7, [ %sp + 0x60 ]
200a124: 90 10 00 19 mov %i1, %o0
200a128: 92 10 20 00 clr %o1
200a12c: 15 00 80 75 sethi %hi(0x201d400), %o2
200a130: 96 10 00 15 mov %l5, %o3
200a134: 94 12 a2 b8 or %o2, 0x2b8, %o2
200a138: 9f c5 c0 00 call %l7
200a13c: 98 10 00 16 mov %l6, %o4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
200a140: da 07 40 00 ld [ %i5 ], %o5
200a144: 80 a5 80 0d cmp %l6, %o5
200a148: 12 80 00 19 bne 200a1ac <_Heap_Walk+0x42c>
200a14c: 80 a6 a0 00 cmp %i2, 0
);
return false;
}
if ( !prev_used ) {
200a150: 02 80 00 2d be 200a204 <_Heap_Walk+0x484>
200a154: 90 10 00 19 mov %i1, %o0
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
200a158: c4 06 20 08 ld [ %i0 + 8 ], %g2
)
{
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 ) {
200a15c: 80 a6 00 02 cmp %i0, %g2
200a160: 02 80 00 0b be 200a18c <_Heap_Walk+0x40c> <== NEVER TAKEN
200a164: 92 10 20 01 mov 1, %o1
if ( free_block == block ) {
200a168: 80 a5 40 02 cmp %l5, %g2
200a16c: 02 bf ff bd be 200a060 <_Heap_Walk+0x2e0>
200a170: 80 a7 00 1d cmp %i4, %i5
return true;
}
free_block = free_block->next;
200a174: c4 00 a0 08 ld [ %g2 + 8 ], %g2
)
{
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 ) {
200a178: 80 a6 00 02 cmp %i0, %g2
200a17c: 12 bf ff fc bne 200a16c <_Heap_Walk+0x3ec>
200a180: 80 a5 40 02 cmp %l5, %g2
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
200a184: 90 10 00 19 mov %i1, %o0
200a188: 92 10 20 01 mov 1, %o1
200a18c: 15 00 80 75 sethi %hi(0x201d400), %o2
200a190: 96 10 00 15 mov %l5, %o3
200a194: 9f c5 c0 00 call %l7
200a198: 94 12 a3 a0 or %o2, 0x3a0, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
200a19c: 10 bf ff 42 b 2009ea4 <_Heap_Walk+0x124>
200a1a0: 82 10 20 00 clr %g1
}
block = next_block;
} while ( block != first_block );
return true;
200a1a4: 10 bf ff 05 b 2009db8 <_Heap_Walk+0x38>
200a1a8: 82 10 20 01 mov 1, %g1
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
200a1ac: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
200a1b0: 90 10 00 19 mov %i1, %o0
200a1b4: 92 10 20 01 mov 1, %o1
200a1b8: 15 00 80 75 sethi %hi(0x201d400), %o2
200a1bc: 96 10 00 15 mov %l5, %o3
200a1c0: 94 12 a2 f0 or %o2, 0x2f0, %o2
200a1c4: 9f c5 c0 00 call %l7
200a1c8: 98 10 00 16 mov %l6, %o4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
200a1cc: 10 bf ff 36 b 2009ea4 <_Heap_Walk+0x124>
200a1d0: 82 10 20 00 clr %g1
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)(
200a1d4: 03 00 80 74 sethi %hi(0x201d000), %g1
200a1d8: 10 bf ff d0 b 200a118 <_Heap_Walk+0x398>
200a1dc: 98 10 63 80 or %g1, 0x380, %o4 ! 201d380 <__log2table+0x140>
200a1e0: 03 00 80 74 sethi %hi(0x201d000), %g1
200a1e4: 10 bf ff c7 b 200a100 <_Heap_Walk+0x380>
200a1e8: 96 10 63 60 or %g1, 0x360, %o3 ! 201d360 <__log2table+0x120>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
200a1ec: 03 00 80 74 sethi %hi(0x201d000), %g1
200a1f0: 10 bf ff ca b 200a118 <_Heap_Walk+0x398>
200a1f4: 98 10 63 90 or %g1, 0x390, %o4 ! 201d390 <__log2table+0x150>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
200a1f8: 17 00 80 74 sethi %hi(0x201d000), %o3
200a1fc: 10 bf ff c1 b 200a100 <_Heap_Walk+0x380>
200a200: 96 12 e3 70 or %o3, 0x370, %o3 ! 201d370 <__log2table+0x130>
return false;
}
if ( !prev_used ) {
(*printer)(
200a204: 92 10 20 01 mov 1, %o1
200a208: 15 00 80 75 sethi %hi(0x201d400), %o2
200a20c: 96 10 00 15 mov %l5, %o3
200a210: 9f c5 c0 00 call %l7
200a214: 94 12 a3 30 or %o2, 0x330, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
200a218: 10 bf ff 23 b 2009ea4 <_Heap_Walk+0x124>
200a21c: 82 10 20 00 clr %g1
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
200a220: 02 bf ff 9a be 200a088 <_Heap_Walk+0x308> <== NEVER TAKEN
200a224: 80 a5 40 1d cmp %l5, %i5
(*printer)(
200a228: 90 10 00 19 mov %i1, %o0
200a22c: 92 10 20 01 mov 1, %o1
200a230: 96 10 00 15 mov %l5, %o3
200a234: 15 00 80 75 sethi %hi(0x201d400), %o2
200a238: 98 10 00 16 mov %l6, %o4
200a23c: 94 12 a2 50 or %o2, 0x250, %o2
200a240: 9f c5 c0 00 call %l7
200a244: 9a 10 00 10 mov %l0, %o5
block,
block_size,
min_block_size
);
return false;
200a248: 10 bf fe dc b 2009db8 <_Heap_Walk+0x38>
200a24c: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
200a250: 92 10 20 01 mov 1, %o1
200a254: 96 10 00 15 mov %l5, %o3
200a258: 15 00 80 75 sethi %hi(0x201d400), %o2
200a25c: 98 10 00 16 mov %l6, %o4
200a260: 9f c5 c0 00 call %l7
200a264: 94 12 a2 20 or %o2, 0x220, %o2
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
200a268: 10 bf fe d4 b 2009db8 <_Heap_Walk+0x38>
200a26c: 82 10 20 00 clr %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;
200a270: 80 a4 c0 1d cmp %l3, %i5
200a274: 0a bf ff 43 bcs 2009f80 <_Heap_Walk+0x200> <== NEVER TAKEN
200a278: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
200a27c: da 27 bf fc st %o5, [ %fp + -4 ]
200a280: 90 07 60 08 add %i5, 8, %o0
200a284: 7f ff de 3b call 2001b70 <.urem>
200a288: 92 10 00 14 mov %l4, %o1
);
return false;
}
if (
200a28c: 80 a2 20 00 cmp %o0, 0
200a290: 12 80 00 36 bne 200a368 <_Heap_Walk+0x5e8> <== NEVER TAKEN
200a294: da 07 bf fc ld [ %fp + -4 ], %o5
- 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;
200a298: c2 07 60 04 ld [ %i5 + 4 ], %g1
200a29c: 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;
200a2a0: 82 07 40 01 add %i5, %g1, %g1
200a2a4: c2 00 60 04 ld [ %g1 + 4 ], %g1
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
200a2a8: 80 88 60 01 btst 1, %g1
200a2ac: 12 80 00 27 bne 200a348 <_Heap_Walk+0x5c8> <== NEVER TAKEN
200a2b0: a4 10 00 1d mov %i5, %l2
200a2b4: 10 80 00 19 b 200a318 <_Heap_Walk+0x598>
200a2b8: 82 10 00 18 mov %i0, %g1
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 ) {
200a2bc: 80 a6 00 1d cmp %i0, %i5
200a2c0: 02 bf ff 37 be 2009f9c <_Heap_Walk+0x21c>
200a2c4: 80 a7 40 0d cmp %i5, %o5
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;
200a2c8: 0a bf ff 2e bcs 2009f80 <_Heap_Walk+0x200>
200a2cc: 90 10 00 19 mov %i1, %o0
200a2d0: 80 a7 40 13 cmp %i5, %l3
200a2d4: 18 bf ff 2c bgu 2009f84 <_Heap_Walk+0x204> <== NEVER TAKEN
200a2d8: 92 10 20 01 mov 1, %o1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
200a2dc: da 27 bf fc st %o5, [ %fp + -4 ]
200a2e0: 90 07 60 08 add %i5, 8, %o0
200a2e4: 7f ff de 23 call 2001b70 <.urem>
200a2e8: 92 10 00 14 mov %l4, %o1
);
return false;
}
if (
200a2ec: 80 a2 20 00 cmp %o0, 0
200a2f0: 12 80 00 1e bne 200a368 <_Heap_Walk+0x5e8>
200a2f4: da 07 bf fc ld [ %fp + -4 ], %o5
- 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;
200a2f8: de 07 60 04 ld [ %i5 + 4 ], %o7
200a2fc: 82 10 00 12 mov %l2, %g1
200a300: 9e 0b ff fe and %o7, -2, %o7
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;
200a304: 9e 03 c0 1d add %o7, %i5, %o7
200a308: de 03 e0 04 ld [ %o7 + 4 ], %o7
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
200a30c: 80 8b e0 01 btst 1, %o7
200a310: 12 80 00 0e bne 200a348 <_Heap_Walk+0x5c8>
200a314: a4 10 00 1d mov %i5, %l2
);
return false;
}
if ( free_block->prev != prev_block ) {
200a318: d8 07 60 0c ld [ %i5 + 0xc ], %o4
200a31c: 80 a3 00 01 cmp %o4, %g1
200a320: 22 bf ff e7 be,a 200a2bc <_Heap_Walk+0x53c>
200a324: fa 07 60 08 ld [ %i5 + 8 ], %i5
(*printer)(
200a328: 90 10 00 19 mov %i1, %o0
200a32c: 92 10 20 01 mov 1, %o1
200a330: 15 00 80 75 sethi %hi(0x201d400), %o2
200a334: 96 10 00 1d mov %i5, %o3
200a338: 9f c5 c0 00 call %l7
200a33c: 94 12 a1 b8 or %o2, 0x1b8, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
200a340: 10 bf fe d9 b 2009ea4 <_Heap_Walk+0x124>
200a344: 82 10 20 00 clr %g1
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
200a348: 90 10 00 19 mov %i1, %o0
200a34c: 92 10 20 01 mov 1, %o1
200a350: 15 00 80 75 sethi %hi(0x201d400), %o2
200a354: 96 10 00 1d mov %i5, %o3
200a358: 9f c5 c0 00 call %l7
200a35c: 94 12 a1 98 or %o2, 0x198, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
200a360: 10 bf fe d1 b 2009ea4 <_Heap_Walk+0x124>
200a364: 82 10 20 00 clr %g1
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
200a368: 90 10 00 19 mov %i1, %o0
200a36c: 92 10 20 01 mov 1, %o1
200a370: 15 00 80 75 sethi %hi(0x201d400), %o2
200a374: 96 10 00 1d mov %i5, %o3
200a378: 9f c5 c0 00 call %l7
200a37c: 94 12 a1 68 or %o2, 0x168, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
200a380: 10 bf fe c9 b 2009ea4 <_Heap_Walk+0x124>
200a384: 82 10 20 00 clr %g1
020083e8 <_IO_Initialize_all_drivers>:
_IO_Driver_address_table[index] = driver_table[index];
}
void _IO_Initialize_all_drivers( void )
{
20083e8: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
20083ec: 39 00 80 7b sethi %hi(0x201ec00), %i4
20083f0: c2 07 20 88 ld [ %i4 + 0x88 ], %g1 ! 201ec88 <_IO_Number_of_drivers>
20083f4: ba 10 20 00 clr %i5
20083f8: 80 a0 60 00 cmp %g1, 0
20083fc: 02 80 00 0b be 2008428 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN
2008400: b8 17 20 88 or %i4, 0x88, %i4
(void) rtems_io_initialize( major, 0, NULL );
2008404: 90 10 00 1d mov %i5, %o0
2008408: 92 10 20 00 clr %o1
200840c: 40 00 16 27 call 200dca8 <rtems_io_initialize>
2008410: 94 10 20 00 clr %o2
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
2008414: c2 07 00 00 ld [ %i4 ], %g1
2008418: ba 07 60 01 inc %i5
200841c: 80 a0 40 1d cmp %g1, %i5
2008420: 18 bf ff fa bgu 2008408 <_IO_Initialize_all_drivers+0x20>
2008424: 90 10 00 1d mov %i5, %o0
2008428: 81 c7 e0 08 ret
200842c: 81 e8 00 00 restore
02008318 <_IO_Manager_initialization>:
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
{
2008318: 9d e3 bf a0 save %sp, -96, %sp
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = rtems_configuration_get_device_driver_table();
200831c: 03 00 80 6d sethi %hi(0x201b400), %g1
2008320: 82 10 60 c8 or %g1, 0xc8, %g1 ! 201b4c8 <Configuration>
drivers_in_table = rtems_configuration_get_number_of_device_drivers();
2008324: f8 00 60 38 ld [ %g1 + 0x38 ], %i4
number_of_drivers = rtems_configuration_get_maximum_drivers();
2008328: f6 00 60 34 ld [ %g1 + 0x34 ], %i3
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
200832c: 80 a7 00 1b cmp %i4, %i3
2008330: 0a 80 00 08 bcs 2008350 <_IO_Manager_initialization+0x38>
2008334: fa 00 60 3c ld [ %g1 + 0x3c ], %i5
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
2008338: 03 00 80 7b sethi %hi(0x201ec00), %g1
200833c: fa 20 60 8c st %i5, [ %g1 + 0x8c ] ! 201ec8c <_IO_Driver_address_table>
_IO_Number_of_drivers = number_of_drivers;
2008340: 03 00 80 7b sethi %hi(0x201ec00), %g1
2008344: f8 20 60 88 st %i4, [ %g1 + 0x88 ] ! 201ec88 <_IO_Number_of_drivers>
return;
2008348: 81 c7 e0 08 ret
200834c: 81 e8 00 00 restore
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
2008350: 83 2e e0 03 sll %i3, 3, %g1
2008354: b5 2e e0 05 sll %i3, 5, %i2
2008358: b4 26 80 01 sub %i2, %g1, %i2
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
200835c: 40 00 0d 7c call 200b94c <_Workspace_Allocate_or_fatal_error>
2008360: 90 10 00 1a mov %i2, %o0
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
2008364: 03 00 80 7b sethi %hi(0x201ec00), %g1
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
2008368: 33 00 80 7b sethi %hi(0x201ec00), %i1
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
200836c: f6 20 60 88 st %i3, [ %g1 + 0x88 ]
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
2008370: d0 26 60 8c st %o0, [ %i1 + 0x8c ]
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
2008374: 92 10 20 00 clr %o1
2008378: 40 00 22 a6 call 2010e10 <memset>
200837c: 94 10 00 1a mov %i2, %o2
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
2008380: 80 a7 20 00 cmp %i4, 0
2008384: 02 bf ff f1 be 2008348 <_IO_Manager_initialization+0x30> <== NEVER TAKEN
2008388: c8 06 60 8c ld [ %i1 + 0x8c ], %g4
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
200838c: 85 2f 20 03 sll %i4, 3, %g2
2008390: b7 2f 20 05 sll %i4, 5, %i3
2008394: 82 10 20 00 clr %g1
2008398: b6 26 c0 02 sub %i3, %g2, %i3
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
200839c: c4 07 40 01 ld [ %i5 + %g1 ], %g2
20083a0: 86 07 40 01 add %i5, %g1, %g3
20083a4: c4 21 00 01 st %g2, [ %g4 + %g1 ]
20083a8: f8 00 e0 04 ld [ %g3 + 4 ], %i4
20083ac: 84 01 00 01 add %g4, %g1, %g2
20083b0: f8 20 a0 04 st %i4, [ %g2 + 4 ]
20083b4: f8 00 e0 08 ld [ %g3 + 8 ], %i4
20083b8: 82 00 60 18 add %g1, 0x18, %g1
20083bc: f8 20 a0 08 st %i4, [ %g2 + 8 ]
20083c0: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
20083c4: 80 a0 40 1b cmp %g1, %i3
_IO_Driver_address_table[index] = driver_table[index];
20083c8: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
20083cc: f8 00 e0 10 ld [ %g3 + 0x10 ], %i4
20083d0: f8 20 a0 10 st %i4, [ %g2 + 0x10 ]
20083d4: c6 00 e0 14 ld [ %g3 + 0x14 ], %g3
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
20083d8: 12 bf ff f1 bne 200839c <_IO_Manager_initialization+0x84>
20083dc: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
20083e0: 81 c7 e0 08 ret
20083e4: 81 e8 00 00 restore
020090e0 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
20090e0: 9d e3 bf 90 save %sp, -112, %sp
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
20090e4: 13 00 80 2c sethi %hi(0x200b000), %o1
20090e8: 90 07 bf f4 add %fp, -12, %o0
20090ec: 92 12 63 84 or %o1, 0x384, %o1
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
20090f0: f0 27 bf f4 st %i0, [ %fp + -12 ]
20090f4: f2 2f bf f8 stb %i1, [ %fp + -8 ]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
20090f8: 40 00 08 ae call 200b3b0 <_User_extensions_Iterate>
20090fc: f4 27 bf fc st %i2, [ %fp + -4 ]
_User_extensions_Fatal( the_source, is_internal, the_error );
_Internal_errors_What_happened.the_source = the_source;
2009100: 05 00 80 7a sethi %hi(0x201e800), %g2 <== NOT EXECUTED
2009104: 82 10 a0 2c or %g2, 0x2c, %g1 ! 201e82c <_Internal_errors_What_happened><== NOT EXECUTED
2009108: f0 20 a0 2c st %i0, [ %g2 + 0x2c ] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
200910c: f2 28 60 04 stb %i1, [ %g1 + 4 ] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
2009110: f4 20 60 08 st %i2, [ %g1 + 8 ] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
2009114: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
2009118: 03 00 80 7a sethi %hi(0x201e800), %g1 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
200911c: 7f ff e5 3c call 200260c <sparc_disable_interrupts> <== NOT EXECUTED
2009120: c4 20 60 38 st %g2, [ %g1 + 0x38 ] ! 201e838 <_System_state_Current><== NOT EXECUTED
2009124: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
2009128: 30 80 00 00 b,a 2009128 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
02009198 <_Objects_Allocate>:
#endif
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2009198: 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 )
200919c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20091a0: 80 a0 60 00 cmp %g1, 0
20091a4: 02 80 00 26 be 200923c <_Objects_Allocate+0xa4> <== NEVER TAKEN
20091a8: ba 10 00 18 mov %i0, %i5
/*
* 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 );
20091ac: b8 06 20 20 add %i0, 0x20, %i4
20091b0: 7f ff fd 4c call 20086e0 <_Chain_Get>
20091b4: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
20091b8: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
20091bc: 80 a0 60 00 cmp %g1, 0
20091c0: 02 80 00 16 be 2009218 <_Objects_Allocate+0x80>
20091c4: 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 ) {
20091c8: 80 a2 20 00 cmp %o0, 0
20091cc: 02 80 00 15 be 2009220 <_Objects_Allocate+0x88>
20091d0: 01 00 00 00 nop
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
20091d4: c4 07 60 08 ld [ %i5 + 8 ], %g2
20091d8: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
20091dc: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
20091e0: 03 00 00 3f sethi %hi(0xfc00), %g1
20091e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
20091e8: 90 0a 00 01 and %o0, %g1, %o0
20091ec: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
20091f0: 40 00 3f f7 call 20191cc <.udiv>
20091f4: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
20091f8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
20091fc: 91 2a 20 02 sll %o0, 2, %o0
2009200: c6 00 40 08 ld [ %g1 + %o0 ], %g3
information->inactive--;
2009204: c4 17 60 2c lduh [ %i5 + 0x2c ], %g2
block = (uint32_t) _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
2009208: 86 00 ff ff add %g3, -1, %g3
200920c: c6 20 40 08 st %g3, [ %g1 + %o0 ]
information->inactive--;
2009210: 82 00 bf ff add %g2, -1, %g1
2009214: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
2009218: 81 c7 e0 08 ret
200921c: 81 e8 00 00 restore
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
2009220: 40 00 00 10 call 2009260 <_Objects_Extend_information>
2009224: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
2009228: 7f ff fd 2e call 20086e0 <_Chain_Get>
200922c: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
2009230: b0 92 20 00 orcc %o0, 0, %i0
2009234: 32 bf ff e9 bne,a 20091d8 <_Objects_Allocate+0x40>
2009238: c4 07 60 08 ld [ %i5 + 8 ], %g2
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
200923c: 81 c7 e0 08 ret
2009240: 91 e8 20 00 restore %g0, 0, %o0
02009260 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
2009260: 9d e3 bf 90 save %sp, -112, %sp
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
2009264: f2 06 20 34 ld [ %i0 + 0x34 ], %i1
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
2009268: e0 16 20 0a lduh [ %i0 + 0xa ], %l0
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
200926c: 80 a6 60 00 cmp %i1, 0
2009270: 02 80 00 a1 be 20094f4 <_Objects_Extend_information+0x294>
2009274: e2 16 20 10 lduh [ %i0 + 0x10 ], %l1
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
2009278: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3
200927c: a3 2c 60 10 sll %l1, 0x10, %l1
2009280: 92 10 00 1b mov %i3, %o1
2009284: 40 00 3f d2 call 20191cc <.udiv>
2009288: 91 34 60 10 srl %l1, 0x10, %o0
200928c: 91 2a 20 10 sll %o0, 0x10, %o0
2009290: b5 32 20 10 srl %o0, 0x10, %i2
for ( ; block < block_count; block++ ) {
2009294: 80 a6 a0 00 cmp %i2, 0
2009298: 02 80 00 af be 2009554 <_Objects_Extend_information+0x2f4><== NEVER TAKEN
200929c: 90 10 00 1b mov %i3, %o0
if ( information->object_blocks[ block ] == NULL ) {
20092a0: c2 06 40 00 ld [ %i1 ], %g1
20092a4: 80 a0 60 00 cmp %g1, 0
20092a8: 02 80 00 b1 be 200956c <_Objects_Extend_information+0x30c><== NEVER TAKEN
20092ac: b8 10 00 10 mov %l0, %i4
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
20092b0: 10 80 00 06 b 20092c8 <_Objects_Extend_information+0x68>
20092b4: ba 10 20 00 clr %i5
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
20092b8: c2 06 40 01 ld [ %i1 + %g1 ], %g1
20092bc: 80 a0 60 00 cmp %g1, 0
20092c0: 22 80 00 08 be,a 20092e0 <_Objects_Extend_information+0x80>
20092c4: b6 10 20 00 clr %i3
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
20092c8: ba 07 60 01 inc %i5
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
20092cc: b8 07 00 1b add %i4, %i3, %i4
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
20092d0: 80 a6 80 1d cmp %i2, %i5
20092d4: 18 bf ff f9 bgu 20092b8 <_Objects_Extend_information+0x58>
20092d8: 83 2f 60 02 sll %i5, 2, %g1
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
20092dc: b6 10 20 01 mov 1, %i3
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
20092e0: b3 34 60 10 srl %l1, 0x10, %i1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
20092e4: 03 00 00 3f sethi %hi(0xfc00), %g1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
20092e8: b2 06 40 08 add %i1, %o0, %i1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
20092ec: 82 10 63 ff or %g1, 0x3ff, %g1
20092f0: 80 a6 40 01 cmp %i1, %g1
20092f4: 18 80 00 9c bgu 2009564 <_Objects_Extend_information+0x304>
20092f8: 01 00 00 00 nop
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
20092fc: 40 00 3f 7a call 20190e4 <.umul>
2009300: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
if ( information->auto_extend ) {
2009304: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
2009308: 80 a0 60 00 cmp %g1, 0
200930c: 02 80 00 6d be 20094c0 <_Objects_Extend_information+0x260>
2009310: 01 00 00 00 nop
new_object_block = _Workspace_Allocate( block_size );
2009314: 40 00 09 80 call 200b914 <_Workspace_Allocate>
2009318: 01 00 00 00 nop
if ( !new_object_block )
200931c: a2 92 20 00 orcc %o0, 0, %l1
2009320: 02 80 00 91 be 2009564 <_Objects_Extend_information+0x304>
2009324: 01 00 00 00 nop
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
2009328: 80 8e e0 ff btst 0xff, %i3
200932c: 22 80 00 42 be,a 2009434 <_Objects_Extend_information+0x1d4>
2009330: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
2009334: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
*/
/*
* Up the block count and maximum
*/
block_count++;
2009338: b6 06 a0 01 add %i2, 1, %i3
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
200933c: 80 a0 60 00 cmp %g1, 0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
2009340: 91 2e e0 01 sll %i3, 1, %o0
2009344: 90 02 00 1b add %o0, %i3, %o0
((maximum + minimum_index) * sizeof(Objects_Control *));
2009348: 90 06 40 08 add %i1, %o0, %o0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
200934c: 90 02 00 10 add %o0, %l0, %o0
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
2009350: 12 80 00 60 bne 20094d0 <_Objects_Extend_information+0x270>
2009354: 91 2a 20 02 sll %o0, 2, %o0
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
2009358: 40 00 09 7d call 200b94c <_Workspace_Allocate_or_fatal_error>
200935c: 01 00 00 00 nop
2009360: a4 10 00 08 mov %o0, %l2
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
2009364: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
/*
* Break the block into the various sections.
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
object_blocks, block_count * sizeof(void*) );
2009368: b7 2e e0 02 sll %i3, 2, %i3
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
200936c: 80 a4 00 01 cmp %l0, %g1
2009370: a6 04 80 1b add %l2, %i3, %l3
2009374: 0a 80 00 67 bcs 2009510 <_Objects_Extend_information+0x2b0>
2009378: b6 04 c0 1b add %l3, %i3, %i3
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
200937c: 85 2c 20 02 sll %l0, 2, %g2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
2009380: 80 a4 20 00 cmp %l0, 0
2009384: 02 80 00 07 be 20093a0 <_Objects_Extend_information+0x140><== NEVER TAKEN
2009388: 82 10 20 00 clr %g1
local_table[ index ] = NULL;
200938c: c0 20 40 1b clr [ %g1 + %i3 ]
2009390: 82 00 60 04 add %g1, 4, %g1
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
2009394: 80 a0 40 02 cmp %g1, %g2
2009398: 32 bf ff fe bne,a 2009390 <_Objects_Extend_information+0x130><== NEVER TAKEN
200939c: c0 20 40 1b clr [ %g1 + %i3 ] <== NOT EXECUTED
20093a0: b5 2e a0 02 sll %i2, 2, %i2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
20093a4: c6 16 20 14 lduh [ %i0 + 0x14 ], %g3
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
20093a8: c0 24 80 1a clr [ %l2 + %i2 ]
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
20093ac: 82 07 00 03 add %i4, %g3, %g1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
20093b0: 80 a7 00 01 cmp %i4, %g1
20093b4: 1a 80 00 0b bcc 20093e0 <_Objects_Extend_information+0x180><== NEVER TAKEN
20093b8: c0 24 c0 1a clr [ %l3 + %i2 ]
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
20093bc: 85 2f 20 02 sll %i4, 2, %g2
20093c0: 87 28 e0 02 sll %g3, 2, %g3
20093c4: 84 06 c0 02 add %i3, %g2, %g2
20093c8: 82 10 20 00 clr %g1
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
20093cc: c0 20 80 01 clr [ %g2 + %g1 ]
20093d0: 82 00 60 04 add %g1, 4, %g1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
20093d4: 80 a0 40 03 cmp %g1, %g3
20093d8: 32 bf ff fe bne,a 20093d0 <_Objects_Extend_information+0x170>
20093dc: c0 20 80 01 clr [ %g2 + %g1 ]
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
20093e0: 7f ff e4 8b call 200260c <sparc_disable_interrupts>
20093e4: 01 00 00 00 nop
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
20093e8: c6 06 00 00 ld [ %i0 ], %g3
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
20093ec: c4 16 20 04 lduh [ %i0 + 4 ], %g2
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
20093f0: f4 06 20 34 ld [ %i0 + 0x34 ], %i2
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
20093f4: f2 36 20 10 sth %i1, [ %i0 + 0x10 ]
20093f8: 87 28 e0 18 sll %g3, 0x18, %g3
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
20093fc: 85 28 a0 1b sll %g2, 0x1b, %g2
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
2009400: e4 26 20 34 st %l2, [ %i0 + 0x34 ]
information->inactive_per_block = inactive_per_block;
2009404: e6 26 20 30 st %l3, [ %i0 + 0x30 ]
information->local_table = local_table;
2009408: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
200940c: 03 00 00 40 sethi %hi(0x10000), %g1
2009410: 82 10 c0 01 or %g3, %g1, %g1
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
2009414: 82 10 40 02 or %g1, %g2, %g1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
2009418: b2 10 40 19 or %g1, %i1, %i1
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
200941c: f2 26 20 0c st %i1, [ %i0 + 0xc ]
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
2009420: 7f ff e4 7f call 200261c <sparc_enable_interrupts>
2009424: 01 00 00 00 nop
_Workspace_Free( old_tables );
2009428: 40 00 09 43 call 200b934 <_Workspace_Free>
200942c: 90 10 00 1a mov %i2, %o0
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
2009430: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
2009434: bb 2f 60 02 sll %i5, 2, %i5
2009438: e2 20 40 1d st %l1, [ %g1 + %i5 ]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
200943c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
2009440: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2
2009444: d2 00 40 1d ld [ %g1 + %i5 ], %o1
2009448: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
200944c: 90 07 bf f4 add %fp, -12, %o0
2009450: 7f ff fc b4 call 2008720 <_Chain_Initialize>
2009454: 35 00 00 40 sethi %hi(0x10000), %i2
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
2009458: 10 80 00 0d b 200948c <_Objects_Extend_information+0x22c>
200945c: b6 06 20 20 add %i0, 0x20, %i3
the_object->id = _Objects_Build_id(
2009460: c6 16 20 04 lduh [ %i0 + 4 ], %g3
2009464: 85 28 a0 18 sll %g2, 0x18, %g2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
2009468: 87 28 e0 1b sll %g3, 0x1b, %g3
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
200946c: 84 10 80 1a or %g2, %i2, %g2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
2009470: 84 10 80 03 or %g2, %g3, %g2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
2009474: 84 10 80 1c or %g2, %i4, %g2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
2009478: 90 10 00 1b mov %i3, %o0
200947c: 92 10 00 01 mov %g1, %o1
index++;
2009480: b8 07 20 01 inc %i4
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
2009484: 7f ff fc 8c call 20086b4 <_Chain_Append>
2009488: c4 20 60 08 st %g2, [ %g1 + 8 ]
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
200948c: 7f ff fc 95 call 20086e0 <_Chain_Get>
2009490: 90 07 bf f4 add %fp, -12, %o0
2009494: 82 92 20 00 orcc %o0, 0, %g1
2009498: 32 bf ff f2 bne,a 2009460 <_Objects_Extend_information+0x200>
200949c: c4 06 00 00 ld [ %i0 ], %g2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
20094a0: c8 16 20 14 lduh [ %i0 + 0x14 ], %g4
20094a4: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
20094a8: c4 16 20 2c lduh [ %i0 + 0x2c ], %g2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
20094ac: c8 20 c0 1d st %g4, [ %g3 + %i5 ]
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
20094b0: 82 00 80 04 add %g2, %g4, %g1
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
20094b4: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
20094b8: 81 c7 e0 08 ret
20094bc: 81 e8 00 00 restore
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
20094c0: 40 00 09 23 call 200b94c <_Workspace_Allocate_or_fatal_error>
20094c4: 01 00 00 00 nop
20094c8: 10 bf ff 98 b 2009328 <_Objects_Extend_information+0xc8>
20094cc: a2 10 00 08 mov %o0, %l1
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
object_blocks = _Workspace_Allocate( block_size );
20094d0: 40 00 09 11 call 200b914 <_Workspace_Allocate>
20094d4: 01 00 00 00 nop
if ( !object_blocks ) {
20094d8: a4 92 20 00 orcc %o0, 0, %l2
20094dc: 32 bf ff a3 bne,a 2009368 <_Objects_Extend_information+0x108>
20094e0: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
_Workspace_Free( new_object_block );
20094e4: 40 00 09 14 call 200b934 <_Workspace_Free>
20094e8: 90 10 00 11 mov %l1, %o0
20094ec: 81 c7 e0 08 ret
20094f0: 81 e8 00 00 restore
20094f4: d0 16 20 14 lduh [ %i0 + 0x14 ], %o0
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
20094f8: b8 10 00 10 mov %l0, %i4
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
20094fc: b6 10 20 01 mov 1, %i3
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
2009500: ba 10 20 00 clr %i5
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
2009504: b4 10 20 00 clr %i2
2009508: 10 bf ff 76 b 20092e0 <_Objects_Extend_information+0x80>
200950c: a3 2c 60 10 sll %l1, 0x10, %l1
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
2009510: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
information->object_blocks,
block_count * sizeof(void*) );
2009514: b5 2e a0 02 sll %i2, 2, %i2
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
2009518: 90 10 00 12 mov %l2, %o0
200951c: 40 00 1e 00 call 2010d1c <memcpy>
2009520: 94 10 00 1a mov %i2, %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
2009524: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
2009528: 94 10 00 1a mov %i2, %o2
200952c: 40 00 1d fc call 2010d1c <memcpy>
2009530: 90 10 00 13 mov %l3, %o0
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
2009534: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
2009538: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
200953c: 94 02 80 10 add %o2, %l0, %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
2009540: 90 10 00 1b mov %i3, %o0
2009544: 40 00 1d f6 call 2010d1c <memcpy>
2009548: 95 2a a0 02 sll %o2, 2, %o2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
200954c: 10 bf ff 97 b 20093a8 <_Objects_Extend_information+0x148>
2009550: c6 16 20 14 lduh [ %i0 + 0x14 ], %g3
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
2009554: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
2009558: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
200955c: 10 bf ff 61 b 20092e0 <_Objects_Extend_information+0x80> <== NOT EXECUTED
2009560: ba 10 20 00 clr %i5 <== NOT EXECUTED
2009564: 81 c7 e0 08 ret
2009568: 81 e8 00 00 restore
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
200956c: b6 10 20 00 clr %i3 <== NOT EXECUTED
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
2009570: 10 bf ff 5c b 20092e0 <_Objects_Extend_information+0x80> <== NOT EXECUTED
2009574: ba 10 20 00 clr %i5 <== NOT EXECUTED
02009628 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
2009628: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
200962c: 80 a6 60 00 cmp %i1, 0
2009630: 02 80 00 19 be 2009694 <_Objects_Get_information+0x6c>
2009634: 01 00 00 00 nop
/*
* 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 );
2009638: 40 00 13 83 call 200e444 <_Objects_API_maximum_class>
200963c: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
2009640: 80 a2 20 00 cmp %o0, 0
2009644: 02 80 00 14 be 2009694 <_Objects_Get_information+0x6c>
2009648: 80 a2 00 19 cmp %o0, %i1
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
200964c: 0a 80 00 12 bcs 2009694 <_Objects_Get_information+0x6c>
2009650: 03 00 80 78 sethi %hi(0x201e000), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
2009654: b1 2e 20 02 sll %i0, 2, %i0
2009658: 82 10 62 84 or %g1, 0x284, %g1
200965c: c2 00 40 18 ld [ %g1 + %i0 ], %g1
2009660: 80 a0 60 00 cmp %g1, 0
2009664: 02 80 00 0c be 2009694 <_Objects_Get_information+0x6c> <== NEVER TAKEN
2009668: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
200966c: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
2009670: 80 a6 20 00 cmp %i0, 0
2009674: 02 80 00 08 be 2009694 <_Objects_Get_information+0x6c> <== NEVER TAKEN
2009678: 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 )
200967c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
2009680: 80 a0 60 00 cmp %g1, 0
2009684: 02 80 00 04 be 2009694 <_Objects_Get_information+0x6c>
2009688: 01 00 00 00 nop
return NULL;
#endif
return info;
}
200968c: 81 c7 e0 08 ret
2009690: 81 e8 00 00 restore
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
2009694: 81 c7 e0 08 ret
2009698: 91 e8 20 00 restore %g0, 0, %o0
02017d90 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
2017d90: 9d e3 bf 90 save %sp, -112, %sp
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
2017d94: 80 a6 60 00 cmp %i1, 0
2017d98: 02 80 00 11 be 2017ddc <_Objects_Get_name_as_string+0x4c>
2017d9c: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( name == NULL )
2017da0: 02 80 00 0f be 2017ddc <_Objects_Get_name_as_string+0x4c>
2017da4: ba 96 20 00 orcc %i0, 0, %i5
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
2017da8: 02 80 00 3d be 2017e9c <_Objects_Get_name_as_string+0x10c>
2017dac: 03 00 80 c6 sethi %hi(0x2031800), %g1
information = _Objects_Get_information_id( tmpId );
2017db0: 7f ff df e4 call 200fd40 <_Objects_Get_information_id>
2017db4: 90 10 00 1d mov %i5, %o0
if ( !information )
2017db8: b8 92 20 00 orcc %o0, 0, %i4
2017dbc: 02 80 00 08 be 2017ddc <_Objects_Get_name_as_string+0x4c>
2017dc0: 92 10 00 1d mov %i5, %o1
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
2017dc4: 7f ff e0 1f call 200fe40 <_Objects_Get>
2017dc8: 94 07 bf f4 add %fp, -12, %o2
switch ( location ) {
2017dcc: c2 07 bf f4 ld [ %fp + -12 ], %g1
2017dd0: 80 a0 60 00 cmp %g1, 0
2017dd4: 22 80 00 05 be,a 2017de8 <_Objects_Get_name_as_string+0x58>
2017dd8: c2 0f 20 38 ldub [ %i4 + 0x38 ], %g1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
2017ddc: b4 10 20 00 clr %i2
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
2017de0: 81 c7 e0 08 ret
2017de4: 91 e8 00 1a restore %g0, %i2, %o0
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
2017de8: 80 a0 60 00 cmp %g1, 0
2017dec: 12 80 00 2f bne 2017ea8 <_Objects_Get_name_as_string+0x118>
2017df0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
2017df4: 89 30 60 18 srl %g1, 0x18, %g4
lname[ 1 ] = (u32_name >> 16) & 0xff;
2017df8: 87 30 60 10 srl %g1, 0x10, %g3
lname[ 2 ] = (u32_name >> 8) & 0xff;
2017dfc: 85 30 60 08 srl %g1, 8, %g2
lname[ 3 ] = (u32_name >> 0) & 0xff;
2017e00: c2 2f bf fb stb %g1, [ %fp + -5 ]
lname[ 4 ] = '\0';
2017e04: c0 2f bf fc clrb [ %fp + -4 ]
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
2017e08: c8 2f bf f8 stb %g4, [ %fp + -8 ]
lname[ 1 ] = (u32_name >> 16) & 0xff;
2017e0c: c6 2f bf f9 stb %g3, [ %fp + -7 ]
lname[ 2 ] = (u32_name >> 8) & 0xff;
2017e10: c4 2f bf fa stb %g2, [ %fp + -6 ]
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
s = lname;
2017e14: 82 07 bf f8 add %fp, -8, %g1
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
2017e18: 80 a6 60 01 cmp %i1, 1
2017e1c: 02 80 00 27 be 2017eb8 <_Objects_Get_name_as_string+0x128><== NEVER TAKEN
2017e20: 86 10 00 1a mov %i2, %g3
2017e24: c6 48 40 00 ldsb [ %g1 ], %g3
2017e28: 80 a0 e0 00 cmp %g3, 0
2017e2c: 02 80 00 22 be 2017eb4 <_Objects_Get_name_as_string+0x124>
2017e30: c4 08 40 00 ldub [ %g1 ], %g2
* This method objects the name of an object and returns its name
* in the form of a C string. It attempts to be careful about
* overflowing the user's string and about returning unprintable characters.
*/
char *_Objects_Get_name_as_string(
2017e34: b6 06 7f ff add %i1, -1, %i3
2017e38: 39 00 80 c1 sethi %hi(0x2030400), %i4
2017e3c: b6 00 40 1b add %g1, %i3, %i3
2017e40: 86 10 00 1a mov %i2, %g3
2017e44: 10 80 00 06 b 2017e5c <_Objects_Get_name_as_string+0xcc>
2017e48: b8 17 21 c0 or %i4, 0x1c0, %i4
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
2017e4c: c8 48 40 00 ldsb [ %g1 ], %g4
2017e50: 80 a1 20 00 cmp %g4, 0
2017e54: 02 80 00 0e be 2017e8c <_Objects_Get_name_as_string+0xfc>
2017e58: c4 08 40 00 ldub [ %g1 ], %g2
*d = (isprint((unsigned char)*s)) ? *s : '*';
2017e5c: fa 07 00 00 ld [ %i4 ], %i5
2017e60: 88 08 a0 ff and %g2, 0xff, %g4
2017e64: 88 07 40 04 add %i5, %g4, %g4
2017e68: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
2017e6c: 80 89 20 97 btst 0x97, %g4
2017e70: 12 80 00 03 bne 2017e7c <_Objects_Get_name_as_string+0xec>
2017e74: 82 00 60 01 inc %g1
2017e78: 84 10 20 2a mov 0x2a, %g2
2017e7c: c4 28 c0 00 stb %g2, [ %g3 ]
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
2017e80: 80 a0 40 1b cmp %g1, %i3
2017e84: 12 bf ff f2 bne 2017e4c <_Objects_Get_name_as_string+0xbc>
2017e88: 86 00 e0 01 inc %g3
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
_Thread_Enable_dispatch();
2017e8c: 7f ff e4 30 call 2010f4c <_Thread_Enable_dispatch>
2017e90: c0 28 c0 00 clrb [ %g3 ]
return name;
}
return NULL; /* unreachable path */
}
2017e94: 81 c7 e0 08 ret
2017e98: 91 e8 00 1a restore %g0, %i2, %o0
return NULL;
if ( name == NULL )
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
2017e9c: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1
2017ea0: 10 bf ff c4 b 2017db0 <_Objects_Get_name_as_string+0x20>
2017ea4: fa 00 60 08 ld [ %g1 + 8 ], %i5
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
2017ea8: 80 a0 60 00 cmp %g1, 0
2017eac: 12 bf ff dc bne 2017e1c <_Objects_Get_name_as_string+0x8c>
2017eb0: 80 a6 60 01 cmp %i1, 1
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
2017eb4: 86 10 00 1a mov %i2, %g3
}
}
*d = '\0';
_Thread_Enable_dispatch();
2017eb8: 7f ff e4 25 call 2010f4c <_Thread_Enable_dispatch>
2017ebc: c0 28 c0 00 clrb [ %g3 ]
2017ec0: 30 bf ff f5 b,a 2017e94 <_Objects_Get_name_as_string+0x104>
0201aac4 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
201aac4: 9d e3 bf a0 save %sp, -96, %sp
Objects_Control *object;
Objects_Id next_id;
if ( !information )
201aac8: 80 a6 20 00 cmp %i0, 0
201aacc: 02 80 00 29 be 201ab70 <_Objects_Get_next+0xac>
201aad0: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( !location_p )
201aad4: 02 80 00 27 be 201ab70 <_Objects_Get_next+0xac>
201aad8: 80 a6 e0 00 cmp %i3, 0
return NULL;
if ( !next_id_p )
201aadc: 02 80 00 25 be 201ab70 <_Objects_Get_next+0xac>
201aae0: 83 2e 60 10 sll %i1, 0x10, %g1
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
201aae4: 80 a0 60 00 cmp %g1, 0
201aae8: 22 80 00 13 be,a 201ab34 <_Objects_Get_next+0x70>
201aaec: f2 06 20 08 ld [ %i0 + 8 ], %i1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
201aaf0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
201aaf4: 83 2e 60 10 sll %i1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
201aaf8: 92 10 00 19 mov %i1, %o1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
201aafc: 83 30 60 10 srl %g1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
201ab00: 90 10 00 18 mov %i0, %o0
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
201ab04: 80 a0 80 01 cmp %g2, %g1
201ab08: 0a 80 00 13 bcs 201ab54 <_Objects_Get_next+0x90>
201ab0c: 94 10 00 1a mov %i2, %o2
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
201ab10: 7f ff d4 cc call 200fe40 <_Objects_Get>
201ab14: b2 06 60 01 inc %i1
next_id++;
} while (*location_p != OBJECTS_LOCAL);
201ab18: c2 06 80 00 ld [ %i2 ], %g1
201ab1c: 80 a0 60 00 cmp %g1, 0
201ab20: 32 bf ff f5 bne,a 201aaf4 <_Objects_Get_next+0x30>
201ab24: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
*next_id_p = next_id;
201ab28: f2 26 c0 00 st %i1, [ %i3 ]
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
201ab2c: 81 c7 e0 08 ret
201ab30: 91 e8 00 08 restore %g0, %o0, %o0
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
201ab34: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
201ab38: 83 2e 60 10 sll %i1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
201ab3c: 92 10 00 19 mov %i1, %o1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
201ab40: 83 30 60 10 srl %g1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
201ab44: 90 10 00 18 mov %i0, %o0
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
201ab48: 80 a0 80 01 cmp %g2, %g1
201ab4c: 1a bf ff f1 bcc 201ab10 <_Objects_Get_next+0x4c> <== ALWAYS TAKEN
201ab50: 94 10 00 1a mov %i2, %o2
{
*location_p = OBJECTS_ERROR;
201ab54: 82 10 20 01 mov 1, %g1
201ab58: c2 26 80 00 st %g1, [ %i2 ]
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
201ab5c: 90 10 20 00 clr %o0
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
201ab60: 82 10 3f ff mov -1, %g1
201ab64: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
201ab68: 81 c7 e0 08 ret
201ab6c: 91 e8 00 08 restore %g0, %o0, %o0
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
201ab70: 10 bf ff ef b 201ab2c <_Objects_Get_next+0x68>
201ab74: 90 10 20 00 clr %o0
0201ac10 <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
201ac10: c4 02 20 08 ld [ %o0 + 8 ], %g2
if ( information->maximum >= index ) {
201ac14: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
201ac18: 92 22 40 02 sub %o1, %g2, %o1
201ac1c: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
201ac20: 80 a2 40 01 cmp %o1, %g1
201ac24: 18 80 00 09 bgu 201ac48 <_Objects_Get_no_protection+0x38>
201ac28: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
201ac2c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
201ac30: d0 00 40 09 ld [ %g1 + %o1 ], %o0
201ac34: 80 a2 20 00 cmp %o0, 0
201ac38: 02 80 00 05 be 201ac4c <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
201ac3c: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
201ac40: 81 c3 e0 08 retl
201ac44: c0 22 80 00 clr [ %o2 ]
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
201ac48: 82 10 20 01 mov 1, %g1
return NULL;
201ac4c: 90 10 20 00 clr %o0
}
201ac50: 81 c3 e0 08 retl
201ac54: c2 22 80 00 st %g1, [ %o2 ]
0200feb4 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
200feb4: 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;
200feb8: 80 a6 20 00 cmp %i0, 0
200febc: 12 80 00 06 bne 200fed4 <_Objects_Id_to_name+0x20>
200fec0: 83 36 20 18 srl %i0, 0x18, %g1
200fec4: 03 00 80 c6 sethi %hi(0x2031800), %g1
200fec8: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2031bb0 <_Per_CPU_Information+0x10>
200fecc: f0 00 60 08 ld [ %g1 + 8 ], %i0
200fed0: 83 36 20 18 srl %i0, 0x18, %g1
200fed4: 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 )
200fed8: 84 00 7f ff add %g1, -1, %g2
200fedc: 80 a0 a0 02 cmp %g2, 2
200fee0: 18 80 00 11 bgu 200ff24 <_Objects_Id_to_name+0x70>
200fee4: 83 28 60 02 sll %g1, 2, %g1
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
200fee8: 05 00 80 c5 sethi %hi(0x2031400), %g2
200feec: 84 10 a1 a4 or %g2, 0x1a4, %g2 ! 20315a4 <_Objects_Information_table>
200fef0: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200fef4: 80 a0 60 00 cmp %g1, 0
200fef8: 02 80 00 0b be 200ff24 <_Objects_Id_to_name+0x70>
200fefc: 85 36 20 1b srl %i0, 0x1b, %g2
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
200ff00: 85 28 a0 02 sll %g2, 2, %g2
200ff04: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
200ff08: 80 a2 20 00 cmp %o0, 0
200ff0c: 02 80 00 06 be 200ff24 <_Objects_Id_to_name+0x70> <== NEVER TAKEN
200ff10: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
200ff14: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
200ff18: 80 a0 60 00 cmp %g1, 0
200ff1c: 02 80 00 04 be 200ff2c <_Objects_Id_to_name+0x78> <== ALWAYS TAKEN
200ff20: 92 10 00 18 mov %i0, %o1
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
200ff24: 81 c7 e0 08 ret
200ff28: 91 e8 20 03 restore %g0, 3, %o0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
200ff2c: 7f ff ff c5 call 200fe40 <_Objects_Get>
200ff30: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
200ff34: 80 a2 20 00 cmp %o0, 0
200ff38: 02 bf ff fb be 200ff24 <_Objects_Id_to_name+0x70>
200ff3c: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
200ff40: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
200ff44: b0 10 20 00 clr %i0
the_object = _Objects_Get( information, tmpId, &ignored_location );
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
200ff48: 40 00 04 01 call 2010f4c <_Thread_Enable_dispatch>
200ff4c: c2 26 40 00 st %g1, [ %i1 ]
200ff50: 81 c7 e0 08 ret
200ff54: 81 e8 00 00 restore
02009938 <_Objects_Shrink_information>:
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
2009938: 9d e3 bf a0 save %sp, -96, %sp
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
200993c: f8 16 20 0a lduh [ %i0 + 0xa ], %i4
block_count = (information->maximum - index_base) /
2009940: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3
2009944: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0
2009948: 92 10 00 1b mov %i3, %o1
200994c: 40 00 3e 20 call 20191cc <.udiv>
2009950: 90 22 00 1c sub %o0, %i4, %o0
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
2009954: 80 a2 20 00 cmp %o0, 0
2009958: 02 80 00 36 be 2009a30 <_Objects_Shrink_information+0xf8> <== NEVER TAKEN
200995c: 01 00 00 00 nop
if ( information->inactive_per_block[ block ] ==
2009960: c8 06 20 30 ld [ %i0 + 0x30 ], %g4
2009964: c2 01 00 00 ld [ %g4 ], %g1
2009968: 80 a6 c0 01 cmp %i3, %g1
200996c: 02 80 00 0f be 20099a8 <_Objects_Shrink_information+0x70> <== NEVER TAKEN
2009970: 82 10 20 00 clr %g1
2009974: 10 80 00 07 b 2009990 <_Objects_Shrink_information+0x58>
2009978: ba 10 20 04 mov 4, %i5
200997c: c4 01 00 1d ld [ %g4 + %i5 ], %g2
2009980: 80 a6 c0 02 cmp %i3, %g2
2009984: 02 80 00 0a be 20099ac <_Objects_Shrink_information+0x74>
2009988: 86 07 60 04 add %i5, 4, %g3
200998c: ba 10 00 03 mov %g3, %i5
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
2009990: 82 00 60 01 inc %g1
2009994: 80 a0 40 08 cmp %g1, %o0
2009998: 12 bf ff f9 bne 200997c <_Objects_Shrink_information+0x44>
200999c: b8 07 00 1b add %i4, %i3, %i4
20099a0: 81 c7 e0 08 ret
20099a4: 81 e8 00 00 restore
if ( information->inactive_per_block[ block ] ==
20099a8: ba 10 20 00 clr %i5 <== NOT EXECUTED
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
20099ac: 35 00 00 3f sethi %hi(0xfc00), %i2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20099b0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
20099b4: 10 80 00 05 b 20099c8 <_Objects_Shrink_information+0x90>
20099b8: b4 16 a3 ff or %i2, 0x3ff, %i2
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
20099bc: 90 96 e0 00 orcc %i3, 0, %o0
20099c0: 22 80 00 12 be,a 2009a08 <_Objects_Shrink_information+0xd0>
20099c4: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
20099c8: c2 02 20 08 ld [ %o0 + 8 ], %g1
20099cc: 82 08 40 1a and %g1, %i2, %g1
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
20099d0: 80 a0 40 1c cmp %g1, %i4
20099d4: 0a bf ff fa bcs 20099bc <_Objects_Shrink_information+0x84>
20099d8: f6 02 00 00 ld [ %o0 ], %i3
(index < (index_base + information->allocation_size))) {
20099dc: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
20099e0: 84 07 00 02 add %i4, %g2, %g2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
20099e4: 80 a0 40 02 cmp %g1, %g2
20099e8: 3a bf ff f6 bcc,a 20099c0 <_Objects_Shrink_information+0x88>
20099ec: 90 96 e0 00 orcc %i3, 0, %o0
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
20099f0: 40 00 10 c5 call 200dd04 <_Chain_Extract>
20099f4: 01 00 00 00 nop
}
}
while ( the_object );
20099f8: 90 96 e0 00 orcc %i3, 0, %o0
20099fc: 32 bf ff f4 bne,a 20099cc <_Objects_Shrink_information+0x94><== ALWAYS TAKEN
2009a00: c2 02 20 08 ld [ %o0 + 8 ], %g1
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
2009a04: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
2009a08: 40 00 07 cb call 200b934 <_Workspace_Free>
2009a0c: d0 00 40 1d ld [ %g1 + %i5 ], %o0
information->object_blocks[ block ] = NULL;
2009a10: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
2009a14: c4 16 20 2c lduh [ %i0 + 0x2c ], %g2
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
2009a18: c0 20 40 1d clr [ %g1 + %i5 ]
information->inactive_per_block[ block ] = 0;
2009a1c: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive -= information->allocation_size;
2009a20: c2 16 20 14 lduh [ %i0 + 0x14 ], %g1
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
2009a24: c0 20 c0 1d clr [ %g3 + %i5 ]
information->inactive -= information->allocation_size;
2009a28: 82 20 80 01 sub %g2, %g1, %g1
2009a2c: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
return;
2009a30: 81 c7 e0 08 ret
2009a34: 81 e8 00 00 restore
0200fb78 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
200fb78: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
200fb7c: c2 06 20 08 ld [ %i0 + 8 ], %g1
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
200fb80: 35 00 00 3f sethi %hi(0xfc00), %i2
200fb84: b3 30 60 18 srl %g1, 0x18, %i1
200fb88: b4 16 a3 ff or %i2, 0x3ff, %i2
200fb8c: b2 0e 60 07 and %i1, 7, %i1
200fb90: b4 08 40 1a and %g1, %i2, %i2
200fb94: b2 06 60 04 add %i1, 4, %i1
200fb98: 3b 00 80 79 sethi %hi(0x201e400), %i5
200fb9c: b5 2e a0 02 sll %i2, 2, %i2
200fba0: ba 17 63 0c or %i5, 0x30c, %i5
200fba4: b3 2e 60 02 sll %i1, 2, %i1
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200fba8: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
200fbac: 80 a0 60 00 cmp %g1, 0
200fbb0: 02 80 00 21 be 200fc34 <_POSIX_Keys_Run_destructors+0xbc>
200fbb4: b8 10 20 01 mov 1, %i4
200fbb8: 86 10 20 01 mov 1, %g3
200fbbc: b6 10 00 01 mov %g1, %i3
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
200fbc0: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
_POSIX_Keys_Information.local_table [ index ];
200fbc4: 85 2f 20 10 sll %i4, 0x10, %g2
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
200fbc8: 85 30 a0 0e srl %g2, 0xe, %g2
200fbcc: c4 01 00 02 ld [ %g4 + %g2 ], %g2
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
200fbd0: 80 a0 a0 00 cmp %g2, 0
200fbd4: 02 80 00 10 be 200fc14 <_POSIX_Keys_Run_destructors+0x9c>
200fbd8: 82 00 80 19 add %g2, %i1, %g1
200fbdc: c8 00 a0 10 ld [ %g2 + 0x10 ], %g4
200fbe0: 80 a1 20 00 cmp %g4, 0
200fbe4: 22 80 00 0d be,a 200fc18 <_POSIX_Keys_Run_destructors+0xa0>
200fbe8: b8 07 20 01 inc %i4
void *value = key->Values [ thread_api ][ thread_index ];
200fbec: c8 00 60 04 ld [ %g1 + 4 ], %g4
200fbf0: d0 01 00 1a ld [ %g4 + %i2 ], %o0
if ( value != NULL ) {
200fbf4: 80 a2 20 00 cmp %o0, 0
200fbf8: 22 80 00 08 be,a 200fc18 <_POSIX_Keys_Run_destructors+0xa0><== ALWAYS TAKEN
200fbfc: b8 07 20 01 inc %i4
key->Values [ thread_api ][ thread_index ] = NULL;
200fc00: c0 21 00 1a clr [ %g4 + %i2 ] <== NOT EXECUTED
(*key->destructor)( value );
200fc04: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED
200fc08: 9f c0 40 00 call %g1 <== NOT EXECUTED
200fc0c: 01 00 00 00 nop <== NOT EXECUTED
done = false;
200fc10: 86 10 20 00 clr %g3 ! 0 <PROM_START> <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200fc14: b8 07 20 01 inc %i4
200fc18: 85 2f 20 10 sll %i4, 0x10, %g2
200fc1c: 85 30 a0 10 srl %g2, 0x10, %g2
200fc20: 80 a6 c0 02 cmp %i3, %g2
200fc24: 1a bf ff e7 bcc 200fbc0 <_POSIX_Keys_Run_destructors+0x48>
200fc28: 80 88 e0 ff btst 0xff, %g3
* 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 ) {
200fc2c: 22 bf ff e0 be,a 200fbac <_POSIX_Keys_Run_destructors+0x34><== NEVER TAKEN
200fc30: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
200fc34: 81 c7 e0 08 ret
200fc38: 81 e8 00 00 restore
0200ccec <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
200ccec: 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(
200ccf0: 11 00 80 ad sethi %hi(0x202b400), %o0
200ccf4: 92 10 00 18 mov %i0, %o1
200ccf8: 90 12 22 a0 or %o0, 0x2a0, %o0
200ccfc: 40 00 0d 9f call 2010378 <_Objects_Get>
200cd00: 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 ) {
200cd04: c2 07 bf f8 ld [ %fp + -8 ], %g1
200cd08: 80 a0 60 00 cmp %g1, 0
200cd0c: 22 80 00 08 be,a 200cd2c <_POSIX_Message_queue_Receive_support+0x40>
200cd10: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
200cd14: 40 00 2a d5 call 2017868 <__errno>
200cd18: b0 10 3f ff mov -1, %i0
200cd1c: 82 10 20 09 mov 9, %g1
200cd20: c2 22 00 00 st %g1, [ %o0 ]
}
200cd24: 81 c7 e0 08 ret
200cd28: 81 e8 00 00 restore
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
200cd2c: 84 08 60 03 and %g1, 3, %g2
200cd30: 80 a0 a0 01 cmp %g2, 1
200cd34: 02 80 00 39 be 200ce18 <_POSIX_Message_queue_Receive_support+0x12c>
200cd38: 01 00 00 00 nop
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
200cd3c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
200cd40: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200cd44: 80 a0 80 1a cmp %g2, %i2
200cd48: 18 80 00 23 bgu 200cdd4 <_POSIX_Message_queue_Receive_support+0xe8>
200cd4c: 84 10 3f ff mov -1, %g2
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
200cd50: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
200cd54: 80 a7 20 00 cmp %i4, 0
200cd58: 12 80 00 1b bne 200cdc4 <_POSIX_Message_queue_Receive_support+0xd8>
200cd5c: 98 10 20 00 clr %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
200cd60: 9a 10 00 1d mov %i5, %o5
200cd64: 90 02 20 1c add %o0, 0x1c, %o0
200cd68: 92 10 00 18 mov %i0, %o1
200cd6c: 94 10 00 19 mov %i1, %o2
200cd70: 96 07 bf fc add %fp, -4, %o3
200cd74: 40 00 09 04 call 200f184 <_CORE_message_queue_Seize>
200cd78: 98 0b 20 01 and %o4, 1, %o4
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
200cd7c: 40 00 11 91 call 20113c0 <_Thread_Enable_dispatch>
200cd80: 3b 00 80 ad sethi %hi(0x202b400), %i5
if (msg_prio) {
200cd84: 80 a6 e0 00 cmp %i3, 0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
200cd88: ba 17 63 20 or %i5, 0x320, %i5
do_wait,
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
200cd8c: 02 80 00 07 be 200cda8 <_POSIX_Message_queue_Receive_support+0xbc><== NEVER TAKEN
200cd90: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
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);
200cd94: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
200cd98: 85 38 e0 1f sra %g3, 0x1f, %g2
200cd9c: 86 18 80 03 xor %g2, %g3, %g3
200cda0: 84 20 c0 02 sub %g3, %g2, %g2
*msg_prio = _POSIX_Message_queue_Priority_from_core(
200cda4: c4 26 c0 00 st %g2, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
200cda8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
200cdac: 80 a0 60 00 cmp %g1, 0
200cdb0: 12 80 00 11 bne 200cdf4 <_POSIX_Message_queue_Receive_support+0x108>
200cdb4: 01 00 00 00 nop
return length_out;
200cdb8: f0 07 bf fc ld [ %fp + -4 ], %i0
200cdbc: 81 c7 e0 08 ret
200cdc0: 81 e8 00 00 restore
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
200cdc4: 99 30 60 0e srl %g1, 0xe, %o4
200cdc8: 98 1b 20 01 xor %o4, 1, %o4
200cdcc: 10 bf ff e5 b 200cd60 <_POSIX_Message_queue_Receive_support+0x74>
200cdd0: 98 0b 20 01 and %o4, 1, %o4
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
200cdd4: 40 00 11 7b call 20113c0 <_Thread_Enable_dispatch>
200cdd8: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EMSGSIZE );
200cddc: 40 00 2a a3 call 2017868 <__errno>
200cde0: 01 00 00 00 nop
200cde4: 82 10 20 7a mov 0x7a, %g1 ! 7a <PROM_START+0x7a>
200cde8: c2 22 00 00 st %g1, [ %o0 ]
200cdec: 81 c7 e0 08 ret
200cdf0: 81 e8 00 00 restore
}
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
200cdf4: 40 00 2a 9d call 2017868 <__errno>
200cdf8: b0 10 3f ff mov -1, %i0
200cdfc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200ce00: b8 10 00 08 mov %o0, %i4
200ce04: 40 00 00 a2 call 200d08c <_POSIX_Message_queue_Translate_core_message_queue_return_code>
200ce08: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
200ce0c: d0 27 00 00 st %o0, [ %i4 ]
200ce10: 81 c7 e0 08 ret
200ce14: 81 e8 00 00 restore
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
200ce18: 40 00 11 6a call 20113c0 <_Thread_Enable_dispatch>
200ce1c: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EBADF );
200ce20: 40 00 2a 92 call 2017868 <__errno>
200ce24: 01 00 00 00 nop
200ce28: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
200ce2c: c2 22 00 00 st %g1, [ %o0 ]
200ce30: 81 c7 e0 08 ret
200ce34: 81 e8 00 00 restore
0200f71c <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
200f71c: 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)
200f720: 80 a6 a0 00 cmp %i2, 0
200f724: 12 80 00 2f bne 200f7e0 <_POSIX_Semaphore_Create_support+0xc4>
200f728: 03 00 80 8b sethi %hi(0x2022c00), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200f72c: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 2022dd0 <_Thread_Dispatch_disable_level>
++level;
200f730: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
200f734: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
200f738: 35 00 80 8c sethi %hi(0x2023000), %i2
200f73c: 7f ff ed b2 call 200ae04 <_Objects_Allocate>
200f740: 90 16 a0 a4 or %i2, 0xa4, %o0 ! 20230a4 <_POSIX_Semaphore_Information>
rtems_set_errno_and_return_minus_one( ENOSYS );
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
200f744: ba 92 20 00 orcc %o0, 0, %i5
200f748: 02 80 00 2c be 200f7f8 <_POSIX_Semaphore_Create_support+0xdc>
200f74c: 80 a6 20 00 cmp %i0, 0
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
200f750: 02 80 00 1e be 200f7c8 <_POSIX_Semaphore_Create_support+0xac>
200f754: 92 10 00 19 mov %i1, %o1
name = _Workspace_String_duplicate( name_arg, name_len );
200f758: 40 00 04 92 call 20109a0 <_Workspace_String_duplicate>
200f75c: 90 10 00 18 mov %i0, %o0
if ( !name ) {
200f760: b2 92 20 00 orcc %o0, 0, %i1
200f764: 02 80 00 2d be 200f818 <_POSIX_Semaphore_Create_support+0xfc><== NEVER TAKEN
200f768: 82 10 20 01 mov 1, %g1
}
the_semaphore->process_shared = pshared;
if ( name ) {
the_semaphore->named = true;
200f76c: 84 10 20 01 mov 1, %g2
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
200f770: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( name ) {
the_semaphore->named = true;
200f774: c4 2f 60 14 stb %g2, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
200f778: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
200f77c: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
200f780: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200f784: 90 07 60 1c add %i5, 0x1c, %o0
200f788: 92 07 60 5c add %i5, 0x5c, %o1
200f78c: 94 10 00 1b mov %i3, %o2
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
200f790: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200f794: 7f ff eb f9 call 200a778 <_CORE_semaphore_Initialize>
200f798: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
200f79c: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200f7a0: b4 16 a0 a4 or %i2, 0xa4, %i2
200f7a4: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
200f7a8: 83 28 60 02 sll %g1, 2, %g1
200f7ac: 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;
200f7b0: f2 27 60 0c st %i1, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
200f7b4: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
200f7b8: 7f ff f3 16 call 200c410 <_Thread_Enable_dispatch>
200f7bc: b0 10 20 00 clr %i0
return 0;
200f7c0: 81 c7 e0 08 ret
200f7c4: 81 e8 00 00 restore
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
200f7c8: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
200f7cc: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
200f7d0: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
200f7d4: c0 2f 60 15 clrb [ %i5 + 0x15 ]
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
} else {
name = NULL;
200f7d8: 10 bf ff ea b 200f780 <_POSIX_Semaphore_Create_support+0x64>
200f7dc: b2 10 20 00 clr %i1
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
rtems_set_errno_and_return_minus_one( ENOSYS );
200f7e0: 40 00 0a c5 call 20122f4 <__errno>
200f7e4: b0 10 3f ff mov -1, %i0
200f7e8: 82 10 20 58 mov 0x58, %g1
200f7ec: c2 22 00 00 st %g1, [ %o0 ]
200f7f0: 81 c7 e0 08 ret
200f7f4: 81 e8 00 00 restore
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
200f7f8: 7f ff f3 06 call 200c410 <_Thread_Enable_dispatch>
200f7fc: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( ENOSPC );
200f800: 40 00 0a bd call 20122f4 <__errno>
200f804: 01 00 00 00 nop
200f808: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
200f80c: c2 22 00 00 st %g1, [ %o0 ]
200f810: 81 c7 e0 08 ret
200f814: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
200f818: 90 16 a0 a4 or %i2, 0xa4, %o0 <== NOT EXECUTED
200f81c: 7f ff ee 72 call 200b1e4 <_Objects_Free> <== NOT EXECUTED
200f820: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
*/
if ( name_arg != NULL ) {
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
200f824: 7f ff f2 fb call 200c410 <_Thread_Enable_dispatch> <== NOT EXECUTED
200f828: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
200f82c: 40 00 0a b2 call 20122f4 <__errno> <== NOT EXECUTED
200f830: 01 00 00 00 nop <== NOT EXECUTED
200f834: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
200f838: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200f83c: 81 c7 e0 08 ret <== NOT EXECUTED
200f840: 81 e8 00 00 restore <== NOT EXECUTED
0200d1c8 <_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 ];
200d1c8: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
200d1cc: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
200d1d0: 80 a0 a0 00 cmp %g2, 0
200d1d4: 12 80 00 06 bne 200d1ec <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24><== NEVER TAKEN
200d1d8: 01 00 00 00 nop
200d1dc: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
200d1e0: 80 a0 a0 01 cmp %g2, 1
200d1e4: 22 80 00 05 be,a 200d1f8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x30>
200d1e8: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
200d1ec: 82 13 c0 00 mov %o7, %g1
200d1f0: 7f ff f5 ad call 200a8a4 <_Thread_Enable_dispatch>
200d1f4: 9e 10 40 00 mov %g1, %o7
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
200d1f8: 80 a0 60 00 cmp %g1, 0
200d1fc: 02 bf ff fc be 200d1ec <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24>
200d200: 01 00 00 00 nop
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200d204: 03 00 80 7a sethi %hi(0x201e800), %g1
200d208: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 201e850 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
200d20c: 92 10 3f ff mov -1, %o1
--level;
200d210: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
200d214: c4 20 60 50 st %g2, [ %g1 + 0x50 ]
200d218: 82 13 c0 00 mov %o7, %g1
200d21c: 40 00 01 d9 call 200d980 <_POSIX_Thread_Exit>
200d220: 9e 10 40 00 mov %g1, %o7
0200e6c4 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
200e6c4: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
200e6c8: 7f ff ff f2 call 200e690 <_POSIX_Priority_Is_valid>
200e6cc: d0 06 40 00 ld [ %i1 ], %o0
200e6d0: 80 8a 20 ff btst 0xff, %o0
200e6d4: 32 80 00 04 bne,a 200e6e4 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
200e6d8: c0 26 80 00 clr [ %i2 ]
return EINVAL;
200e6dc: 81 c7 e0 08 ret
200e6e0: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
200e6e4: 80 a6 20 00 cmp %i0, 0
200e6e8: 02 80 00 2c be 200e798 <_POSIX_Thread_Translate_sched_param+0xd4>
200e6ec: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
200e6f0: 80 a6 20 01 cmp %i0, 1
200e6f4: 02 80 00 2d be 200e7a8 <_POSIX_Thread_Translate_sched_param+0xe4>
200e6f8: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
200e6fc: 02 80 00 2d be 200e7b0 <_POSIX_Thread_Translate_sched_param+0xec>
200e700: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
200e704: 12 bf ff f6 bne 200e6dc <_POSIX_Thread_Translate_sched_param+0x18>
200e708: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
200e70c: c2 06 60 08 ld [ %i1 + 8 ], %g1
200e710: 80 a0 60 00 cmp %g1, 0
200e714: 32 80 00 07 bne,a 200e730 <_POSIX_Thread_Translate_sched_param+0x6c>
200e718: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e71c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
200e720: 80 a0 60 00 cmp %g1, 0
200e724: 02 bf ff ee be 200e6dc <_POSIX_Thread_Translate_sched_param+0x18>
200e728: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
200e72c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e730: 80 a0 60 00 cmp %g1, 0
200e734: 12 80 00 06 bne 200e74c <_POSIX_Thread_Translate_sched_param+0x88>
200e738: 01 00 00 00 nop
200e73c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200e740: 80 a0 60 00 cmp %g1, 0
200e744: 02 bf ff e6 be 200e6dc <_POSIX_Thread_Translate_sched_param+0x18>
200e748: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
200e74c: 7f ff f6 cc call 200c27c <_Timespec_To_ticks>
200e750: 90 06 60 08 add %i1, 8, %o0
200e754: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
200e758: 7f ff f6 c9 call 200c27c <_Timespec_To_ticks>
200e75c: 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 ) <
200e760: 80 a7 40 08 cmp %i5, %o0
200e764: 0a bf ff de bcs 200e6dc <_POSIX_Thread_Translate_sched_param+0x18>
200e768: 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 ) )
200e76c: 7f ff ff c9 call 200e690 <_POSIX_Priority_Is_valid>
200e770: d0 06 60 04 ld [ %i1 + 4 ], %o0
200e774: 80 8a 20 ff btst 0xff, %o0
200e778: 02 bf ff d9 be 200e6dc <_POSIX_Thread_Translate_sched_param+0x18>
200e77c: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
200e780: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
200e784: 03 00 80 20 sethi %hi(0x2008000), %g1
200e788: 82 10 61 70 or %g1, 0x170, %g1 ! 2008170 <_POSIX_Threads_Sporadic_budget_callout>
200e78c: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
200e790: 81 c7 e0 08 ret
200e794: 91 e8 20 00 restore %g0, 0, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200e798: 82 10 20 01 mov 1, %g1
200e79c: c2 26 80 00 st %g1, [ %i2 ]
return 0;
200e7a0: 81 c7 e0 08 ret
200e7a4: 81 e8 00 00 restore
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
200e7a8: 81 c7 e0 08 ret
200e7ac: 91 e8 20 00 restore %g0, 0, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
200e7b0: f0 26 80 00 st %i0, [ %i2 ]
return 0;
200e7b4: 81 c7 e0 08 ret
200e7b8: 91 e8 20 00 restore %g0, 0, %o0
0200d508 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
200d508: 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 ];
200d50c: f0 06 61 5c ld [ %i1 + 0x15c ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
200d510: 40 00 09 7e call 200fb08 <_POSIX_Threads_cancel_run>
200d514: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
200d518: 90 10 00 19 mov %i1, %o0
200d51c: 40 00 09 97 call 200fb78 <_POSIX_Keys_Run_destructors>
200d520: 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 )) )
200d524: 10 80 00 03 b 200d530 <_POSIX_Threads_Delete_extension+0x28>
200d528: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
200d52c: 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 )) )
200d530: 7f ff f5 7c call 200ab20 <_Thread_queue_Dequeue>
200d534: 90 10 00 1d mov %i5, %o0
200d538: 80 a2 20 00 cmp %o0, 0
200d53c: 32 bf ff fc bne,a 200d52c <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
200d540: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
200d544: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
200d548: 80 a0 60 04 cmp %g1, 4
200d54c: 02 80 00 05 be 200d560 <_POSIX_Threads_Delete_extension+0x58>
200d550: 01 00 00 00 nop
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
200d554: c0 26 61 5c clr [ %i1 + 0x15c ]
_Workspace_Free( api );
200d558: 7f ff f8 f7 call 200b934 <_Workspace_Free>
200d55c: 81 e8 00 00 restore
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
200d560: 7f ff f8 37 call 200b63c <_Watchdog_Remove>
200d564: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
200d568: c0 26 61 5c clr [ %i1 + 0x15c ]
_Workspace_Free( api );
200d56c: 7f ff f8 f2 call 200b934 <_Workspace_Free>
200d570: 81 e8 00 00 restore
02007e84 <_POSIX_Threads_Initialize_user_threads_body>:
#include <rtems/posix/config.h>
#include <rtems/posix/key.h>
#include <rtems/posix/time.h>
void _POSIX_Threads_Initialize_user_threads_body(void)
{
2007e84: 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;
2007e88: 03 00 80 89 sethi %hi(0x2022400), %g1
2007e8c: 82 10 61 c4 or %g1, 0x1c4, %g1 ! 20225c4 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
2007e90: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
2007e94: 80 a6 e0 00 cmp %i3, 0
2007e98: 02 80 00 18 be 2007ef8 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
2007e9c: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
2007ea0: 80 a7 60 00 cmp %i5, 0
2007ea4: 02 80 00 15 be 2007ef8 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
2007ea8: 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 );
2007eac: 40 00 1a 44 call 200e7bc <pthread_attr_init>
2007eb0: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
2007eb4: 92 10 20 02 mov 2, %o1
2007eb8: 40 00 1a 4d call 200e7ec <pthread_attr_setinheritsched>
2007ebc: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
2007ec0: d2 07 60 04 ld [ %i5 + 4 ], %o1
2007ec4: 40 00 1a 5a call 200e82c <pthread_attr_setstacksize>
2007ec8: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
2007ecc: d4 07 40 00 ld [ %i5 ], %o2
2007ed0: 90 07 bf bc add %fp, -68, %o0
2007ed4: 92 07 bf c0 add %fp, -64, %o1
2007ed8: 7f ff ff 00 call 2007ad8 <pthread_create>
2007edc: 96 10 20 00 clr %o3
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
2007ee0: 94 92 20 00 orcc %o0, 0, %o2
2007ee4: 12 80 00 07 bne 2007f00 <_POSIX_Threads_Initialize_user_threads_body+0x7c>
2007ee8: b8 07 20 01 inc %i4
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
2007eec: 80 a7 00 1b cmp %i4, %i3
2007ef0: 12 bf ff ef bne 2007eac <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
2007ef4: ba 07 60 08 add %i5, 8, %i5
2007ef8: 81 c7 e0 08 ret
2007efc: 81 e8 00 00 restore
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
2007f00: 90 10 20 02 mov 2, %o0
2007f04: 40 00 08 8b call 200a130 <_Internal_error_Occurred>
2007f08: 92 10 20 01 mov 1, %o1
0200d694 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
200d694: 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 ];
200d698: 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 );
200d69c: 40 00 04 3d call 200e790 <_Timespec_To_ticks>
200d6a0: 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);
200d6a4: c4 07 60 88 ld [ %i5 + 0x88 ], %g2
200d6a8: 03 00 80 75 sethi %hi(0x201d400), %g1
200d6ac: d2 08 62 7c ldub [ %g1 + 0x27c ], %o1 ! 201d67c <rtems_maximum_priority>
*/
#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 ) {
200d6b0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
200d6b4: 92 22 40 02 sub %o1, %g2, %o1
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
200d6b8: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
*/
#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 ) {
200d6bc: 80 a0 60 00 cmp %g1, 0
200d6c0: 12 80 00 06 bne 200d6d8 <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NEVER TAKEN
200d6c4: 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 ) {
200d6c8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200d6cc: 80 a0 40 09 cmp %g1, %o1
200d6d0: 18 80 00 09 bgu 200d6f4 <_POSIX_Threads_Sporadic_budget_TSR+0x60>
200d6d4: 90 10 00 19 mov %i1, %o0
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
200d6d8: 90 07 60 90 add %i5, 0x90, %o0
200d6dc: 40 00 04 2d call 200e790 <_Timespec_To_ticks>
200d6e0: 31 00 80 78 sethi %hi(0x201e000), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200d6e4: b2 07 60 a8 add %i5, 0xa8, %i1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
200d6e8: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200d6ec: 7f ff f7 75 call 200b4c0 <_Watchdog_Insert>
200d6f0: 91 ee 23 bc restore %i0, 0x3bc, %o0
if ( the_thread->resource_count == 0 ) {
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
_Thread_Change_priority( the_thread, new_priority, true );
200d6f4: 7f ff f2 cf call 200a230 <_Thread_Change_priority>
200d6f8: 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 );
200d6fc: 90 07 60 90 add %i5, 0x90, %o0
200d700: 40 00 04 24 call 200e790 <_Timespec_To_ticks>
200d704: 31 00 80 78 sethi %hi(0x201e000), %i0
200d708: b2 07 60 a8 add %i5, 0xa8, %i1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
200d70c: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200d710: 7f ff f7 6c call 200b4c0 <_Watchdog_Insert>
200d714: 91 ee 23 bc restore %i0, 0x3bc, %o0
0200d718 <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200d718: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
200d71c: c6 00 a0 8c ld [ %g2 + 0x8c ], %g3
200d720: 05 00 80 75 sethi %hi(0x201d400), %g2
200d724: d2 08 a2 7c ldub [ %g2 + 0x27c ], %o1 ! 201d67c <rtems_maximum_priority>
*/
#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 ) {
200d728: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
200d72c: 92 22 40 03 sub %o1, %g3, %o1
/*
* 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 */
200d730: 86 10 3f ff mov -1, %g3
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
200d734: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
*/
#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 ) {
200d738: 80 a0 a0 00 cmp %g2, 0
200d73c: 12 80 00 06 bne 200d754 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NEVER TAKEN
200d740: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
/*
* 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 ) {
200d744: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200d748: 80 a0 40 09 cmp %g1, %o1
200d74c: 0a 80 00 04 bcs 200d75c <_POSIX_Threads_Sporadic_budget_callout+0x44><== ALWAYS TAKEN
200d750: 94 10 20 01 mov 1, %o2
200d754: 81 c3 e0 08 retl <== NOT EXECUTED
200d758: 01 00 00 00 nop <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
200d75c: 82 13 c0 00 mov %o7, %g1
200d760: 7f ff f2 b4 call 200a230 <_Thread_Change_priority>
200d764: 9e 10 40 00 mov %g1, %o7
0200fb08 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
200fb08: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
200fb0c: f8 06 21 5c ld [ %i0 + 0x15c ], %i4
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
200fb10: 84 10 20 01 mov 1, %g2
while ( !_Chain_Is_empty( handler_stack ) ) {
200fb14: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200fb18: b6 07 20 e8 add %i4, 0xe8, %i3
200fb1c: 80 a0 40 1b cmp %g1, %i3
200fb20: 02 80 00 14 be 200fb70 <_POSIX_Threads_cancel_run+0x68>
200fb24: c4 27 20 d8 st %g2, [ %i4 + 0xd8 ]
_ISR_Disable( level );
200fb28: 7f ff ca b9 call 200260c <sparc_disable_interrupts>
200fb2c: 01 00 00 00 nop
handler = (POSIX_Cancel_Handler_control *)
200fb30: fa 07 20 ec ld [ %i4 + 0xec ], %i5
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200fb34: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
200fb38: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
200fb3c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200fb40: c4 20 40 00 st %g2, [ %g1 ]
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
200fb44: 7f ff ca b6 call 200261c <sparc_enable_interrupts>
200fb48: 01 00 00 00 nop
(*handler->routine)( handler->arg );
200fb4c: c2 07 60 08 ld [ %i5 + 8 ], %g1
200fb50: 9f c0 40 00 call %g1
200fb54: d0 07 60 0c ld [ %i5 + 0xc ], %o0
_Workspace_Free( handler );
200fb58: 7f ff ef 77 call 200b934 <_Workspace_Free>
200fb5c: 90 10 00 1d mov %i5, %o0
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
200fb60: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
200fb64: 80 a0 40 1b cmp %g1, %i3
200fb68: 12 bf ff f0 bne 200fb28 <_POSIX_Threads_cancel_run+0x20> <== NEVER TAKEN
200fb6c: 01 00 00 00 nop
200fb70: 81 c7 e0 08 ret
200fb74: 81 e8 00 00 restore
02007920 <_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)
{
2007920: 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;
2007924: c4 06 60 68 ld [ %i1 + 0x68 ], %g2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
2007928: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
200792c: 84 00 a0 01 inc %g2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
2007930: 80 a0 60 00 cmp %g1, 0
2007934: 12 80 00 0e bne 200796c <_POSIX_Timer_TSR+0x4c>
2007938: c4 26 60 68 st %g2, [ %i1 + 0x68 ]
200793c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
2007940: 80 a0 60 00 cmp %g1, 0
2007944: 32 80 00 0b bne,a 2007970 <_POSIX_Timer_TSR+0x50> <== ALWAYS TAKEN
2007948: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
200794c: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
2007950: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
2007954: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
2007958: 40 00 18 b2 call 200dc20 <pthread_kill>
200795c: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
2007960: c0 26 60 68 clr [ %i1 + 0x68 ]
2007964: 81 c7 e0 08 ret
2007968: 81 e8 00 00 restore
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
200796c: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
2007970: d4 06 60 08 ld [ %i1 + 8 ], %o2
2007974: 90 06 60 10 add %i1, 0x10, %o0
2007978: 98 10 00 19 mov %i1, %o4
200797c: 17 00 80 1e sethi %hi(0x2007800), %o3
2007980: 40 00 19 cf call 200e0bc <_POSIX_Timer_Insert_helper>
2007984: 96 12 e1 20 or %o3, 0x120, %o3 ! 2007920 <_POSIX_Timer_TSR>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
2007988: 80 8a 20 ff btst 0xff, %o0
200798c: 02 bf ff f6 be 2007964 <_POSIX_Timer_TSR+0x44> <== NEVER TAKEN
2007990: 90 07 bf f8 add %fp, -8, %o0
2007994: 13 00 80 7b sethi %hi(0x201ec00), %o1
2007998: 40 00 06 3b call 2009284 <_TOD_Get_with_nanoseconds>
200799c: 92 12 61 98 or %o1, 0x198, %o1 ! 201ed98 <_TOD>
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
20079a0: f8 1a 00 00 ldd [ %o0 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
20079a4: 94 10 20 00 clr %o2
20079a8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20079ac: 90 10 00 1c mov %i4, %o0
20079b0: 96 12 e2 00 or %o3, 0x200, %o3
20079b4: 40 00 4a 95 call 201a408 <__divdi3>
20079b8: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20079bc: 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);
20079c0: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20079c4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20079c8: 90 10 00 1c mov %i4, %o0
20079cc: 96 12 e2 00 or %o3, 0x200, %o3
20079d0: 40 00 4b 79 call 201a7b4 <__moddi3>
20079d4: 92 10 00 1d mov %i5, %o1
/* 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;
20079d8: 82 10 20 03 mov 3, %g1
20079dc: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
20079e0: 10 bf ff dd b 2007954 <_POSIX_Timer_TSR+0x34>
20079e4: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
0200fc3c <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
200fc3c: 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,
200fc40: 98 10 20 01 mov 1, %o4
200fc44: 90 10 00 18 mov %i0, %o0
200fc48: 92 10 00 19 mov %i1, %o1
200fc4c: 94 07 bf cc add %fp, -52, %o2
200fc50: 40 00 00 2e call 200fd08 <_POSIX_signals_Clear_signals>
200fc54: 96 10 00 1a mov %i2, %o3
200fc58: 80 8a 20 ff btst 0xff, %o0
200fc5c: 02 80 00 23 be 200fce8 <_POSIX_signals_Check_signal+0xac>
200fc60: 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 )
200fc64: 85 2e 60 02 sll %i1, 2, %g2
200fc68: 37 00 80 7a sethi %hi(0x201e800), %i3
200fc6c: b9 2e 60 04 sll %i1, 4, %i4
200fc70: b6 16 e0 a0 or %i3, 0xa0, %i3
200fc74: b8 27 00 02 sub %i4, %g2, %i4
200fc78: 84 06 c0 1c add %i3, %i4, %g2
200fc7c: fa 00 a0 08 ld [ %g2 + 8 ], %i5
200fc80: 80 a7 60 01 cmp %i5, 1
200fc84: 02 80 00 19 be 200fce8 <_POSIX_signals_Check_signal+0xac> <== NEVER TAKEN
200fc88: 21 00 80 7a sethi %hi(0x201e800), %l0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
200fc8c: f4 06 20 d0 ld [ %i0 + 0xd0 ], %i2
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
200fc90: c2 00 a0 04 ld [ %g2 + 4 ], %g1
/*
* 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,
200fc94: a0 14 20 40 or %l0, 0x40, %l0
200fc98: d2 04 20 10 ld [ %l0 + 0x10 ], %o1
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
200fc9c: 82 10 40 1a or %g1, %i2, %g1
/*
* 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,
200fca0: 90 07 bf d8 add %fp, -40, %o0
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
200fca4: 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,
200fca8: 92 02 60 20 add %o1, 0x20, %o1
200fcac: 40 00 04 1c call 2010d1c <memcpy>
200fcb0: 94 10 20 28 mov 0x28, %o2
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
200fcb4: c2 06 c0 1c ld [ %i3 + %i4 ], %g1
200fcb8: 80 a0 60 02 cmp %g1, 2
200fcbc: 02 80 00 0e be 200fcf4 <_POSIX_signals_Check_signal+0xb8>
200fcc0: 90 10 00 19 mov %i1, %o0
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
200fcc4: 9f c7 40 00 call %i5
200fcc8: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
200fccc: d0 04 20 10 ld [ %l0 + 0x10 ], %o0
200fcd0: 92 07 bf d8 add %fp, -40, %o1
200fcd4: 90 02 20 20 add %o0, 0x20, %o0
200fcd8: 40 00 04 11 call 2010d1c <memcpy>
200fcdc: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
200fce0: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
200fce4: f4 26 20 d0 st %i2, [ %i0 + 0xd0 ]
return true;
}
200fce8: b0 08 60 01 and %g1, 1, %i0
200fcec: 81 c7 e0 08 ret
200fcf0: 81 e8 00 00 restore
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
200fcf4: 92 07 bf cc add %fp, -52, %o1
200fcf8: 9f c7 40 00 call %i5
200fcfc: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
200fd00: 10 bf ff f4 b 200fcd0 <_POSIX_signals_Check_signal+0x94>
200fd04: d0 04 20 10 ld [ %l0 + 0x10 ], %o0
02010330 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
2010330: 9d e3 bf a0 save %sp, -96, %sp
2010334: 84 10 20 01 mov 1, %g2
2010338: 82 06 3f ff add %i0, -1, %g1
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
201033c: 7f ff c8 b4 call 200260c <sparc_disable_interrupts>
2010340: bb 28 80 01 sll %g2, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
2010344: 05 00 80 7a sethi %hi(0x201e800), %g2
2010348: 83 2e 20 02 sll %i0, 2, %g1
201034c: 84 10 a0 a0 or %g2, 0xa0, %g2
2010350: b1 2e 20 04 sll %i0, 4, %i0
2010354: 82 26 00 01 sub %i0, %g1, %g1
2010358: c4 00 80 01 ld [ %g2 + %g1 ], %g2
201035c: 80 a0 a0 02 cmp %g2, 2
2010360: 02 80 00 08 be 2010380 <_POSIX_signals_Clear_process_signals+0x50>
2010364: 31 00 80 7a sethi %hi(0x201e800), %i0
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
2010368: 03 00 80 7a sethi %hi(0x201e800), %g1
201036c: c4 00 62 94 ld [ %g1 + 0x294 ], %g2 ! 201ea94 <_POSIX_signals_Pending>
2010370: ba 28 80 1d andn %g2, %i5, %i5
2010374: fa 20 62 94 st %i5, [ %g1 + 0x294 ]
}
_ISR_Enable( level );
2010378: 7f ff c8 a9 call 200261c <sparc_enable_interrupts>
201037c: 91 e8 00 08 restore %g0, %o0, %o0
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
2010380: b0 16 22 98 or %i0, 0x298, %i0
2010384: c4 00 40 18 ld [ %g1 + %i0 ], %g2
2010388: b0 00 40 18 add %g1, %i0, %i0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
201038c: b0 06 20 04 add %i0, 4, %i0
2010390: 80 a0 80 18 cmp %g2, %i0
2010394: 02 bf ff f6 be 201036c <_POSIX_signals_Clear_process_signals+0x3c><== ALWAYS TAKEN
2010398: 03 00 80 7a sethi %hi(0x201e800), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
201039c: 7f ff c8 a0 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
20103a0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02008784 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
2008784: 82 10 20 1b mov 0x1b, %g1
2008788: 86 10 20 01 mov 1, %g3
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
200878c: 84 00 7f ff add %g1, -1, %g2
2008790: 85 28 c0 02 sll %g3, %g2, %g2
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
2008794: 80 88 80 08 btst %g2, %o0
2008798: 12 80 00 11 bne 20087dc <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
200879c: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
20087a0: 82 00 60 01 inc %g1
20087a4: 80 a0 60 20 cmp %g1, 0x20
20087a8: 12 bf ff fa bne 2008790 <_POSIX_signals_Get_lowest+0xc>
20087ac: 84 00 7f ff add %g1, -1, %g2
20087b0: 82 10 20 01 mov 1, %g1
20087b4: 10 80 00 05 b 20087c8 <_POSIX_signals_Get_lowest+0x44>
20087b8: 86 10 20 01 mov 1, %g3
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
20087bc: 80 a0 60 1b cmp %g1, 0x1b
20087c0: 02 80 00 07 be 20087dc <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
20087c4: 01 00 00 00 nop
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
20087c8: 84 00 7f ff add %g1, -1, %g2
20087cc: 85 28 c0 02 sll %g3, %g2, %g2
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
20087d0: 80 88 80 08 btst %g2, %o0
20087d4: 22 bf ff fa be,a 20087bc <_POSIX_signals_Get_lowest+0x38>
20087d8: 82 00 60 01 inc %g1
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
20087dc: 81 c3 e0 08 retl
20087e0: 90 10 00 01 mov %g1, %o0
0200d248 <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
200d248: 9d e3 bf a0 save %sp, -96, %sp
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
200d24c: 35 00 80 7a sethi %hi(0x201e800), %i2
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200d250: f8 06 21 5c ld [ %i0 + 0x15c ], %i4
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
200d254: b4 16 a0 40 or %i2, 0x40, %i2
200d258: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
200d25c: 80 a7 20 00 cmp %i4, 0
200d260: 02 80 00 34 be 200d330 <_POSIX_signals_Post_switch_hook+0xe8><== NEVER TAKEN
200d264: f2 00 60 34 ld [ %g1 + 0x34 ], %i1
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
200d268: 7f ff d4 e9 call 200260c <sparc_disable_interrupts>
200d26c: 37 00 80 7a sethi %hi(0x201e800), %i3
200d270: b6 16 e2 94 or %i3, 0x294, %i3 ! 201ea94 <_POSIX_signals_Pending>
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
200d274: c6 06 c0 00 ld [ %i3 ], %g3
200d278: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
200d27c: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
(api->signals_pending | _POSIX_signals_Pending)) ) {
200d280: 82 10 c0 01 or %g3, %g1, %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
200d284: 80 a8 40 02 andncc %g1, %g2, %g0
200d288: 02 80 00 26 be 200d320 <_POSIX_signals_Post_switch_hook+0xd8>
200d28c: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
200d290: 7f ff d4 e3 call 200261c <sparc_enable_interrupts>
200d294: ba 10 20 1b mov 0x1b, %i5 ! 1b <PROM_START+0x1b>
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
200d298: 92 10 00 1d mov %i5, %o1
200d29c: 94 10 20 00 clr %o2
200d2a0: 40 00 0a 67 call 200fc3c <_POSIX_signals_Check_signal>
200d2a4: 90 10 00 1c mov %i4, %o0
_POSIX_signals_Check_signal( api, signo, true );
200d2a8: 92 10 00 1d mov %i5, %o1
200d2ac: 90 10 00 1c mov %i4, %o0
200d2b0: 40 00 0a 63 call 200fc3c <_POSIX_signals_Check_signal>
200d2b4: 94 10 20 01 mov 1, %o2
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
200d2b8: ba 07 60 01 inc %i5
200d2bc: 80 a7 60 20 cmp %i5, 0x20
200d2c0: 12 bf ff f7 bne 200d29c <_POSIX_signals_Post_switch_hook+0x54>
200d2c4: 92 10 00 1d mov %i5, %o1
200d2c8: ba 10 20 01 mov 1, %i5
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
200d2cc: 92 10 00 1d mov %i5, %o1
200d2d0: 94 10 20 00 clr %o2
200d2d4: 40 00 0a 5a call 200fc3c <_POSIX_signals_Check_signal>
200d2d8: 90 10 00 1c mov %i4, %o0
_POSIX_signals_Check_signal( api, signo, true );
200d2dc: 92 10 00 1d mov %i5, %o1
200d2e0: 90 10 00 1c mov %i4, %o0
200d2e4: 40 00 0a 56 call 200fc3c <_POSIX_signals_Check_signal>
200d2e8: 94 10 20 01 mov 1, %o2
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
200d2ec: ba 07 60 01 inc %i5
200d2f0: 80 a7 60 1b cmp %i5, 0x1b
200d2f4: 12 bf ff f7 bne 200d2d0 <_POSIX_signals_Post_switch_hook+0x88>
200d2f8: 92 10 00 1d mov %i5, %o1
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
200d2fc: 7f ff d4 c4 call 200260c <sparc_disable_interrupts>
200d300: 01 00 00 00 nop
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
200d304: c6 06 c0 00 ld [ %i3 ], %g3
200d308: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
200d30c: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
(api->signals_pending | _POSIX_signals_Pending)) ) {
200d310: 82 10 c0 01 or %g3, %g1, %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
200d314: 80 a8 40 02 andncc %g1, %g2, %g0
200d318: 12 bf ff de bne 200d290 <_POSIX_signals_Post_switch_hook+0x48><== NEVER TAKEN
200d31c: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
200d320: 7f ff d4 bf call 200261c <sparc_enable_interrupts>
200d324: 01 00 00 00 nop
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
200d328: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
200d32c: f2 20 60 34 st %i1, [ %g1 + 0x34 ]
200d330: 81 c7 e0 08 ret
200d334: 81 e8 00 00 restore
0201afd4 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
201afd4: 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 ) ) {
201afd8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201afdc: 05 04 00 20 sethi %hi(0x10008000), %g2
201afe0: 88 10 20 01 mov 1, %g4
201afe4: 86 06 7f ff add %i1, -1, %g3
201afe8: ba 08 40 02 and %g1, %g2, %i5
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
201afec: f8 06 21 5c ld [ %i0 + 0x15c ], %i4
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
201aff0: 80 a7 40 02 cmp %i5, %g2
201aff4: 02 80 00 2c be 201b0a4 <_POSIX_signals_Unblock_thread+0xd0>
201aff8: 87 29 00 03 sll %g4, %g3, %g3
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
201affc: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
201b000: 80 a8 c0 02 andncc %g3, %g2, %g0
201b004: 02 80 00 24 be 201b094 <_POSIX_signals_Unblock_thread+0xc0>
201b008: 05 04 00 00 sethi %hi(0x10000000), %g2
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
201b00c: 80 88 40 02 btst %g1, %g2
201b010: 02 80 00 15 be 201b064 <_POSIX_signals_Unblock_thread+0x90>
201b014: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
201b018: 84 10 20 04 mov 4, %g2
201b01c: c4 26 20 34 st %g2, [ %i0 + 0x34 ]
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
201b020: 05 00 00 ef sethi %hi(0x3bc00), %g2
201b024: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
/*
* 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) )
201b028: 80 88 40 02 btst %g1, %g2
201b02c: 12 80 00 38 bne 201b10c <_POSIX_signals_Unblock_thread+0x138>
201b030: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
201b034: 22 80 00 19 be,a 201b098 <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
201b038: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
201b03c: 7f ff c1 80 call 200b63c <_Watchdog_Remove>
201b040: 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 );
201b044: 90 10 00 18 mov %i0, %o0
201b048: 13 04 01 ff sethi %hi(0x1007fc00), %o1
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
201b04c: b0 10 20 00 clr %i0
201b050: 7f ff bc c5 call 200a364 <_Thread_Clear_state>
201b054: 92 12 63 f8 or %o1, 0x3f8, %o1
201b058: b0 0e 20 01 and %i0, 1, %i0
201b05c: 81 c7 e0 08 ret
201b060: 81 e8 00 00 restore
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
201b064: 32 80 00 0d bne,a 201b098 <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
201b068: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201b06c: 03 00 80 7a sethi %hi(0x201e800), %g1
201b070: 82 10 60 40 or %g1, 0x40, %g1 ! 201e840 <_Per_CPU_Information>
201b074: c4 00 60 08 ld [ %g1 + 8 ], %g2
201b078: 80 a0 a0 00 cmp %g2, 0
201b07c: 22 80 00 07 be,a 201b098 <_POSIX_signals_Unblock_thread+0xc4>
201b080: b0 10 20 00 clr %i0
201b084: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
201b088: 80 a6 00 02 cmp %i0, %g2
201b08c: 22 80 00 02 be,a 201b094 <_POSIX_signals_Unblock_thread+0xc0><== ALWAYS TAKEN
201b090: c8 28 60 0c stb %g4, [ %g1 + 0xc ]
_Thread_Dispatch_necessary = true;
}
}
return false;
201b094: b0 10 20 00 clr %i0
}
201b098: b0 0e 20 01 and %i0, 1, %i0
201b09c: 81 c7 e0 08 ret
201b0a0: 81 e8 00 00 restore
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
201b0a4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
201b0a8: 80 88 c0 01 btst %g3, %g1
201b0ac: 22 80 00 13 be,a 201b0f8 <_POSIX_signals_Unblock_thread+0x124>
201b0b0: c2 07 20 d0 ld [ %i4 + 0xd0 ], %g1
the_thread->Wait.return_code = EINTR;
201b0b4: 82 10 20 04 mov 4, %g1
201b0b8: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
201b0bc: 80 a6 a0 00 cmp %i2, 0
201b0c0: 02 80 00 19 be 201b124 <_POSIX_signals_Unblock_thread+0x150>
201b0c4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
201b0c8: c4 06 80 00 ld [ %i2 ], %g2
201b0cc: c4 20 40 00 st %g2, [ %g1 ]
201b0d0: c4 06 a0 04 ld [ %i2 + 4 ], %g2
201b0d4: c4 20 60 04 st %g2, [ %g1 + 4 ]
201b0d8: c4 06 a0 08 ld [ %i2 + 8 ], %g2
201b0dc: c4 20 60 08 st %g2, [ %g1 + 8 ]
}
_Thread_queue_Extract_with_proxy( the_thread );
201b0e0: 90 10 00 18 mov %i0, %o0
201b0e4: 7f ff bf 9f call 200af60 <_Thread_queue_Extract_with_proxy>
201b0e8: b0 10 20 01 mov 1, %i0
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
201b0ec: b0 0e 20 01 and %i0, 1, %i0
201b0f0: 81 c7 e0 08 ret
201b0f4: 81 e8 00 00 restore
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
201b0f8: 80 a8 c0 01 andncc %g3, %g1, %g0
201b0fc: 32 bf ff ef bne,a 201b0b8 <_POSIX_signals_Unblock_thread+0xe4>
201b100: 82 10 20 04 mov 4, %g1
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
201b104: 10 bf ff e5 b 201b098 <_POSIX_signals_Unblock_thread+0xc4>
201b108: b0 10 20 00 clr %i0
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
201b10c: 90 10 00 18 mov %i0, %o0
201b110: 7f ff bf 94 call 200af60 <_Thread_queue_Extract_with_proxy>
201b114: b0 10 20 00 clr %i0
201b118: b0 0e 20 01 and %i0, 1, %i0
201b11c: 81 c7 e0 08 ret
201b120: 81 e8 00 00 restore
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
201b124: 84 10 20 01 mov 1, %g2
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
201b128: f2 20 40 00 st %i1, [ %g1 ]
the_info->si_code = SI_USER;
201b12c: c4 20 60 04 st %g2, [ %g1 + 4 ]
the_info->si_value.sival_int = 0;
201b130: 10 bf ff ec b 201b0e0 <_POSIX_signals_Unblock_thread+0x10c>
201b134: c0 20 60 08 clr [ %g1 + 8 ]
0200a97c <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a97c: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
200a980: 80 a6 60 00 cmp %i1, 0
200a984: 02 80 00 4c be 200aab4 <_RBTree_Extract_unprotected+0x138>
200a988: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
200a98c: c2 06 20 08 ld [ %i0 + 8 ], %g1
200a990: 80 a0 40 19 cmp %g1, %i1
200a994: 02 80 00 56 be 200aaec <_RBTree_Extract_unprotected+0x170>
200a998: 90 10 00 19 mov %i1, %o0
the_rbtree->first[RBT_LEFT] = next;
}
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
200a99c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
200a9a0: 80 a0 40 19 cmp %g1, %i1
200a9a4: 02 80 00 56 be 200aafc <_RBTree_Extract_unprotected+0x180>
200a9a8: 90 10 00 19 mov %i1, %o0
* 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]) {
200a9ac: fa 06 60 04 ld [ %i1 + 4 ], %i5
200a9b0: 80 a7 60 00 cmp %i5, 0
200a9b4: 22 80 00 5a be,a 200ab1c <_RBTree_Extract_unprotected+0x1a0>
200a9b8: f8 06 60 08 ld [ %i1 + 8 ], %i4
200a9bc: c2 06 60 08 ld [ %i1 + 8 ], %g1
200a9c0: 80 a0 60 00 cmp %g1, 0
200a9c4: 32 80 00 05 bne,a 200a9d8 <_RBTree_Extract_unprotected+0x5c>
200a9c8: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a9cc: 10 80 00 3c b 200aabc <_RBTree_Extract_unprotected+0x140>
200a9d0: b8 10 00 1d mov %i5, %i4
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
200a9d4: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a9d8: 80 a0 60 00 cmp %g1, 0
200a9dc: 32 bf ff fe bne,a 200a9d4 <_RBTree_Extract_unprotected+0x58>
200a9e0: 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];
200a9e4: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
200a9e8: 80 a7 20 00 cmp %i4, 0
200a9ec: 02 80 00 48 be 200ab0c <_RBTree_Extract_unprotected+0x190>
200a9f0: 01 00 00 00 nop
leaf->parent = target->parent;
200a9f4: c2 07 40 00 ld [ %i5 ], %g1
200a9f8: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
200a9fc: c4 07 40 00 ld [ %i5 ], %g2
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
200aa00: c2 06 40 00 ld [ %i1 ], %g1
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
200aa04: c8 00 a0 04 ld [ %g2 + 4 ], %g4
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;
200aa08: c6 07 60 0c ld [ %i5 + 0xc ], %g3
dir = target != target->parent->child[0];
200aa0c: 88 1f 40 04 xor %i5, %g4, %g4
200aa10: 80 a0 00 04 cmp %g0, %g4
200aa14: 88 40 20 00 addx %g0, 0, %g4
target->parent->child[dir] = leaf;
200aa18: 89 29 20 02 sll %g4, 2, %g4
200aa1c: 84 00 80 04 add %g2, %g4, %g2
200aa20: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
200aa24: c4 00 60 04 ld [ %g1 + 4 ], %g2
200aa28: 84 18 80 19 xor %g2, %i1, %g2
200aa2c: 80 a0 00 02 cmp %g0, %g2
200aa30: 84 40 20 00 addx %g0, 0, %g2
the_node->parent->child[dir] = target;
200aa34: 85 28 a0 02 sll %g2, 2, %g2
200aa38: 82 00 40 02 add %g1, %g2, %g1
200aa3c: fa 20 60 04 st %i5, [ %g1 + 4 ]
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
200aa40: c2 06 60 08 ld [ %i1 + 8 ], %g1
200aa44: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
200aa48: c2 06 60 08 ld [ %i1 + 8 ], %g1
200aa4c: 80 a0 60 00 cmp %g1, 0
200aa50: 32 80 00 02 bne,a 200aa58 <_RBTree_Extract_unprotected+0xdc><== ALWAYS TAKEN
200aa54: fa 20 40 00 st %i5, [ %g1 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
200aa58: c2 06 60 04 ld [ %i1 + 4 ], %g1
200aa5c: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
200aa60: c2 06 60 04 ld [ %i1 + 4 ], %g1
200aa64: 80 a0 60 00 cmp %g1, 0
200aa68: 32 80 00 02 bne,a 200aa70 <_RBTree_Extract_unprotected+0xf4>
200aa6c: fa 20 40 00 st %i5, [ %g1 ]
/* 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;
200aa70: c4 06 40 00 ld [ %i1 ], %g2
target->color = the_node->color;
200aa74: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* 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;
200aa78: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
200aa7c: c2 27 60 0c st %g1, [ %i5 + 0xc ]
/* 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 */
200aa80: 80 a0 e0 00 cmp %g3, 0
200aa84: 32 80 00 06 bne,a 200aa9c <_RBTree_Extract_unprotected+0x120>
200aa88: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
200aa8c: 80 a7 20 00 cmp %i4, 0
200aa90: 32 80 00 02 bne,a 200aa98 <_RBTree_Extract_unprotected+0x11c>
200aa94: 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;
200aa98: 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;
200aa9c: c0 26 60 08 clr [ %i1 + 8 ]
200aaa0: c0 26 60 04 clr [ %i1 + 4 ]
200aaa4: 80 a0 60 00 cmp %g1, 0
200aaa8: 02 80 00 03 be 200aab4 <_RBTree_Extract_unprotected+0x138>
200aaac: c0 26 40 00 clr [ %i1 ]
200aab0: c0 20 60 0c clr [ %g1 + 0xc ]
200aab4: 81 c7 e0 08 ret
200aab8: 81 e8 00 00 restore
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
leaf->parent = the_node->parent;
200aabc: c2 06 40 00 ld [ %i1 ], %g1
200aac0: c2 27 00 00 st %g1, [ %i4 ]
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
200aac4: c2 06 40 00 ld [ %i1 ], %g1
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;
200aac8: c6 06 60 0c ld [ %i1 + 0xc ], %g3
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
200aacc: c4 00 60 04 ld [ %g1 + 4 ], %g2
200aad0: 84 18 80 19 xor %g2, %i1, %g2
200aad4: 80 a0 00 02 cmp %g0, %g2
200aad8: 84 40 20 00 addx %g0, 0, %g2
the_node->parent->child[dir] = leaf;
200aadc: 85 28 a0 02 sll %g2, 2, %g2
200aae0: 82 00 40 02 add %g1, %g2, %g1
200aae4: 10 bf ff e7 b 200aa80 <_RBTree_Extract_unprotected+0x104>
200aae8: f8 20 60 04 st %i4, [ %g1 + 4 ]
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_RIGHT );
200aaec: 40 00 00 eb call 200ae98 <_RBTree_Next_unprotected>
200aaf0: 92 10 20 01 mov 1, %o1
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
200aaf4: 10 bf ff aa b 200a99c <_RBTree_Extract_unprotected+0x20>
200aaf8: d0 26 20 08 st %o0, [ %i0 + 8 ]
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_LEFT );
200aafc: 40 00 00 e7 call 200ae98 <_RBTree_Next_unprotected>
200ab00: 92 10 20 00 clr %o1
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
200ab04: 10 bf ff aa b 200a9ac <_RBTree_Extract_unprotected+0x30>
200ab08: d0 26 20 0c st %o0, [ %i0 + 0xc ]
leaf = target->child[RBT_LEFT];
if(leaf) {
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
200ab0c: 7f ff fe d3 call 200a658 <_RBTree_Extract_validate_unprotected>
200ab10: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
200ab14: 10 bf ff bb b 200aa00 <_RBTree_Extract_unprotected+0x84>
200ab18: c4 07 40 00 ld [ %i5 ], %g2
* 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 ) {
200ab1c: 80 a7 20 00 cmp %i4, 0
200ab20: 32 bf ff e8 bne,a 200aac0 <_RBTree_Extract_unprotected+0x144>
200ab24: c2 06 40 00 ld [ %i1 ], %g1
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
200ab28: 7f ff fe cc call 200a658 <_RBTree_Extract_validate_unprotected>
200ab2c: 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];
200ab30: 10 bf ff e6 b 200aac8 <_RBTree_Extract_unprotected+0x14c>
200ab34: c2 06 40 00 ld [ %i1 ], %g1
0200a658 <_RBTree_Extract_validate_unprotected>:
)
{
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
200a658: c2 02 00 00 ld [ %o0 ], %g1
if(!parent->parent) return;
200a65c: c4 00 40 00 ld [ %g1 ], %g2
200a660: 80 a0 a0 00 cmp %g2, 0
200a664: 02 80 00 3f be 200a760 <_RBTree_Extract_validate_unprotected+0x108>
200a668: 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 == the_node->parent->child[RBT_LEFT])
200a66c: c4 00 60 04 ld [ %g1 + 4 ], %g2
200a670: 80 a2 00 02 cmp %o0, %g2
200a674: 22 80 00 02 be,a 200a67c <_RBTree_Extract_validate_unprotected+0x24>
200a678: c4 00 60 08 ld [ %g1 + 8 ], %g2
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a67c: c6 02 20 0c ld [ %o0 + 0xc ], %g3
200a680: 80 a0 e0 01 cmp %g3, 1
200a684: 02 80 00 32 be 200a74c <_RBTree_Extract_validate_unprotected+0xf4>
200a688: 9a 10 20 01 mov 1, %o5
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) {
200a68c: c6 00 40 00 ld [ %g1 ], %g3
200a690: 80 a0 e0 00 cmp %g3, 0
200a694: 02 80 00 2e be 200a74c <_RBTree_Extract_validate_unprotected+0xf4>
200a698: 80 a0 a0 00 cmp %g2, 0
200a69c: 22 80 00 07 be,a 200a6b8 <_RBTree_Extract_validate_unprotected+0x60><== NEVER TAKEN
200a6a0: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED
200a6a4: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
200a6a8: 80 a1 20 01 cmp %g4, 1
200a6ac: 22 80 00 63 be,a 200a838 <_RBTree_Extract_validate_unprotected+0x1e0>
200a6b0: d8 00 60 04 ld [ %g1 + 4 ], %o4
_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]) &&
200a6b4: c6 00 a0 08 ld [ %g2 + 8 ], %g3
200a6b8: 80 a0 e0 00 cmp %g3, 0
200a6bc: 22 80 00 07 be,a 200a6d8 <_RBTree_Extract_validate_unprotected+0x80>
200a6c0: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a6c4: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
200a6c8: 80 a0 e0 01 cmp %g3, 1
200a6cc: 22 80 00 29 be,a 200a770 <_RBTree_Extract_validate_unprotected+0x118>
200a6d0: c6 00 60 04 ld [ %g1 + 4 ], %g3
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
200a6d4: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a6d8: 80 a0 e0 00 cmp %g3, 0
200a6dc: 22 80 00 07 be,a 200a6f8 <_RBTree_Extract_validate_unprotected+0xa0>
200a6e0: da 20 a0 0c st %o5, [ %g2 + 0xc ]
200a6e4: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
200a6e8: 80 a0 e0 01 cmp %g3, 1
200a6ec: 22 80 00 21 be,a 200a770 <_RBTree_Extract_validate_unprotected+0x118>
200a6f0: c6 00 60 04 ld [ %g1 + 4 ], %g3
sibling->color = RBT_RED;
200a6f4: da 20 a0 0c st %o5, [ %g2 + 0xc ]
200a6f8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200a6fc: 80 a0 a0 01 cmp %g2, 1
200a700: 22 80 00 99 be,a 200a964 <_RBTree_Extract_validate_unprotected+0x30c>
200a704: c0 20 60 0c clr [ %g1 + 0xc ]
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
200a708: c6 00 40 00 ld [ %g1 ], %g3
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
200a70c: 80 a0 e0 00 cmp %g3, 0
200a710: 02 80 00 6c be 200a8c0 <_RBTree_Extract_validate_unprotected+0x268><== NEVER TAKEN
200a714: 90 10 00 01 mov %g1, %o0
if(!(the_node->parent->parent)) return NULL;
200a718: c4 00 c0 00 ld [ %g3 ], %g2
200a71c: 80 a0 a0 00 cmp %g2, 0
200a720: 02 80 00 69 be 200a8c4 <_RBTree_Extract_validate_unprotected+0x26c>
200a724: 84 10 20 00 clr %g2
if(the_node == the_node->parent->child[RBT_LEFT])
200a728: c4 00 e0 04 ld [ %g3 + 4 ], %g2
200a72c: 80 a0 40 02 cmp %g1, %g2
200a730: 22 80 00 0e be,a 200a768 <_RBTree_Extract_validate_unprotected+0x110>
200a734: c4 00 e0 08 ld [ %g3 + 8 ], %g2
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
200a738: 82 10 00 03 mov %g3, %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a73c: c6 02 20 0c ld [ %o0 + 0xc ], %g3
200a740: 80 a0 e0 01 cmp %g3, 1
200a744: 32 bf ff d3 bne,a 200a690 <_RBTree_Extract_validate_unprotected+0x38><== ALWAYS TAKEN
200a748: c6 00 40 00 ld [ %g1 ], %g3
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;
200a74c: c2 02 00 00 ld [ %o0 ], %g1
200a750: c2 00 40 00 ld [ %g1 ], %g1
200a754: 80 a0 60 00 cmp %g1, 0
200a758: 02 80 00 5f be 200a8d4 <_RBTree_Extract_validate_unprotected+0x27c>
200a75c: 01 00 00 00 nop
200a760: 81 c3 e0 08 retl
200a764: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
200a768: 10 bf ff f5 b 200a73c <_RBTree_Extract_validate_unprotected+0xe4>
200a76c: 82 10 00 03 mov %g3, %g1
* 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];
200a770: 86 1a 00 03 xor %o0, %g3, %g3
200a774: 80 a0 00 03 cmp %g0, %g3
200a778: 9a 40 20 00 addx %g0, 0, %o5
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a77c: 86 1b 60 01 xor %o5, 1, %g3
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
200a780: 87 28 e0 02 sll %g3, 2, %g3
200a784: 88 00 80 03 add %g2, %g3, %g4
200a788: c8 01 20 04 ld [ %g4 + 4 ], %g4
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a78c: 80 a1 20 00 cmp %g4, 0
200a790: 22 80 00 07 be,a 200a7ac <_RBTree_Extract_validate_unprotected+0x154>
200a794: 9b 2b 60 02 sll %o5, 2, %o5
200a798: d8 01 20 0c ld [ %g4 + 0xc ], %o4
200a79c: 80 a3 20 01 cmp %o4, 1
200a7a0: 22 80 00 4f be,a 200a8dc <_RBTree_Extract_validate_unprotected+0x284>
200a7a4: d6 00 60 0c ld [ %g1 + 0xc ], %o3
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
200a7a8: 9b 2b 60 02 sll %o5, 2, %o5
200a7ac: 98 00 80 0d add %g2, %o5, %o4
200a7b0: c8 03 20 04 ld [ %o4 + 4 ], %g4
* 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)])) {
sibling->color = RBT_RED;
200a7b4: 96 10 20 01 mov 1, %o3
200a7b8: d6 20 a0 0c st %o3, [ %g2 + 0xc ]
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
200a7bc: 80 a1 20 00 cmp %g4, 0
200a7c0: 02 80 00 15 be 200a814 <_RBTree_Extract_validate_unprotected+0x1bc><== NEVER TAKEN
200a7c4: c0 21 20 0c clr [ %g4 + 0xc ]
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
200a7c8: 96 01 00 03 add %g4, %g3, %o3
200a7cc: d4 02 e0 04 ld [ %o3 + 4 ], %o2
200a7d0: d4 23 20 04 st %o2, [ %o4 + 4 ]
if (c->child[dir])
200a7d4: d8 02 e0 04 ld [ %o3 + 4 ], %o4
200a7d8: 80 a3 20 00 cmp %o4, 0
200a7dc: 32 80 00 02 bne,a 200a7e4 <_RBTree_Extract_validate_unprotected+0x18c>
200a7e0: c4 23 00 00 st %g2, [ %o4 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a7e4: d8 00 80 00 ld [ %g2 ], %o4
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
200a7e8: 96 01 00 03 add %g4, %g3, %o3
200a7ec: c4 22 e0 04 st %g2, [ %o3 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a7f0: d6 03 20 04 ld [ %o4 + 4 ], %o3
c->parent = the_node->parent;
200a7f4: d8 21 00 00 st %o4, [ %g4 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a7f8: 96 18 80 0b xor %g2, %o3, %o3
c->parent = the_node->parent;
the_node->parent = c;
200a7fc: c8 20 80 00 st %g4, [ %g2 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a800: 80 a0 00 0b cmp %g0, %o3
200a804: 84 40 20 00 addx %g0, 0, %g2
200a808: 85 28 a0 02 sll %g2, 2, %g2
200a80c: 98 03 00 02 add %o4, %g2, %o4
200a810: c8 23 20 04 st %g4, [ %o4 + 4 ]
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
200a814: c8 00 60 0c ld [ %g1 + 0xc ], %g4
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
200a818: 84 00 40 03 add %g1, %g3, %g2
200a81c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
}
sibling->color = parent->color;
200a820: c8 20 a0 0c st %g4, [ %g2 + 0xc ]
200a824: 88 00 80 03 add %g2, %g3, %g4
200a828: c8 01 20 04 ld [ %g4 + 4 ], %g4
parent->color = RBT_BLACK;
200a82c: c0 20 60 0c clr [ %g1 + 0xc ]
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
200a830: 10 80 00 33 b 200a8fc <_RBTree_Extract_validate_unprotected+0x2a4>
200a834: c0 21 20 0c clr [ %g4 + 0xc ]
* 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;
200a838: c8 20 60 0c st %g4, [ %g1 + 0xc ]
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
200a83c: 88 1b 00 08 xor %o4, %o0, %g4
200a840: 80 a0 00 04 cmp %g0, %g4
200a844: 94 40 20 00 addx %g0, 0, %o2
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a848: 96 1a a0 01 xor %o2, 1, %o3
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
200a84c: 97 2a e0 02 sll %o3, 2, %o3
200a850: 98 00 40 0b add %g1, %o3, %o4
200a854: c8 03 20 04 ld [ %o4 + 4 ], %g4
200a858: 80 a1 20 00 cmp %g4, 0
200a85c: 02 80 00 1c be 200a8cc <_RBTree_Extract_validate_unprotected+0x274><== NEVER TAKEN
200a860: c0 20 a0 0c clr [ %g2 + 0xc ]
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
200a864: 95 2a a0 02 sll %o2, 2, %o2
200a868: 84 01 00 0a add %g4, %o2, %g2
200a86c: d2 00 a0 04 ld [ %g2 + 4 ], %o1
200a870: d2 23 20 04 st %o1, [ %o4 + 4 ]
if (c->child[dir])
200a874: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200a878: 80 a0 a0 00 cmp %g2, 0
200a87c: 02 80 00 04 be 200a88c <_RBTree_Extract_validate_unprotected+0x234><== NEVER TAKEN
200a880: 94 01 00 0a add %g4, %o2, %o2
c->child[dir]->parent = the_node;
200a884: c2 20 80 00 st %g1, [ %g2 ]
200a888: c6 00 40 00 ld [ %g1 ], %g3
c->child[dir] = the_node;
200a88c: c2 22 a0 04 st %g1, [ %o2 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a890: c4 00 e0 04 ld [ %g3 + 4 ], %g2
c->parent = the_node->parent;
200a894: c6 21 00 00 st %g3, [ %g4 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a898: 84 18 40 02 xor %g1, %g2, %g2
200a89c: 80 a0 00 02 cmp %g0, %g2
200a8a0: 84 40 20 00 addx %g0, 0, %g2
200a8a4: 85 28 a0 02 sll %g2, 2, %g2
200a8a8: 96 00 40 0b add %g1, %o3, %o3
200a8ac: 86 00 c0 02 add %g3, %g2, %g3
c->parent = the_node->parent;
the_node->parent = c;
200a8b0: c8 20 40 00 st %g4, [ %g1 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a8b4: c8 20 e0 04 st %g4, [ %g3 + 4 ]
200a8b8: 10 bf ff 7f b 200a6b4 <_RBTree_Extract_validate_unprotected+0x5c>
200a8bc: c4 02 e0 04 ld [ %o3 + 4 ], %g2
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
200a8c0: 84 10 20 00 clr %g2 <== NOT EXECUTED
200a8c4: 10 bf ff 9e b 200a73c <_RBTree_Extract_validate_unprotected+0xe4>
200a8c8: 82 10 00 03 mov %g3, %g1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
200a8cc: 10 bf ff 7a b 200a6b4 <_RBTree_Extract_validate_unprotected+0x5c><== NOT EXECUTED
200a8d0: 84 10 20 00 clr %g2 <== NOT EXECUTED
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;
200a8d4: 81 c3 e0 08 retl
200a8d8: c0 22 20 0c clr [ %o0 + 0xc ]
200a8dc: 98 00 40 03 add %g1, %g3, %o4
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;
200a8e0: d6 20 a0 0c st %o3, [ %g2 + 0xc ]
parent->color = RBT_BLACK;
200a8e4: c0 20 60 0c clr [ %g1 + 0xc ]
200a8e8: c4 03 20 04 ld [ %o4 + 4 ], %g2
200a8ec: 80 a0 a0 00 cmp %g2, 0
200a8f0: 02 bf ff 97 be 200a74c <_RBTree_Extract_validate_unprotected+0xf4><== NEVER TAKEN
200a8f4: c0 21 20 0c clr [ %g4 + 0xc ]
200a8f8: 9b 2b 60 02 sll %o5, 2, %o5
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
200a8fc: 88 00 80 0d add %g2, %o5, %g4
200a900: d8 01 20 04 ld [ %g4 + 4 ], %o4
200a904: 86 00 40 03 add %g1, %g3, %g3
200a908: d8 20 e0 04 st %o4, [ %g3 + 4 ]
if (c->child[dir])
200a90c: c6 01 20 04 ld [ %g4 + 4 ], %g3
200a910: 80 a0 e0 00 cmp %g3, 0
200a914: 32 80 00 02 bne,a 200a91c <_RBTree_Extract_validate_unprotected+0x2c4>
200a918: c2 20 c0 00 st %g1, [ %g3 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a91c: c6 00 40 00 ld [ %g1 ], %g3
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
200a920: 9a 00 80 0d add %g2, %o5, %o5
200a924: c2 23 60 04 st %g1, [ %o5 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a928: c8 00 e0 04 ld [ %g3 + 4 ], %g4
c->parent = the_node->parent;
200a92c: c6 20 80 00 st %g3, [ %g2 ]
the_node->parent = c;
200a930: c4 20 40 00 st %g2, [ %g1 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a934: 88 18 40 04 xor %g1, %g4, %g4
200a938: 80 a0 00 04 cmp %g0, %g4
200a93c: 82 40 20 00 addx %g0, 0, %g1
200a940: 83 28 60 02 sll %g1, 2, %g1
200a944: 86 00 c0 01 add %g3, %g1, %g3
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;
200a948: c2 02 00 00 ld [ %o0 ], %g1
200a94c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
200a950: c2 00 40 00 ld [ %g1 ], %g1
200a954: 80 a0 60 00 cmp %g1, 0
200a958: 12 bf ff 82 bne 200a760 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
200a95c: 01 00 00 00 nop
200a960: 30 bf ff dd b,a 200a8d4 <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
200a964: c2 02 00 00 ld [ %o0 ], %g1
200a968: c2 00 40 00 ld [ %g1 ], %g1
200a96c: 80 a0 60 00 cmp %g1, 0
200a970: 12 bf ff 7c bne 200a760 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
200a974: 01 00 00 00 nop
200a978: 30 bf ff d7 b,a 200a8d4 <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
0200b570 <_RBTree_Find>:
RBTree_Node *_RBTree_Find(
RBTree_Control *the_rbtree,
RBTree_Node *search_node
)
{
200b570: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
RBTree_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
200b574: 7f ff e1 c8 call 2003c94 <sparc_disable_interrupts>
200b578: b8 10 00 18 mov %i0, %i4
200b57c: b6 10 00 08 mov %o0, %i3
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
200b580: fa 06 20 04 ld [ %i0 + 4 ], %i5
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
200b584: 80 a7 60 00 cmp %i5, 0
200b588: 02 80 00 15 be 200b5dc <_RBTree_Find+0x6c> <== NEVER TAKEN
200b58c: b0 10 20 00 clr %i0
compare_result = the_rbtree->compare_function(the_node, iter_node);
200b590: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
200b594: 92 10 00 1d mov %i5, %o1
200b598: 9f c0 40 00 call %g1
200b59c: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
200b5a0: 83 3a 20 1f sra %o0, 0x1f, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
200b5a4: 80 a2 20 00 cmp %o0, 0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
200b5a8: 82 20 40 08 sub %g1, %o0, %g1
200b5ac: 83 30 60 1f srl %g1, 0x1f, %g1
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
200b5b0: 83 28 60 02 sll %g1, 2, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
200b5b4: 12 80 00 06 bne 200b5cc <_RBTree_Find+0x5c>
200b5b8: 82 07 40 01 add %i5, %g1, %g1
found = iter_node;
if ( the_rbtree->is_unique )
200b5bc: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
200b5c0: 80 a0 a0 00 cmp %g2, 0
200b5c4: 12 80 00 0a bne 200b5ec <_RBTree_Find+0x7c>
200b5c8: b0 10 00 1d mov %i5, %i0
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
200b5cc: fa 00 60 04 ld [ %g1 + 4 ], %i5
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
200b5d0: 80 a7 60 00 cmp %i5, 0
200b5d4: 32 bf ff f0 bne,a 200b594 <_RBTree_Find+0x24>
200b5d8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
200b5dc: 7f ff e1 b2 call 2003ca4 <sparc_enable_interrupts>
200b5e0: 90 10 00 1b mov %i3, %o0
return return_node;
}
200b5e4: 81 c7 e0 08 ret
200b5e8: 81 e8 00 00 restore
RBTree_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
200b5ec: 7f ff e1 ae call 2003ca4 <sparc_enable_interrupts>
200b5f0: 90 10 00 1b mov %i3, %o0
return return_node;
}
200b5f4: 81 c7 e0 08 ret
200b5f8: 81 e8 00 00 restore
0200b9dc <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
200b9dc: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
200b9e0: 80 a6 20 00 cmp %i0, 0
200b9e4: 02 80 00 0f be 200ba20 <_RBTree_Initialize+0x44> <== NEVER TAKEN
200b9e8: 80 a6 e0 00 cmp %i3, 0
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
200b9ec: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
200b9f0: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
200b9f4: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
200b9f8: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
200b9fc: 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-- ) {
200ba00: 02 80 00 08 be 200ba20 <_RBTree_Initialize+0x44> <== NEVER TAKEN
200ba04: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
200ba08: 92 10 00 1a mov %i2, %o1
200ba0c: 7f ff ff 0b call 200b638 <_RBTree_Insert_unprotected>
200ba10: 90 10 00 18 mov %i0, %o0
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
200ba14: b6 86 ff ff addcc %i3, -1, %i3
200ba18: 12 bf ff fc bne 200ba08 <_RBTree_Initialize+0x2c>
200ba1c: b4 06 80 1c add %i2, %i4, %i2
200ba20: 81 c7 e0 08 ret
200ba24: 81 e8 00 00 restore
0200ab5c <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200ab5c: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
200ab60: 80 a6 60 00 cmp %i1, 0
200ab64: 02 80 00 9c be 200add4 <_RBTree_Insert_unprotected+0x278>
200ab68: b8 10 00 18 mov %i0, %i4
RBTree_Node *iter_node = the_rbtree->root;
200ab6c: fa 06 20 04 ld [ %i0 + 4 ], %i5
int compare_result;
if (!iter_node) { /* special case: first node inserted */
200ab70: 80 a7 60 00 cmp %i5, 0
200ab74: 32 80 00 05 bne,a 200ab88 <_RBTree_Insert_unprotected+0x2c>
200ab78: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
the_node->color = RBT_BLACK;
200ab7c: 10 80 00 9a b 200ade4 <_RBTree_Insert_unprotected+0x288>
200ab80: c0 26 60 0c clr [ %i1 + 0xc ]
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);
200ab84: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
200ab88: 92 10 00 1d mov %i5, %o1
200ab8c: 9f c0 40 00 call %g1
200ab90: 90 10 00 19 mov %i1, %o0
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200ab94: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
200ab98: b6 38 00 08 xnor %g0, %o0, %i3
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);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200ab9c: 80 a0 a0 00 cmp %g2, 0
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
200aba0: b7 36 e0 1f srl %i3, 0x1f, %i3
if (!iter_node->child[dir]) {
200aba4: 83 2e e0 02 sll %i3, 2, %g1
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);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200aba8: 02 80 00 05 be 200abbc <_RBTree_Insert_unprotected+0x60>
200abac: 82 07 40 01 add %i5, %g1, %g1
200abb0: 80 a2 20 00 cmp %o0, 0
200abb4: 02 80 00 8a be 200addc <_RBTree_Insert_unprotected+0x280>
200abb8: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
200abbc: f0 00 60 04 ld [ %g1 + 4 ], %i0
200abc0: 80 a6 20 00 cmp %i0, 0
200abc4: 32 bf ff f0 bne,a 200ab84 <_RBTree_Insert_unprotected+0x28>
200abc8: ba 10 00 18 mov %i0, %i5
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
the_node->color = RBT_RED;
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
/* update min/max */
compare_result = the_rbtree->compare_function(
200abcc: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
200abd0: b4 06 e0 02 add %i3, 2, %i2
200abd4: 87 2e a0 02 sll %i2, 2, %g3
200abd8: d2 07 00 03 ld [ %i4 + %g3 ], %o1
compare_result = the_rbtree->compare_function(the_node, iter_node);
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;
200abdc: c0 26 60 08 clr [ %i1 + 8 ]
200abe0: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
iter_node->child[dir] = the_node;
200abe4: f2 20 60 04 st %i1, [ %g1 + 4 ]
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
the_node->color = RBT_RED;
200abe8: 82 10 20 01 mov 1, %g1
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
200abec: fa 26 40 00 st %i5, [ %i1 ]
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;
200abf0: c2 26 60 0c st %g1, [ %i1 + 0xc ]
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
/* update min/max */
compare_result = the_rbtree->compare_function(
200abf4: 9f c0 80 00 call %g2
200abf8: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
200abfc: 80 a6 e0 00 cmp %i3, 0
200ac00: 12 80 00 10 bne 200ac40 <_RBTree_Insert_unprotected+0xe4>
200ac04: 80 a2 20 00 cmp %o0, 0
200ac08: 06 80 00 10 bl 200ac48 <_RBTree_Insert_unprotected+0xec>
200ac0c: b5 2e a0 02 sll %i2, 2, %i2
200ac10: c2 06 40 00 ld [ %i1 ], %g1
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;
200ac14: b4 10 20 01 mov 1, %i2
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
200ac18: c4 00 40 00 ld [ %g1 ], %g2
200ac1c: 86 90 a0 00 orcc %g2, 0, %g3
200ac20: 22 80 00 06 be,a 200ac38 <_RBTree_Insert_unprotected+0xdc>
200ac24: 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);
200ac28: c8 00 60 0c ld [ %g1 + 0xc ], %g4
200ac2c: 80 a1 20 01 cmp %g4, 1
200ac30: 22 80 00 08 be,a 200ac50 <_RBTree_Insert_unprotected+0xf4>
200ac34: f6 00 80 00 ld [ %g2 ], %i3
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
200ac38: 81 c7 e0 08 ret
200ac3c: 81 e8 00 00 restore
compare_result = the_rbtree->compare_function(
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
(dir && _RBTree_Is_greater(compare_result)) ) {
200ac40: 04 bf ff f4 ble 200ac10 <_RBTree_Insert_unprotected+0xb4>
200ac44: b5 2e a0 02 sll %i2, 2, %i2
the_rbtree->first[dir] = the_node;
200ac48: 10 bf ff f2 b 200ac10 <_RBTree_Insert_unprotected+0xb4>
200ac4c: f2 27 00 1a st %i1, [ %i4 + %i2 ]
)
{
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;
200ac50: 80 a6 e0 00 cmp %i3, 0
200ac54: 02 80 00 0c be 200ac84 <_RBTree_Insert_unprotected+0x128> <== NEVER TAKEN
200ac58: c8 00 a0 04 ld [ %g2 + 4 ], %g4
{
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])
200ac5c: 80 a1 00 01 cmp %g4, %g1
200ac60: 02 80 00 5b be 200adcc <_RBTree_Insert_unprotected+0x270>
200ac64: ba 10 00 04 mov %g4, %i5
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200ac68: 80 a7 60 00 cmp %i5, 0
200ac6c: 22 80 00 07 be,a 200ac88 <_RBTree_Insert_unprotected+0x12c>
200ac70: fa 00 60 04 ld [ %g1 + 4 ], %i5
200ac74: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200ac78: 80 a7 20 01 cmp %i4, 1
200ac7c: 22 80 00 4f be,a 200adb8 <_RBTree_Insert_unprotected+0x25c>
200ac80: c0 20 60 0c clr [ %g1 + 0xc ]
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];
200ac84: fa 00 60 04 ld [ %g1 + 4 ], %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
200ac88: 88 18 40 04 xor %g1, %g4, %g4
200ac8c: 80 a0 00 04 cmp %g0, %g4
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];
200ac90: ba 1e 40 1d xor %i1, %i5, %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
200ac94: 88 40 20 00 addx %g0, 0, %g4
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];
200ac98: 80 a0 00 1d cmp %g0, %i5
200ac9c: ba 40 20 00 addx %g0, 0, %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
200aca0: 80 a7 40 04 cmp %i5, %g4
200aca4: 02 80 00 20 be 200ad24 <_RBTree_Insert_unprotected+0x1c8>
200aca8: 80 a0 00 04 cmp %g0, %g4
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200acac: b6 60 3f ff subx %g0, -1, %i3
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
200acb0: b7 2e e0 02 sll %i3, 2, %i3
200acb4: b6 00 40 1b add %g1, %i3, %i3
200acb8: fa 06 e0 04 ld [ %i3 + 4 ], %i5
200acbc: 80 a7 60 00 cmp %i5, 0
200acc0: 02 80 00 16 be 200ad18 <_RBTree_Insert_unprotected+0x1bc> <== NEVER TAKEN
200acc4: b9 29 20 02 sll %g4, 2, %i4
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
200acc8: 9e 07 40 1c add %i5, %i4, %o7
200accc: da 03 e0 04 ld [ %o7 + 4 ], %o5
200acd0: da 26 e0 04 st %o5, [ %i3 + 4 ]
if (c->child[dir])
200acd4: f6 03 e0 04 ld [ %o7 + 4 ], %i3
200acd8: 80 a6 e0 00 cmp %i3, 0
200acdc: 22 80 00 05 be,a 200acf0 <_RBTree_Insert_unprotected+0x194>
200ace0: b6 07 40 1c add %i5, %i4, %i3
c->child[dir]->parent = the_node;
200ace4: c2 26 c0 00 st %g1, [ %i3 ]
200ace8: c4 00 40 00 ld [ %g1 ], %g2
c->child[dir] = the_node;
200acec: b6 07 40 1c add %i5, %i4, %i3
200acf0: c2 26 e0 04 st %g1, [ %i3 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200acf4: f6 00 a0 04 ld [ %g2 + 4 ], %i3
c->parent = the_node->parent;
200acf8: c4 27 40 00 st %g2, [ %i5 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200acfc: b6 1e c0 01 xor %i3, %g1, %i3
c->parent = the_node->parent;
the_node->parent = c;
200ad00: fa 20 40 00 st %i5, [ %g1 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200ad04: 80 a0 00 1b cmp %g0, %i3
200ad08: 82 40 20 00 addx %g0, 0, %g1
200ad0c: 83 28 60 02 sll %g1, 2, %g1
200ad10: 84 00 80 01 add %g2, %g1, %g2
200ad14: fa 20 a0 04 st %i5, [ %g2 + 4 ]
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
200ad18: b2 06 40 1c add %i1, %i4, %i1
200ad1c: f2 06 60 04 ld [ %i1 + 4 ], %i1
200ad20: c2 06 40 00 ld [ %i1 ], %g1
}
the_node->parent->color = RBT_BLACK;
200ad24: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
200ad28: 88 26 80 04 sub %i2, %g4, %g4
200ad2c: ba 19 20 01 xor %g4, 1, %i5
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
200ad30: bb 2f 60 02 sll %i5, 2, %i5
200ad34: ba 00 c0 1d add %g3, %i5, %i5
200ad38: c4 07 60 04 ld [ %i5 + 4 ], %g2
200ad3c: 80 a0 a0 00 cmp %g2, 0
200ad40: 02 bf ff b6 be 200ac18 <_RBTree_Insert_unprotected+0xbc> <== NEVER TAKEN
200ad44: f4 20 e0 0c st %i2, [ %g3 + 0xc ]
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
200ad48: 89 29 20 02 sll %g4, 2, %g4
200ad4c: 82 00 80 04 add %g2, %g4, %g1
200ad50: f8 00 60 04 ld [ %g1 + 4 ], %i4
200ad54: f8 27 60 04 st %i4, [ %i5 + 4 ]
if (c->child[dir])
200ad58: c2 00 60 04 ld [ %g1 + 4 ], %g1
200ad5c: 80 a0 60 00 cmp %g1, 0
200ad60: 32 80 00 02 bne,a 200ad68 <_RBTree_Insert_unprotected+0x20c>
200ad64: c6 20 40 00 st %g3, [ %g1 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200ad68: fa 00 c0 00 ld [ %g3 ], %i5
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
200ad6c: 88 00 80 04 add %g2, %g4, %g4
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
200ad70: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
200ad74: c6 21 20 04 st %g3, [ %g4 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200ad78: c8 07 60 04 ld [ %i5 + 4 ], %g4
c->parent = the_node->parent;
the_node->parent = c;
200ad7c: c4 20 c0 00 st %g2, [ %g3 ]
200ad80: c2 06 40 00 ld [ %i1 ], %g1
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200ad84: 86 18 c0 04 xor %g3, %g4, %g3
200ad88: 80 a0 00 03 cmp %g0, %g3
200ad8c: 86 40 20 00 addx %g0, 0, %g3
200ad90: 87 28 e0 02 sll %g3, 2, %g3
200ad94: ba 07 40 03 add %i5, %g3, %i5
200ad98: c4 27 60 04 st %g2, [ %i5 + 4 ]
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
200ad9c: c4 00 40 00 ld [ %g1 ], %g2
200ada0: 86 90 a0 00 orcc %g2, 0, %g3
200ada4: 32 bf ff a2 bne,a 200ac2c <_RBTree_Insert_unprotected+0xd0><== ALWAYS TAKEN
200ada8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
200adac: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
200adb0: 81 c7 e0 08 ret <== NOT EXECUTED
200adb4: 81 e8 00 00 restore <== NOT EXECUTED
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
200adb8: c0 27 60 0c clr [ %i5 + 0xc ]
g->color = RBT_RED;
200adbc: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
200adc0: 82 10 00 1b mov %i3, %g1
200adc4: 10 bf ff 95 b 200ac18 <_RBTree_Insert_unprotected+0xbc>
200adc8: b2 10 00 02 mov %g2, %i1
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
200adcc: 10 bf ff a7 b 200ac68 <_RBTree_Insert_unprotected+0x10c>
200add0: fa 00 a0 08 ld [ %g2 + 8 ], %i5
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
if(!the_node) return (RBTree_Node*)-1;
200add4: 81 c7 e0 08 ret
200add8: 91 e8 3f ff restore %g0, -1, %o0
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);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200addc: 81 c7 e0 08 ret
200ade0: 91 e8 00 1d restore %g0, %i5, %o0
RBTree_Node *iter_node = the_rbtree->root;
int compare_result;
if (!iter_node) { /* special case: first node inserted */
the_node->color = RBT_BLACK;
the_rbtree->root = the_node;
200ade4: f2 26 20 04 st %i1, [ %i0 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
200ade8: f2 26 20 0c st %i1, [ %i0 + 0xc ]
200adec: f2 26 20 08 st %i1, [ %i0 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
200adf0: f0 26 40 00 st %i0, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200adf4: c0 26 60 08 clr [ %i1 + 8 ]
200adf8: c0 26 60 04 clr [ %i1 + 4 ]
} /* while(iter_node) */
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
200adfc: 81 c7 e0 08 ret
200ae00: 91 e8 20 00 restore %g0, 0, %o0
0200ae34 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
200ae34: 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);
200ae38: 80 a0 00 19 cmp %g0, %i1
200ae3c: 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];
200ae40: 82 00 60 02 add %g1, 2, %g1
200ae44: 83 28 60 02 sll %g1, 2, %g1
200ae48: 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 ) {
200ae4c: 80 a7 60 00 cmp %i5, 0
200ae50: 12 80 00 06 bne 200ae68 <_RBTree_Iterate_unprotected+0x34><== ALWAYS TAKEN
200ae54: 94 10 00 1b mov %i3, %o2
200ae58: 30 80 00 0e b,a 200ae90 <_RBTree_Iterate_unprotected+0x5c><== NOT EXECUTED
200ae5c: 80 8f 20 ff btst 0xff, %i4
200ae60: 02 80 00 0c be 200ae90 <_RBTree_Iterate_unprotected+0x5c> <== NEVER TAKEN
200ae64: 94 10 00 1b mov %i3, %o2
stop = (*visitor)( current, dir, visitor_arg );
200ae68: 90 10 00 1d mov %i5, %o0
200ae6c: 9f c6 80 00 call %i2
200ae70: 92 10 00 19 mov %i1, %o1
current = _RBTree_Next_unprotected( current, dir );
200ae74: 92 10 00 19 mov %i1, %o1
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
stop = (*visitor)( current, dir, visitor_arg );
200ae78: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
200ae7c: 40 00 00 07 call 200ae98 <_RBTree_Next_unprotected>
200ae80: 90 10 00 1d mov %i5, %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 ) {
200ae84: ba 92 20 00 orcc %o0, 0, %i5
200ae88: 12 bf ff f5 bne 200ae5c <_RBTree_Iterate_unprotected+0x28>
200ae8c: b8 1f 20 01 xor %i4, 1, %i4
200ae90: 81 c7 e0 08 ret
200ae94: 81 e8 00 00 restore
02008bec <_RTEMS_signal_Post_switch_hook>:
#include <rtems/score/thread.h>
#include <rtems/score/apiext.h>
#include <rtems/rtems/tasks.h>
static void _RTEMS_signal_Post_switch_hook( Thread_Control *executing )
{
2008bec: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
2008bf0: fa 06 21 58 ld [ %i0 + 0x158 ], %i5
if ( !api )
2008bf4: 80 a7 60 00 cmp %i5, 0
2008bf8: 02 80 00 1e be 2008c70 <_RTEMS_signal_Post_switch_hook+0x84><== NEVER TAKEN
2008bfc: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
2008c00: 7f ff ea 2c call 20034b0 <sparc_disable_interrupts>
2008c04: 01 00 00 00 nop
signal_set = asr->signals_posted;
2008c08: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
asr->signals_posted = 0;
2008c0c: c0 27 60 14 clr [ %i5 + 0x14 ]
_ISR_Enable( level );
2008c10: 7f ff ea 2c call 20034c0 <sparc_enable_interrupts>
2008c14: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
2008c18: 80 a7 20 00 cmp %i4, 0
2008c1c: 32 80 00 04 bne,a 2008c2c <_RTEMS_signal_Post_switch_hook+0x40>
2008c20: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2008c24: 81 c7 e0 08 ret
2008c28: 81 e8 00 00 restore
return;
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008c2c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
2008c30: 82 00 60 01 inc %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008c34: 94 07 bf fc add %fp, -4, %o2
2008c38: 37 00 00 3f sethi %hi(0xfc00), %i3
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
2008c3c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008c40: 40 00 01 07 call 200905c <rtems_task_mode>
2008c44: 92 16 e3 ff or %i3, 0x3ff, %o1
(*asr->handler)( signal_set );
2008c48: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2008c4c: 9f c0 40 00 call %g1
2008c50: 90 10 00 1c mov %i4, %o0
asr->nest_level -= 1;
2008c54: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008c58: d0 07 bf fc ld [ %fp + -4 ], %o0
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
(*asr->handler)( signal_set );
asr->nest_level -= 1;
2008c5c: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008c60: 92 16 e3 ff or %i3, 0x3ff, %o1
2008c64: 94 07 bf fc add %fp, -4, %o2
2008c68: 40 00 00 fd call 200905c <rtems_task_mode>
2008c6c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
2008c70: 81 c7 e0 08 ret
2008c74: 81 e8 00 00 restore
02007fa0 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
2007fa0: 9d e3 bf 98 save %sp, -104, %sp
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
2007fa4: 03 00 80 75 sethi %hi(0x201d400), %g1
2007fa8: 82 10 62 84 or %g1, 0x284, %g1 ! 201d684 <Configuration_RTEMS_API>
2007fac: fa 00 60 2c ld [ %g1 + 0x2c ], %i5
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
2007fb0: 80 a7 60 00 cmp %i5, 0
2007fb4: 02 80 00 18 be 2008014 <_RTEMS_tasks_Initialize_user_tasks_body+0x74>
2007fb8: f6 00 60 28 ld [ %g1 + 0x28 ], %i3
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
2007fbc: 80 a6 e0 00 cmp %i3, 0
2007fc0: 02 80 00 15 be 2008014 <_RTEMS_tasks_Initialize_user_tasks_body+0x74><== NEVER TAKEN
2007fc4: b8 10 20 00 clr %i4
return_value = rtems_task_create(
2007fc8: d4 07 60 04 ld [ %i5 + 4 ], %o2
2007fcc: d0 07 40 00 ld [ %i5 ], %o0
2007fd0: d2 07 60 08 ld [ %i5 + 8 ], %o1
2007fd4: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
2007fd8: d8 07 60 0c ld [ %i5 + 0xc ], %o4
2007fdc: 7f ff ff 70 call 2007d9c <rtems_task_create>
2007fe0: 9a 07 bf fc add %fp, -4, %o5
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
2007fe4: 94 92 20 00 orcc %o0, 0, %o2
2007fe8: 12 80 00 0d bne 200801c <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
2007fec: d0 07 bf fc ld [ %fp + -4 ], %o0
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
2007ff0: d4 07 60 18 ld [ %i5 + 0x18 ], %o2
2007ff4: 40 00 00 0e call 200802c <rtems_task_start>
2007ff8: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
2007ffc: 94 92 20 00 orcc %o0, 0, %o2
2008000: 12 80 00 07 bne 200801c <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
2008004: b8 07 20 01 inc %i4
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
2008008: 80 a7 00 1b cmp %i4, %i3
200800c: 12 bf ff ef bne 2007fc8 <_RTEMS_tasks_Initialize_user_tasks_body+0x28><== NEVER TAKEN
2008010: ba 07 60 1c add %i5, 0x1c, %i5
2008014: 81 c7 e0 08 ret
2008018: 81 e8 00 00 restore
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
200801c: 90 10 20 01 mov 1, %o0
2008020: 40 00 04 30 call 20090e0 <_Internal_error_Occurred>
2008024: 92 10 20 01 mov 1, %o1
0200da4c <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
200da4c: c2 02 21 64 ld [ %o0 + 0x164 ], %g1
while (tvp) {
200da50: 80 a0 60 00 cmp %g1, 0
200da54: 22 80 00 0c be,a 200da84 <_RTEMS_tasks_Switch_extension+0x38>
200da58: c2 02 61 64 ld [ %o1 + 0x164 ], %g1
tvp->tval = *tvp->ptr;
200da5c: c4 00 60 04 ld [ %g1 + 4 ], %g2
*tvp->ptr = tvp->gval;
200da60: c6 00 60 08 ld [ %g1 + 8 ], %g3
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
200da64: c8 00 80 00 ld [ %g2 ], %g4
200da68: c8 20 60 0c st %g4, [ %g1 + 0xc ]
*tvp->ptr = tvp->gval;
200da6c: c6 20 80 00 st %g3, [ %g2 ]
tvp = (rtems_task_variable_t *)tvp->next;
200da70: c2 00 40 00 ld [ %g1 ], %g1
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
200da74: 80 a0 60 00 cmp %g1, 0
200da78: 32 bf ff fa bne,a 200da60 <_RTEMS_tasks_Switch_extension+0x14><== NEVER TAKEN
200da7c: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
200da80: c2 02 61 64 ld [ %o1 + 0x164 ], %g1
while (tvp) {
200da84: 80 a0 60 00 cmp %g1, 0
200da88: 02 80 00 0d be 200dabc <_RTEMS_tasks_Switch_extension+0x70>
200da8c: 01 00 00 00 nop
tvp->gval = *tvp->ptr;
200da90: c4 00 60 04 ld [ %g1 + 4 ], %g2
*tvp->ptr = tvp->tval;
200da94: c6 00 60 0c ld [ %g1 + 0xc ], %g3
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
200da98: c8 00 80 00 ld [ %g2 ], %g4
200da9c: c8 20 60 08 st %g4, [ %g1 + 8 ]
*tvp->ptr = tvp->tval;
200daa0: c6 20 80 00 st %g3, [ %g2 ]
tvp = (rtems_task_variable_t *)tvp->next;
200daa4: c2 00 40 00 ld [ %g1 ], %g1
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
200daa8: 80 a0 60 00 cmp %g1, 0
200daac: 32 bf ff fa bne,a 200da94 <_RTEMS_tasks_Switch_extension+0x48><== NEVER TAKEN
200dab0: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
200dab4: 81 c3 e0 08 retl
200dab8: 01 00 00 00 nop
200dabc: 81 c3 e0 08 retl
02037f40 <_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
)
{
2037f40: 9d e3 bf 98 save %sp, -104, %sp
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
2037f44: 13 00 81 9c sethi %hi(0x2067000), %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
2037f48: f6 06 20 40 ld [ %i0 + 0x40 ], %i3
2037f4c: 90 07 bf f8 add %fp, -8, %o0
2037f50: 7f ff 42 77 call 200892c <_TOD_Get_with_nanoseconds>
2037f54: 92 12 62 b0 or %o1, 0x2b0, %o1
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
2037f58: c4 1f bf f8 ldd [ %fp + -8 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2037f5c: f8 1e 20 50 ldd [ %i0 + 0x50 ], %i4
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
2037f60: 03 00 81 9e sethi %hi(0x2067800), %g1
2037f64: 82 10 60 80 or %g1, 0x80, %g1 ! 2067880 <_Per_CPU_Information>
2037f68: de 00 60 10 ld [ %g1 + 0x10 ], %o7
2037f6c: ba a0 c0 1d subcc %g3, %i5, %i5
2037f70: b8 60 80 1c subx %g2, %i4, %i4
2037f74: f8 3e 40 00 std %i4, [ %i1 ]
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
2037f78: 88 10 20 01 mov 1, %g4
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
2037f7c: 80 a3 c0 1b cmp %o7, %i3
2037f80: 02 80 00 05 be 2037f94 <_Rate_monotonic_Get_status+0x54>
2037f84: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
2037f88: b0 09 20 01 and %g4, 1, %i0
2037f8c: 81 c7 e0 08 ret
2037f90: 81 e8 00 00 restore
2037f94: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2037f98: f0 1e 20 48 ldd [ %i0 + 0x48 ], %i0
2037f9c: 86 a0 c0 0d subcc %g3, %o5, %g3
2037fa0: 84 60 80 0c subx %g2, %o4, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2037fa4: 9a 87 40 03 addcc %i5, %g3, %o5
2037fa8: 98 47 00 02 addx %i4, %g2, %o4
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
2037fac: 80 a6 00 0c cmp %i0, %o4
2037fb0: 14 bf ff f6 bg 2037f88 <_Rate_monotonic_Get_status+0x48> <== NEVER TAKEN
2037fb4: 88 10 20 00 clr %g4
2037fb8: 02 80 00 09 be 2037fdc <_Rate_monotonic_Get_status+0x9c>
2037fbc: 80 a6 40 0d cmp %i1, %o5
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2037fc0: 9a a3 40 19 subcc %o5, %i1, %o5
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
2037fc4: 88 10 20 01 mov 1, %g4
2037fc8: 98 63 00 18 subx %o4, %i0, %o4
}
2037fcc: b0 09 20 01 and %g4, 1, %i0
2037fd0: d8 3e 80 00 std %o4, [ %i2 ]
2037fd4: 81 c7 e0 08 ret
2037fd8: 81 e8 00 00 restore
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
2037fdc: 28 bf ff fa bleu,a 2037fc4 <_Rate_monotonic_Get_status+0x84>
2037fe0: 9a a3 40 19 subcc %o5, %i1, %o5
return false;
2037fe4: 10 bf ff e9 b 2037f88 <_Rate_monotonic_Get_status+0x48>
2037fe8: 88 10 20 00 clr %g4
02038390 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
2038390: 9d e3 bf 98 save %sp, -104, %sp
2038394: 11 00 81 9f sethi %hi(0x2067c00), %o0
2038398: 92 10 00 18 mov %i0, %o1
203839c: 90 12 22 44 or %o0, 0x244, %o0
20383a0: 7f ff 44 37 call 200947c <_Objects_Get>
20383a4: 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 ) {
20383a8: c2 07 bf fc ld [ %fp + -4 ], %g1
20383ac: 80 a0 60 00 cmp %g1, 0
20383b0: 12 80 00 16 bne 2038408 <_Rate_monotonic_Timeout+0x78> <== NEVER TAKEN
20383b4: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
20383b8: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
20383bc: 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);
20383c0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
20383c4: 80 88 80 01 btst %g2, %g1
20383c8: 22 80 00 08 be,a 20383e8 <_Rate_monotonic_Timeout+0x58>
20383cc: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
20383d0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
20383d4: c2 07 60 08 ld [ %i5 + 8 ], %g1
20383d8: 80 a0 80 01 cmp %g2, %g1
20383dc: 02 80 00 19 be 2038440 <_Rate_monotonic_Timeout+0xb0>
20383e0: 13 04 01 ff sethi %hi(0x1007fc00), %o1
_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 ) {
20383e4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
20383e8: 80 a0 60 01 cmp %g1, 1
20383ec: 02 80 00 09 be 2038410 <_Rate_monotonic_Timeout+0x80>
20383f0: 82 10 20 04 mov 4, %g1
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
20383f4: 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)
{
uint32_t level = _Thread_Dispatch_disable_level;
20383f8: 03 00 81 9c sethi %hi(0x2067000), %g1
20383fc: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 2067360 <_Thread_Dispatch_disable_level>
--level;
2038400: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
2038404: c4 20 63 60 st %g2, [ %g1 + 0x360 ]
2038408: 81 c7 e0 08 ret
203840c: 81 e8 00 00 restore
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
2038410: 82 10 20 03 mov 3, %g1
_Rate_monotonic_Initiate_statistics( the_period );
2038414: 90 10 00 1d mov %i5, %o0
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
2038418: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
203841c: 7f ff ff 43 call 2038128 <_Rate_monotonic_Initiate_statistics>
2038420: 01 00 00 00 nop
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2038424: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2038428: 11 00 81 9c sethi %hi(0x2067000), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203842c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2038430: 90 12 23 fc or %o0, 0x3fc, %o0
2038434: 7f ff 4b 52 call 200b17c <_Watchdog_Insert>
2038438: 92 07 60 10 add %i5, 0x10, %o1
203843c: 30 bf ff ef b,a 20383f8 <_Rate_monotonic_Timeout+0x68>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
2038440: 7f ff 46 f8 call 200a020 <_Thread_Clear_state>
2038444: 92 12 63 f8 or %o1, 0x3f8, %o1
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
2038448: 10 bf ff f5 b 203841c <_Rate_monotonic_Timeout+0x8c>
203844c: 90 10 00 1d mov %i5, %o0
02037fec <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
2037fec: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
2037ff0: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
2037ff4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
2037ff8: 84 00 a0 01 inc %g2
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
2037ffc: 80 a0 60 04 cmp %g1, 4
2038000: 02 80 00 32 be 20380c8 <_Rate_monotonic_Update_statistics+0xdc>
2038004: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
2038008: 90 10 00 18 mov %i0, %o0
203800c: 92 07 bf f8 add %fp, -8, %o1
2038010: 7f ff ff cc call 2037f40 <_Rate_monotonic_Get_status>
2038014: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
2038018: 80 8a 20 ff btst 0xff, %o0
203801c: 02 80 00 21 be 20380a0 <_Rate_monotonic_Update_statistics+0xb4>
2038020: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2038024: f8 1e 20 70 ldd [ %i0 + 0x70 ], %i4
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
2038028: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
203802c: b6 87 40 03 addcc %i5, %g3, %i3
2038030: b4 47 00 02 addx %i4, %g2, %i2
2038034: 80 a0 40 02 cmp %g1, %g2
2038038: 04 80 00 1c ble 20380a8 <_Rate_monotonic_Update_statistics+0xbc>
203803c: f4 3e 20 70 std %i2, [ %i0 + 0x70 ]
stats->min_cpu_time = executed;
2038040: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
2038044: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
2038048: 80 a0 40 02 cmp %g1, %g2
203804c: 26 80 00 05 bl,a 2038060 <_Rate_monotonic_Update_statistics+0x74><== NEVER TAKEN
2038050: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
2038054: 80 a0 40 02 cmp %g1, %g2
2038058: 22 80 00 28 be,a 20380f8 <_Rate_monotonic_Update_statistics+0x10c><== ALWAYS TAKEN
203805c: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
2038060: c4 1f bf f8 ldd [ %fp + -8 ], %g2
2038064: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
2038068: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
203806c: b6 87 40 03 addcc %i5, %g3, %i3
2038070: b4 47 00 02 addx %i4, %g2, %i2
2038074: 80 a0 40 02 cmp %g1, %g2
2038078: 14 80 00 1b bg 20380e4 <_Rate_monotonic_Update_statistics+0xf8>
203807c: f4 3e 20 88 std %i2, [ %i0 + 0x88 ]
2038080: 80 a0 40 02 cmp %g1, %g2
2038084: 22 80 00 15 be,a 20380d8 <_Rate_monotonic_Update_statistics+0xec><== ALWAYS TAKEN
2038088: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
203808c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2038090: 80 a0 40 02 cmp %g1, %g2
2038094: 16 80 00 1e bge 203810c <_Rate_monotonic_Update_statistics+0x120><== ALWAYS TAKEN
2038098: 01 00 00 00 nop
stats->max_wall_time = since_last_period;
203809c: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
20380a0: 81 c7 e0 08 ret
20380a4: 81 e8 00 00 restore
* 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 ) )
20380a8: 32 bf ff e8 bne,a 2038048 <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN
20380ac: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
20380b0: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
20380b4: 80 a0 40 03 cmp %g1, %g3
20380b8: 28 bf ff e4 bleu,a 2038048 <_Rate_monotonic_Update_statistics+0x5c>
20380bc: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
20380c0: 10 bf ff e1 b 2038044 <_Rate_monotonic_Update_statistics+0x58>
20380c4: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
20380c8: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
20380cc: 82 00 60 01 inc %g1
20380d0: 10 bf ff ce b 2038008 <_Rate_monotonic_Update_statistics+0x1c>
20380d4: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
20380d8: 80 a0 40 03 cmp %g1, %g3
20380dc: 28 bf ff ed bleu,a 2038090 <_Rate_monotonic_Update_statistics+0xa4>
20380e0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
20380e4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
20380e8: 80 a0 40 02 cmp %g1, %g2
20380ec: 06 bf ff ec bl 203809c <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
20380f0: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
20380f4: 30 80 00 06 b,a 203810c <_Rate_monotonic_Update_statistics+0x120>
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
stats->min_cpu_time = executed;
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
20380f8: 80 a0 40 03 cmp %g1, %g3
20380fc: 3a bf ff da bcc,a 2038064 <_Rate_monotonic_Update_statistics+0x78>
2038100: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
2038104: 10 bf ff d7 b 2038060 <_Rate_monotonic_Update_statistics+0x74>
2038108: c4 3e 20 68 std %g2, [ %i0 + 0x68 ]
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
203810c: 12 bf ff e5 bne 20380a0 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
2038110: 01 00 00 00 nop
2038114: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2038118: 80 a0 40 03 cmp %g1, %g3
203811c: 2a bf ff e1 bcs,a 20380a0 <_Rate_monotonic_Update_statistics+0xb4>
2038120: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
2038124: 30 bf ff df b,a 20380a0 <_Rate_monotonic_Update_statistics+0xb4>
0200a60c <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
200a60c: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
200a610: 40 00 07 3f call 200c30c <_Workspace_Allocate>
200a614: 90 10 20 1c mov 0x1c, %o0
if ( sched ) {
200a618: 80 a2 20 00 cmp %o0, 0
200a61c: 02 80 00 06 be 200a634 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN
200a620: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a624: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
200a628: f0 22 00 00 st %i0, [ %o0 ]
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a62c: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
schinfo->cbs_server = NULL;
200a630: c0 22 20 18 clr [ %o0 + 0x18 ]
}
return sched;
}
200a634: 81 c7 e0 08 ret
200a638: 91 e8 00 08 restore %g0, %o0, %o0
0200b9e0 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
200b9e0: 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;
200b9e4: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200b9e8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200b9ec: 80 a0 40 09 cmp %g1, %o1
200b9f0: 32 80 00 02 bne,a 200b9f8 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
200b9f4: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200b9f8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200b9fc: 80 a0 40 09 cmp %g1, %o1
200ba00: 02 80 00 04 be 200ba10 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
200ba04: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200ba08: 40 00 01 92 call 200c050 <_Thread_Change_priority>
200ba0c: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
200ba10: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
200ba14: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200ba18: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200ba1c: 80 a0 a0 00 cmp %g2, 0
200ba20: 02 80 00 09 be 200ba44 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
200ba24: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
200ba28: d0 00 40 00 ld [ %g1 ], %o0
200ba2c: 7f ff ff d5 call 200b980 <_Scheduler_CBS_Get_server_id>
200ba30: 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 );
200ba34: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200ba38: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200ba3c: 9f c0 40 00 call %g1
200ba40: d0 07 bf fc ld [ %fp + -4 ], %o0
200ba44: 81 c7 e0 08 ret
200ba48: 81 e8 00 00 restore
0200b538 <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
200b538: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
200b53c: 39 00 80 83 sethi %hi(0x2020c00), %i4
200b540: c2 07 22 c0 ld [ %i4 + 0x2c0 ], %g1 ! 2020ec0 <_Scheduler_CBS_Maximum_servers>
200b544: 80 a0 60 00 cmp %g1, 0
200b548: 02 80 00 18 be 200b5a8 <_Scheduler_CBS_Cleanup+0x70> <== NEVER TAKEN
200b54c: 03 00 80 88 sethi %hi(0x2022000), %g1
200b550: 37 00 80 88 sethi %hi(0x2022000), %i3
200b554: c4 06 e0 a8 ld [ %i3 + 0xa8 ], %g2 ! 20220a8 <_Scheduler_CBS_Server_list>
200b558: ba 10 20 00 clr %i5
200b55c: b8 17 22 c0 or %i4, 0x2c0, %i4
if ( _Scheduler_CBS_Server_list[ i ] )
200b560: 83 2f 60 02 sll %i5, 2, %g1
200b564: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200b568: 80 a0 60 00 cmp %g1, 0
200b56c: 02 80 00 05 be 200b580 <_Scheduler_CBS_Cleanup+0x48>
200b570: 90 10 00 1d mov %i5, %o0
_Scheduler_CBS_Destroy_server( i );
200b574: 40 00 00 46 call 200b68c <_Scheduler_CBS_Destroy_server>
200b578: 01 00 00 00 nop
200b57c: c4 06 e0 a8 ld [ %i3 + 0xa8 ], %g2
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
200b580: c2 07 00 00 ld [ %i4 ], %g1
200b584: ba 07 60 01 inc %i5
200b588: 80 a0 40 1d cmp %g1, %i5
200b58c: 18 bf ff f6 bgu 200b564 <_Scheduler_CBS_Cleanup+0x2c>
200b590: 83 2f 60 02 sll %i5, 2, %g1
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
return SCHEDULER_CBS_OK;
}
200b594: b0 10 20 00 clr %i0
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
200b598: 40 00 08 6f call 200d754 <_Workspace_Free>
200b59c: 90 10 00 02 mov %g2, %o0
return SCHEDULER_CBS_OK;
}
200b5a0: 81 c7 e0 08 ret
200b5a4: 81 e8 00 00 restore
200b5a8: 10 bf ff fb b 200b594 <_Scheduler_CBS_Cleanup+0x5c> <== NOT EXECUTED
200b5ac: c4 00 60 a8 ld [ %g1 + 0xa8 ], %g2 <== NOT EXECUTED
0200b5b0 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
200b5b0: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
200b5b4: c2 06 20 04 ld [ %i0 + 4 ], %g1
200b5b8: 80 a0 60 00 cmp %g1, 0
200b5bc: 04 80 00 30 ble 200b67c <_Scheduler_CBS_Create_server+0xcc>
200b5c0: b8 10 00 18 mov %i0, %i4
200b5c4: c2 06 00 00 ld [ %i0 ], %g1
200b5c8: 80 a0 60 00 cmp %g1, 0
200b5cc: 04 80 00 2c ble 200b67c <_Scheduler_CBS_Create_server+0xcc>
200b5d0: 03 00 80 83 sethi %hi(0x2020c00), %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++ ) {
200b5d4: c8 00 62 c0 ld [ %g1 + 0x2c0 ], %g4 ! 2020ec0 <_Scheduler_CBS_Maximum_servers>
200b5d8: 80 a1 20 00 cmp %g4, 0
200b5dc: 02 80 00 11 be 200b620 <_Scheduler_CBS_Create_server+0x70><== NEVER TAKEN
200b5e0: 37 00 80 88 sethi %hi(0x2022000), %i3
if ( !_Scheduler_CBS_Server_list[i] )
200b5e4: fa 06 e0 a8 ld [ %i3 + 0xa8 ], %i5 ! 20220a8 <_Scheduler_CBS_Server_list>
200b5e8: c2 07 40 00 ld [ %i5 ], %g1
200b5ec: 80 a0 60 00 cmp %g1, 0
200b5f0: 02 80 00 21 be 200b674 <_Scheduler_CBS_Create_server+0xc4>
200b5f4: b0 10 20 00 clr %i0
200b5f8: 10 80 00 06 b 200b610 <_Scheduler_CBS_Create_server+0x60>
200b5fc: 82 10 20 00 clr %g1
200b600: c6 07 40 02 ld [ %i5 + %g2 ], %g3
200b604: 80 a0 e0 00 cmp %g3, 0
200b608: 02 80 00 08 be 200b628 <_Scheduler_CBS_Create_server+0x78>
200b60c: b0 10 00 02 mov %g2, %i0
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++ ) {
200b610: 82 00 60 01 inc %g1
200b614: 80 a0 40 04 cmp %g1, %g4
200b618: 12 bf ff fa bne 200b600 <_Scheduler_CBS_Create_server+0x50>
200b61c: 85 28 60 02 sll %g1, 2, %g2
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
200b620: 81 c7 e0 08 ret
200b624: 91 e8 3f e6 restore %g0, -26, %o0
*server_id = i;
200b628: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
200b62c: 40 00 08 42 call 200d734 <_Workspace_Allocate>
200b630: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
200b634: 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 *)
200b638: d0 27 40 18 st %o0, [ %i5 + %i0 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
200b63c: c4 06 e0 a8 ld [ %i3 + 0xa8 ], %g2
200b640: 83 28 60 02 sll %g1, 2, %g1
200b644: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
200b648: 80 a0 60 00 cmp %g1, 0
200b64c: 02 80 00 0e be 200b684 <_Scheduler_CBS_Create_server+0xd4><== NEVER TAKEN
200b650: 86 10 3f ff mov -1, %g3
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
200b654: c4 07 00 00 ld [ %i4 ], %g2
200b658: c4 20 60 04 st %g2, [ %g1 + 4 ]
200b65c: c4 07 20 04 ld [ %i4 + 4 ], %g2
the_server->task_id = -1;
200b660: c6 20 40 00 st %g3, [ %g1 ]
_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;
200b664: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
200b668: f2 20 60 0c st %i1, [ %g1 + 0xc ]
return SCHEDULER_CBS_OK;
200b66c: 81 c7 e0 08 ret
200b670: 91 e8 20 00 restore %g0, 0, %o0
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++ ) {
if ( !_Scheduler_CBS_Server_list[i] )
200b674: 10 bf ff ed b 200b628 <_Scheduler_CBS_Create_server+0x78>
200b678: 82 10 20 00 clr %g1
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
200b67c: 81 c7 e0 08 ret
200b680: 91 e8 3f ee restore %g0, -18, %o0
the_server->parameters = *params;
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
}
200b684: 81 c7 e0 08 ret <== NOT EXECUTED
200b688: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
0200b70c <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
200b70c: 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);
200b710: 92 07 bf fc add %fp, -4, %o1
200b714: 40 00 03 ad call 200c5c8 <_Thread_Get>
200b718: 90 10 00 19 mov %i1, %o0
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
200b71c: ba 92 20 00 orcc %o0, 0, %i5
200b720: 02 80 00 1e be 200b798 <_Scheduler_CBS_Detach_thread+0x8c>
200b724: 01 00 00 00 nop
_Thread_Enable_dispatch();
200b728: 40 00 03 9c call 200c598 <_Thread_Enable_dispatch>
200b72c: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
200b730: 03 00 80 83 sethi %hi(0x2020c00), %g1
200b734: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 2020ec0 <_Scheduler_CBS_Maximum_servers>
200b738: 80 a6 00 01 cmp %i0, %g1
200b73c: 1a 80 00 17 bcc 200b798 <_Scheduler_CBS_Detach_thread+0x8c>
200b740: 03 00 80 88 sethi %hi(0x2022000), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
200b744: c2 00 60 a8 ld [ %g1 + 0xa8 ], %g1 ! 20220a8 <_Scheduler_CBS_Server_list>
200b748: b1 2e 20 02 sll %i0, 2, %i0
200b74c: c2 00 40 18 ld [ %g1 + %i0 ], %g1
200b750: 80 a0 60 00 cmp %g1, 0
200b754: 02 80 00 13 be 200b7a0 <_Scheduler_CBS_Detach_thread+0x94>
200b758: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
200b75c: c4 00 40 00 ld [ %g1 ], %g2
200b760: 80 a0 80 19 cmp %g2, %i1
200b764: 12 80 00 0d bne 200b798 <_Scheduler_CBS_Detach_thread+0x8c><== NEVER TAKEN
200b768: 84 10 3f ff mov -1, %g2
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
200b76c: c8 07 60 88 ld [ %i5 + 0x88 ], %g4
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
200b770: c6 07 60 a0 ld [ %i5 + 0xa0 ], %g3
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
200b774: c4 20 40 00 st %g2, [ %g1 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
200b778: c4 07 60 a4 ld [ %i5 + 0xa4 ], %g2
the_thread->is_preemptible = the_thread->Start.is_preemptible;
200b77c: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
200b780: c0 21 20 18 clr [ %g4 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
200b784: c6 27 60 78 st %g3, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
200b788: c4 27 60 7c st %g2, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
200b78c: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
200b790: 81 c7 e0 08 ret
200b794: 91 e8 20 00 restore %g0, 0, %o0
if ( the_thread ) {
_Thread_Enable_dispatch();
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
200b798: 81 c7 e0 08 ret
200b79c: 91 e8 3f ee restore %g0, -18, %o0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
}
200b7a0: 81 c7 e0 08 ret
200b7a4: 91 e8 3f e7 restore %g0, -25, %o0
0200b980 <_Scheduler_CBS_Get_server_id>:
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
200b980: 03 00 80 83 sethi %hi(0x2020c00), %g1
200b984: c6 00 62 c0 ld [ %g1 + 0x2c0 ], %g3 ! 2020ec0 <_Scheduler_CBS_Maximum_servers>
200b988: 80 a0 e0 00 cmp %g3, 0
200b98c: 02 80 00 11 be 200b9d0 <_Scheduler_CBS_Get_server_id+0x50><== NEVER TAKEN
200b990: 03 00 80 88 sethi %hi(0x2022000), %g1
200b994: c8 00 60 a8 ld [ %g1 + 0xa8 ], %g4 ! 20220a8 <_Scheduler_CBS_Server_list>
200b998: 82 10 20 00 clr %g1
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Get_server_id (
200b99c: 85 28 60 02 sll %g1, 2, %g2
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
200b9a0: c4 01 00 02 ld [ %g4 + %g2 ], %g2
200b9a4: 80 a0 a0 00 cmp %g2, 0
200b9a8: 22 80 00 07 be,a 200b9c4 <_Scheduler_CBS_Get_server_id+0x44>
200b9ac: 82 00 60 01 inc %g1
200b9b0: c4 00 80 00 ld [ %g2 ], %g2
200b9b4: 80 a0 80 08 cmp %g2, %o0
200b9b8: 22 80 00 08 be,a 200b9d8 <_Scheduler_CBS_Get_server_id+0x58>
200b9bc: c2 22 40 00 st %g1, [ %o1 ]
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
200b9c0: 82 00 60 01 inc %g1
200b9c4: 80 a0 40 03 cmp %g1, %g3
200b9c8: 12 bf ff f6 bne 200b9a0 <_Scheduler_CBS_Get_server_id+0x20>
200b9cc: 85 28 60 02 sll %g1, 2, %g2
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
200b9d0: 81 c3 e0 08 retl
200b9d4: 90 10 3f e7 mov -25, %o0
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
200b9d8: 81 c3 e0 08 retl
200b9dc: 90 10 20 00 clr %o0
0200ba4c <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
200ba4c: 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*) );
200ba50: 3b 00 80 83 sethi %hi(0x2020c00), %i5
200ba54: d0 07 62 c0 ld [ %i5 + 0x2c0 ], %o0 ! 2020ec0 <_Scheduler_CBS_Maximum_servers>
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
200ba58: 40 00 07 37 call 200d734 <_Workspace_Allocate>
200ba5c: 91 2a 20 02 sll %o0, 2, %o0
200ba60: 09 00 80 88 sethi %hi(0x2022000), %g4
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
200ba64: 80 a2 20 00 cmp %o0, 0
200ba68: 02 80 00 10 be 200baa8 <_Scheduler_CBS_Initialize+0x5c> <== NEVER TAKEN
200ba6c: d0 21 20 a8 st %o0, [ %g4 + 0xa8 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200ba70: c6 07 62 c0 ld [ %i5 + 0x2c0 ], %g3
200ba74: 80 a0 e0 00 cmp %g3, 0
200ba78: 12 80 00 05 bne 200ba8c <_Scheduler_CBS_Initialize+0x40> <== ALWAYS TAKEN
200ba7c: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
200ba80: 81 c7 e0 08 ret <== NOT EXECUTED
200ba84: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
200ba88: d0 01 20 a8 ld [ %g4 + 0xa8 ], %o0
_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++) {
_Scheduler_CBS_Server_list[i] = NULL;
200ba8c: 85 28 60 02 sll %g1, 2, %g2
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++) {
200ba90: 82 00 60 01 inc %g1
200ba94: 80 a0 40 03 cmp %g1, %g3
200ba98: 12 bf ff fc bne 200ba88 <_Scheduler_CBS_Initialize+0x3c>
200ba9c: c0 22 00 02 clr [ %o0 + %g2 ]
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
200baa0: 81 c7 e0 08 ret
200baa4: 91 e8 20 00 restore %g0, 0, %o0
{
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;
200baa8: b0 10 3f ef mov -17, %i0 <== NOT EXECUTED
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
}
200baac: 81 c7 e0 08 ret <== NOT EXECUTED
200bab0: 81 e8 00 00 restore <== NOT EXECUTED
0200a63c <_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;
200a63c: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
200a640: 80 a2 60 00 cmp %o1, 0
200a644: 02 80 00 11 be 200a688 <_Scheduler_CBS_Release_job+0x4c>
200a648: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
200a64c: 80 a0 60 00 cmp %g1, 0
200a650: 02 80 00 13 be 200a69c <_Scheduler_CBS_Release_job+0x60>
200a654: 07 00 80 80 sethi %hi(0x2020000), %g3
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
200a658: c4 00 60 04 ld [ %g1 + 4 ], %g2
200a65c: d2 00 e0 7c ld [ %g3 + 0x7c ], %o1
200a660: 92 02 40 02 add %o1, %g2, %o1
200a664: 05 20 00 00 sethi %hi(0x80000000), %g2
200a668: 92 2a 40 02 andn %o1, %g2, %o1
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
the_thread->cpu_time_budget = serv_info->parameters.budget;
200a66c: c2 00 60 08 ld [ %g1 + 8 ], %g1
200a670: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
200a674: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
200a678: 94 10 20 01 mov 1, %o2
200a67c: 82 13 c0 00 mov %o7, %g1
200a680: 40 00 01 3a call 200ab68 <_Thread_Change_priority>
200a684: 9e 10 40 00 mov %g1, %o7
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
200a688: 80 a0 60 00 cmp %g1, 0
200a68c: 12 bf ff f8 bne 200a66c <_Scheduler_CBS_Release_job+0x30> <== ALWAYS TAKEN
200a690: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
the_thread->real_priority = new_priority;
200a694: 10 bf ff f9 b 200a678 <_Scheduler_CBS_Release_job+0x3c> <== NOT EXECUTED
200a698: d2 22 20 18 st %o1, [ %o0 + 0x18 ] <== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
200a69c: 03 00 80 80 sethi %hi(0x2020000), %g1
200a6a0: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 ! 202007c <_Watchdog_Ticks_since_boot>
200a6a4: 92 02 40 01 add %o1, %g1, %o1
200a6a8: 03 20 00 00 sethi %hi(0x80000000), %g1
200a6ac: 10 bf ff f2 b 200a674 <_Scheduler_CBS_Release_job+0x38>
200a6b0: 92 2a 40 01 andn %o1, %g1, %o1
0200a6b4 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
200a6b4: 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);
200a6b8: 40 00 00 50 call 200a7f8 <_Scheduler_EDF_Enqueue>
200a6bc: 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;
200a6c0: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
200a6c4: 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) {
200a6c8: 80 a7 60 00 cmp %i5, 0
200a6cc: 02 80 00 19 be 200a730 <_Scheduler_CBS_Unblock+0x7c>
200a6d0: 03 00 80 80 sethi %hi(0x2020000), %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 ) {
200a6d4: 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 -
200a6d8: d0 00 60 7c ld [ %g1 + 0x7c ], %o0
200a6dc: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
200a6e0: 40 00 41 03 call 201aaec <.umul>
200a6e4: 90 27 00 08 sub %i4, %o0, %o0
200a6e8: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
200a6ec: b6 10 00 08 mov %o0, %i3
200a6f0: 40 00 40 ff call 201aaec <.umul>
200a6f4: d0 07 60 08 ld [ %i5 + 8 ], %o0
200a6f8: 80 a6 c0 08 cmp %i3, %o0
200a6fc: 24 80 00 0e ble,a 200a734 <_Scheduler_CBS_Unblock+0x80>
200a700: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
200a704: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200a708: 80 a7 00 09 cmp %i4, %o1
200a70c: 32 80 00 02 bne,a 200a714 <_Scheduler_CBS_Unblock+0x60>
200a710: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200a714: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
200a718: 80 a2 00 09 cmp %o0, %o1
200a71c: 02 80 00 07 be 200a738 <_Scheduler_CBS_Unblock+0x84>
200a720: 3b 00 80 81 sethi %hi(0x2020400), %i5
_Thread_Change_priority(the_thread, new_priority, true);
200a724: 90 10 00 18 mov %i0, %o0
200a728: 40 00 01 10 call 200ab68 <_Thread_Change_priority>
200a72c: 94 10 20 01 mov 1, %o2
200a730: d0 06 20 14 ld [ %i0 + 0x14 ], %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_higher_than( the_thread->current_priority,
200a734: 3b 00 80 81 sethi %hi(0x2020400), %i5
200a738: ba 17 60 b0 or %i5, 0xb0, %i5 ! 20204b0 <_Per_CPU_Information>
200a73c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200a740: d2 00 60 14 ld [ %g1 + 0x14 ], %o1
200a744: 03 00 80 7c sethi %hi(0x201f000), %g1
200a748: c2 00 63 24 ld [ %g1 + 0x324 ], %g1 ! 201f324 <_Scheduler+0x30>
200a74c: 9f c0 40 00 call %g1
200a750: 01 00 00 00 nop
200a754: 80 a2 20 00 cmp %o0, 0
200a758: 04 80 00 0a ble 200a780 <_Scheduler_CBS_Unblock+0xcc>
200a75c: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a760: c2 07 60 10 ld [ %i5 + 0x10 ], %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;
200a764: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
200a768: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a76c: 80 a0 60 00 cmp %g1, 0
200a770: 22 80 00 06 be,a 200a788 <_Scheduler_CBS_Unblock+0xd4>
200a774: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a778: 82 10 20 01 mov 1, %g1
200a77c: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
200a780: 81 c7 e0 08 ret
200a784: 81 e8 00 00 restore
* 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;
if ( _Thread_Executing->is_preemptible ||
200a788: 80 a0 60 00 cmp %g1, 0
200a78c: 12 bf ff fd bne 200a780 <_Scheduler_CBS_Unblock+0xcc> <== ALWAYS TAKEN
200a790: 82 10 20 01 mov 1, %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a794: c2 2f 60 0c stb %g1, [ %i5 + 0xc ] <== NOT EXECUTED
200a798: 30 bf ff fa b,a 200a780 <_Scheduler_CBS_Unblock+0xcc> <== NOT EXECUTED
0200a60c <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
200a60c: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
200a610: 40 00 07 16 call 200c268 <_Workspace_Allocate>
200a614: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
200a618: 80 a2 20 00 cmp %o0, 0
200a61c: 02 80 00 05 be 200a630 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
200a620: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a624: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
200a628: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a62c: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
200a630: 81 c7 e0 08 ret
200a634: 91 e8 00 08 restore %g0, %o0, %o0
0200a7f0 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
200a7f0: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
200a7f4: 7f ff ff a8 call 200a694 <_Scheduler_EDF_Enqueue>
200a7f8: 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(
200a7fc: 3b 00 80 80 sethi %hi(0x2020000), %i5
200a800: ba 17 63 f0 or %i5, 0x3f0, %i5 ! 20203f0 <_Per_CPU_Information>
200a804: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200a808: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
200a80c: 03 00 80 7c sethi %hi(0x201f000), %g1
200a810: c2 00 62 74 ld [ %g1 + 0x274 ], %g1 ! 201f274 <_Scheduler+0x30>
200a814: 9f c0 40 00 call %g1
200a818: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
200a81c: 80 a2 20 00 cmp %o0, 0
200a820: 26 80 00 04 bl,a 200a830 <_Scheduler_EDF_Unblock+0x40>
200a824: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200a828: 81 c7 e0 08 ret
200a82c: 81 e8 00 00 restore
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
200a830: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
200a834: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a838: 80 a0 60 00 cmp %g1, 0
200a83c: 22 80 00 06 be,a 200a854 <_Scheduler_EDF_Unblock+0x64>
200a840: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a844: 82 10 20 01 mov 1, %g1
200a848: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
200a84c: 81 c7 e0 08 ret
200a850: 81 e8 00 00 restore
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a854: 80 a0 60 00 cmp %g1, 0
200a858: 12 bf ff f4 bne 200a828 <_Scheduler_EDF_Unblock+0x38> <== ALWAYS TAKEN
200a85c: 82 10 20 01 mov 1, %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a860: c2 2f 60 0c stb %g1, [ %i5 + 0xc ] <== NOT EXECUTED
200a864: 30 bf ff fa b,a 200a84c <_Scheduler_EDF_Unblock+0x5c> <== NOT EXECUTED
02009f60 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
2009f60: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
executing = _Thread_Executing;
2009f64: 03 00 80 7a sethi %hi(0x201e800), %g1
2009f68: d0 00 60 50 ld [ %g1 + 0x50 ], %o0 ! 201e850 <_Per_CPU_Information+0x10>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
2009f6c: c2 0a 20 70 ldub [ %o0 + 0x70 ], %g1
2009f70: 80 a0 60 00 cmp %g1, 0
2009f74: 02 80 00 26 be 200a00c <_Scheduler_priority_Tick+0xac>
2009f78: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
2009f7c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
2009f80: 80 a0 60 00 cmp %g1, 0
2009f84: 12 80 00 22 bne 200a00c <_Scheduler_priority_Tick+0xac>
2009f88: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
2009f8c: c2 02 20 78 ld [ %o0 + 0x78 ], %g1
2009f90: 80 a0 60 01 cmp %g1, 1
2009f94: 0a 80 00 07 bcs 2009fb0 <_Scheduler_priority_Tick+0x50>
2009f98: 80 a0 60 02 cmp %g1, 2
2009f9c: 28 80 00 10 bleu,a 2009fdc <_Scheduler_priority_Tick+0x7c>
2009fa0: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
2009fa4: 80 a0 60 03 cmp %g1, 3
2009fa8: 22 80 00 04 be,a 2009fb8 <_Scheduler_priority_Tick+0x58> <== ALWAYS TAKEN
2009fac: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
2009fb0: 81 c7 e0 08 ret
2009fb4: 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 )
2009fb8: 82 00 7f ff add %g1, -1, %g1
2009fbc: 80 a0 60 00 cmp %g1, 0
2009fc0: 12 bf ff fc bne 2009fb0 <_Scheduler_priority_Tick+0x50>
2009fc4: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
(*executing->budget_callout)( executing );
2009fc8: c2 02 20 7c ld [ %o0 + 0x7c ], %g1
2009fcc: 9f c0 40 00 call %g1
2009fd0: 01 00 00 00 nop
2009fd4: 81 c7 e0 08 ret
2009fd8: 81 e8 00 00 restore
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 ) {
2009fdc: 82 00 7f ff add %g1, -1, %g1
2009fe0: 80 a0 60 00 cmp %g1, 0
2009fe4: 14 bf ff f3 bg 2009fb0 <_Scheduler_priority_Tick+0x50>
2009fe8: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
2009fec: 03 00 80 75 sethi %hi(0x201d400), %g1
2009ff0: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 201d710 <_Scheduler+0xc>
2009ff4: 9f c0 40 00 call %g1
2009ff8: d0 27 bf fc st %o0, [ %fp + -4 ]
* 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;
2009ffc: 03 00 80 78 sethi %hi(0x201e000), %g1
200a000: d0 07 bf fc ld [ %fp + -4 ], %o0
200a004: c2 00 62 80 ld [ %g1 + 0x280 ], %g1
200a008: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
200a00c: 81 c7 e0 08 ret
200a010: 81 e8 00 00 restore
0200a808 <_Scheduler_simple_Ready_queue_enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
200a808: 03 00 80 79 sethi %hi(0x201e400), %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200a80c: c2 00 63 04 ld [ %g1 + 0x304 ], %g1 ! 201e704 <_Scheduler>
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
200a810: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
200a814: c2 00 40 00 ld [ %g1 ], %g1
200a818: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200a81c: 80 a0 80 03 cmp %g2, %g3
200a820: 3a 80 00 08 bcc,a 200a840 <_Scheduler_simple_Ready_queue_enqueue_first+0x38>
200a824: c2 00 60 04 ld [ %g1 + 4 ], %g1
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
200a828: c2 00 40 00 ld [ %g1 ], %g1
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
200a82c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200a830: 80 a0 80 03 cmp %g2, %g3
200a834: 2a bf ff fe bcs,a 200a82c <_Scheduler_simple_Ready_queue_enqueue_first+0x24><== NEVER TAKEN
200a838: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
200a83c: c2 00 60 04 ld [ %g1 + 4 ], %g1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200a840: c4 00 40 00 ld [ %g1 ], %g2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200a844: c2 22 20 04 st %g1, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200a848: d0 20 40 00 st %o0, [ %g1 ]
the_node->next = before_node;
200a84c: c4 22 00 00 st %g2, [ %o0 ]
before_node->previous = the_node;
200a850: 81 c3 e0 08 retl
200a854: d0 20 a0 04 st %o0, [ %g2 + 4 ]
02008808 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
2008808: 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();
200880c: 03 00 80 75 sethi %hi(0x201d400), %g1
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
2008810: d2 00 63 2c ld [ %g1 + 0x32c ], %o1 ! 201d72c <Configuration+0xc>
2008814: 11 00 03 d0 sethi %hi(0xf4000), %o0
2008818: 40 00 4a d8 call 201b378 <.udiv>
200881c: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
2008820: 80 a6 20 00 cmp %i0, 0
2008824: 02 80 00 2c be 20088d4 <_TOD_Validate+0xcc> <== NEVER TAKEN
2008828: 82 10 20 00 clr %g1
200882c: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
2008830: 80 a2 00 02 cmp %o0, %g2
2008834: 28 80 00 26 bleu,a 20088cc <_TOD_Validate+0xc4>
2008838: b0 08 60 01 and %g1, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
200883c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
2008840: 80 a0 a0 3b cmp %g2, 0x3b
2008844: 38 80 00 22 bgu,a 20088cc <_TOD_Validate+0xc4>
2008848: b0 08 60 01 and %g1, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
200884c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
2008850: 80 a0 a0 3b cmp %g2, 0x3b
2008854: 38 80 00 1e bgu,a 20088cc <_TOD_Validate+0xc4>
2008858: b0 08 60 01 and %g1, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
200885c: c4 06 20 0c ld [ %i0 + 0xc ], %g2
2008860: 80 a0 a0 17 cmp %g2, 0x17
2008864: 38 80 00 1a bgu,a 20088cc <_TOD_Validate+0xc4>
2008868: b0 08 60 01 and %g1, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
200886c: c4 06 20 04 ld [ %i0 + 4 ], %g2
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) ||
2008870: 80 a0 a0 00 cmp %g2, 0
2008874: 02 80 00 15 be 20088c8 <_TOD_Validate+0xc0> <== NEVER TAKEN
2008878: 80 a0 a0 0c cmp %g2, 0xc
(the_tod->month == 0) ||
200887c: 38 80 00 14 bgu,a 20088cc <_TOD_Validate+0xc4>
2008880: b0 08 60 01 and %g1, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
2008884: 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) ||
2008888: 80 a0 e7 c3 cmp %g3, 0x7c3
200888c: 28 80 00 10 bleu,a 20088cc <_TOD_Validate+0xc4>
2008890: b0 08 60 01 and %g1, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
2008894: c8 06 20 08 ld [ %i0 + 8 ], %g4
(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) ||
2008898: 80 a1 20 00 cmp %g4, 0
200889c: 02 80 00 0b be 20088c8 <_TOD_Validate+0xc0> <== NEVER TAKEN
20088a0: 80 88 e0 03 btst 3, %g3
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
20088a4: 32 80 00 0f bne,a 20088e0 <_TOD_Validate+0xd8>
20088a8: 85 28 a0 02 sll %g2, 2, %g2
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
20088ac: 82 00 a0 0d add %g2, 0xd, %g1
20088b0: 05 00 80 7a sethi %hi(0x201e800), %g2
20088b4: 83 28 60 02 sll %g1, 2, %g1
20088b8: 84 10 a1 20 or %g2, 0x120, %g2
20088bc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
if ( the_tod->day > days_in_month )
20088c0: 80 a0 40 04 cmp %g1, %g4
20088c4: 82 60 3f ff subx %g0, -1, %g1
return false;
return true;
}
20088c8: b0 08 60 01 and %g1, 1, %i0
20088cc: 81 c7 e0 08 ret
20088d0: 81 e8 00 00 restore
20088d4: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED
20088d8: 81 c7 e0 08 ret <== NOT EXECUTED
20088dc: 81 e8 00 00 restore <== NOT EXECUTED
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
20088e0: 03 00 80 7a sethi %hi(0x201e800), %g1
20088e4: 82 10 61 20 or %g1, 0x120, %g1 ! 201e920 <_TOD_Days_per_month>
20088e8: c2 00 40 02 ld [ %g1 + %g2 ], %g1
if ( the_tod->day > days_in_month )
20088ec: 80 a0 40 04 cmp %g1, %g4
20088f0: 10 bf ff f6 b 20088c8 <_TOD_Validate+0xc0>
20088f4: 82 60 3f ff subx %g0, -1, %g1
0200a230 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
200a230: 9d e3 bf a0 save %sp, -96, %sp
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
200a234: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
/*
* 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 );
200a238: 40 00 03 c3 call 200b144 <_Thread_Set_transient>
200a23c: 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 )
200a240: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a244: 80 a0 40 19 cmp %g1, %i1
200a248: 02 80 00 05 be 200a25c <_Thread_Change_priority+0x2c>
200a24c: ba 10 00 18 mov %i0, %i5
_Thread_Set_priority( the_thread, new_priority );
200a250: 90 10 00 18 mov %i0, %o0
200a254: 40 00 03 a2 call 200b0dc <_Thread_Set_priority>
200a258: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
200a25c: 7f ff e0 ec call 200260c <sparc_disable_interrupts>
200a260: 01 00 00 00 nop
200a264: b2 10 00 08 mov %o0, %i1
/*
* 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;
200a268: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
200a26c: 80 a7 20 04 cmp %i4, 4
200a270: 02 80 00 18 be 200a2d0 <_Thread_Change_priority+0xa0>
200a274: 80 8e e0 04 btst 4, %i3
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
200a278: 02 80 00 0b be 200a2a4 <_Thread_Change_priority+0x74> <== ALWAYS TAKEN
200a27c: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
200a280: 7f ff e0 e7 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
200a284: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
200a288: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED
200a28c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
if ( _States_Is_waiting_on_thread_queue( state ) ) {
200a290: 80 8f 00 01 btst %i4, %g1 <== NOT EXECUTED
200a294: 32 80 00 0d bne,a 200a2c8 <_Thread_Change_priority+0x98> <== NOT EXECUTED
200a298: f0 07 60 44 ld [ %i5 + 0x44 ], %i0 <== NOT EXECUTED
200a29c: 81 c7 e0 08 ret
200a2a0: 81 e8 00 00 restore
*/
state = the_thread->current_state;
if ( state != STATES_TRANSIENT ) {
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
200a2a4: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
200a2a8: 7f ff e0 dd call 200261c <sparc_enable_interrupts>
200a2ac: 90 10 00 19 mov %i1, %o0
200a2b0: 03 00 00 ef sethi %hi(0x3bc00), %g1
200a2b4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
if ( _States_Is_waiting_on_thread_queue( state ) ) {
200a2b8: 80 8f 00 01 btst %i4, %g1
200a2bc: 02 bf ff f8 be 200a29c <_Thread_Change_priority+0x6c>
200a2c0: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
200a2c4: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
200a2c8: 40 00 03 55 call 200b01c <_Thread_queue_Requeue>
200a2cc: 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 ) ) {
200a2d0: 22 80 00 19 be,a 200a334 <_Thread_Change_priority+0x104> <== ALWAYS TAKEN
200a2d4: c0 27 60 10 clr [ %i5 + 0x10 ]
200a2d8: 39 00 80 75 sethi %hi(0x201d400), %i4 <== NOT EXECUTED
200a2dc: b8 17 23 04 or %i4, 0x304, %i4 ! 201d704 <_Scheduler> <== NOT EXECUTED
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
200a2e0: 7f ff e0 cf call 200261c <sparc_enable_interrupts>
200a2e4: 90 10 00 19 mov %i1, %o0
200a2e8: 7f ff e0 c9 call 200260c <sparc_disable_interrupts>
200a2ec: 01 00 00 00 nop
200a2f0: 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();
200a2f4: c2 07 20 08 ld [ %i4 + 8 ], %g1
200a2f8: 9f c0 40 00 call %g1
200a2fc: 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 );
200a300: 03 00 80 7a sethi %hi(0x201e800), %g1
200a304: 82 10 60 40 or %g1, 0x40, %g1 ! 201e840 <_Per_CPU_Information>
* 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() &&
200a308: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2
200a30c: 80 a0 80 03 cmp %g2, %g3
200a310: 02 80 00 07 be 200a32c <_Thread_Change_priority+0xfc>
200a314: 01 00 00 00 nop
200a318: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
200a31c: 80 a0 a0 00 cmp %g2, 0
200a320: 02 80 00 03 be 200a32c <_Thread_Change_priority+0xfc>
200a324: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
200a328: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
_ISR_Enable( level );
200a32c: 7f ff e0 bc call 200261c <sparc_enable_interrupts>
200a330: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
200a334: 39 00 80 75 sethi %hi(0x201d400), %i4
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
if ( prepend_it )
200a338: 80 a6 a0 00 cmp %i2, 0
200a33c: 02 80 00 06 be 200a354 <_Thread_Change_priority+0x124>
200a340: b8 17 23 04 or %i4, 0x304, %i4
200a344: c2 07 20 28 ld [ %i4 + 0x28 ], %g1
200a348: 9f c0 40 00 call %g1
200a34c: 90 10 00 1d mov %i5, %o0
200a350: 30 bf ff e4 b,a 200a2e0 <_Thread_Change_priority+0xb0>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
200a354: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
200a358: 9f c0 40 00 call %g1
200a35c: 90 10 00 1d mov %i5, %o0
200a360: 30 bf ff e0 b,a 200a2e0 <_Thread_Change_priority+0xb0>
0200a574 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200a574: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200a578: 90 10 00 18 mov %i0, %o0
200a57c: 40 00 00 8b call 200a7a8 <_Thread_Get>
200a580: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a584: c2 07 bf fc ld [ %fp + -4 ], %g1
200a588: 80 a0 60 00 cmp %g1, 0
200a58c: 12 80 00 08 bne 200a5ac <_Thread_Delay_ended+0x38> <== NEVER TAKEN
200a590: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
200a594: 7f ff ff 74 call 200a364 <_Thread_Clear_state>
200a598: 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)
{
uint32_t level = _Thread_Dispatch_disable_level;
200a59c: 03 00 80 78 sethi %hi(0x201e000), %g1
200a5a0: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 201e320 <_Thread_Dispatch_disable_level>
--level;
200a5a4: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
200a5a8: c4 20 63 20 st %g2, [ %g1 + 0x320 ]
200a5ac: 81 c7 e0 08 ret
200a5b0: 81 e8 00 00 restore
0200a5b4 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
200a5b4: 9d e3 bf 98 save %sp, -104, %sp
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
200a5b8: 35 00 80 7a sethi %hi(0x201e800), %i2
200a5bc: b4 16 a0 40 or %i2, 0x40, %i2 ! 201e840 <_Per_CPU_Information>
_ISR_Disable( level );
200a5c0: 7f ff e0 13 call 200260c <sparc_disable_interrupts>
200a5c4: fa 06 a0 10 ld [ %i2 + 0x10 ], %i5
while ( _Thread_Dispatch_necessary == true ) {
200a5c8: c2 0e a0 0c ldub [ %i2 + 0xc ], %g1
200a5cc: 80 a0 60 00 cmp %g1, 0
200a5d0: 02 80 00 55 be 200a724 <_Thread_Dispatch+0x170>
200a5d4: 31 00 80 78 sethi %hi(0x201e000), %i0
heir = _Thread_Heir;
200a5d8: f8 06 a0 14 ld [ %i2 + 0x14 ], %i4
* This routine sets thread dispatch level to the
* value passed in.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_set_disable_level(uint32_t value)
{
_Thread_Dispatch_disable_level = value;
200a5dc: 82 10 20 01 mov 1, %g1
200a5e0: c2 26 23 20 st %g1, [ %i0 + 0x320 ]
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
200a5e4: c0 2e a0 0c clrb [ %i2 + 0xc ]
/*
* 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 )
200a5e8: 80 a7 40 1c cmp %i5, %i4
200a5ec: 02 80 00 4e be 200a724 <_Thread_Dispatch+0x170>
200a5f0: f8 26 a0 10 st %i4, [ %i2 + 0x10 ]
200a5f4: 21 00 80 76 sethi %hi(0x201d800), %l0
200a5f8: 25 00 80 78 sethi %hi(0x201e000), %l2
200a5fc: a0 14 20 d8 or %l0, 0xd8, %l0
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
200a600: 23 00 80 78 sethi %hi(0x201e000), %l1
200a604: a4 14 a3 90 or %l2, 0x390, %l2
200a608: b6 04 20 04 add %l0, 4, %i3
#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;
200a60c: 29 00 80 78 sethi %hi(0x201e000), %l4
200a610: a2 14 62 70 or %l1, 0x270, %l1
#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 );
200a614: 33 00 80 78 sethi %hi(0x201e000), %i1
* This routine sets thread dispatch level to the
* value passed in.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_set_disable_level(uint32_t value)
{
_Thread_Dispatch_disable_level = value;
200a618: a6 10 20 01 mov 1, %l3
*/
#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 )
200a61c: c2 07 20 78 ld [ %i4 + 0x78 ], %g1
200a620: 80 a0 60 01 cmp %g1, 1
200a624: 02 80 00 53 be 200a770 <_Thread_Dispatch+0x1bc>
200a628: c2 05 22 80 ld [ %l4 + 0x280 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
_ISR_Enable( level );
200a62c: 7f ff df fc call 200261c <sparc_enable_interrupts>
200a630: 01 00 00 00 nop
200a634: 92 10 00 11 mov %l1, %o1
200a638: 7f ff f9 62 call 2008bc0 <_TOD_Get_with_nanoseconds>
200a63c: 90 07 bf f8 add %fp, -8, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
200a640: d8 1e a0 20 ldd [ %i2 + 0x20 ], %o4
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
200a644: c4 1f 60 80 ldd [ %i5 + 0x80 ], %g2
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
200a648: d4 1f bf f8 ldd [ %fp + -8 ], %o2
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
200a64c: c2 04 80 00 ld [ %l2 ], %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
200a650: 9a a2 c0 0d subcc %o3, %o5, %o5
200a654: 98 62 80 0c subx %o2, %o4, %o4
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
200a658: 92 80 c0 0d addcc %g3, %o5, %o1
200a65c: 90 40 80 0c addx %g2, %o4, %o0
200a660: d0 3f 60 80 std %o0, [ %i5 + 0x80 ]
200a664: 80 a0 60 00 cmp %g1, 0
200a668: 02 80 00 06 be 200a680 <_Thread_Dispatch+0xcc> <== NEVER TAKEN
200a66c: d4 3e a0 20 std %o2, [ %i2 + 0x20 ]
executing->libc_reent = *_Thread_libc_reent;
200a670: c4 00 40 00 ld [ %g1 ], %g2
200a674: c4 27 61 54 st %g2, [ %i5 + 0x154 ]
*_Thread_libc_reent = heir->libc_reent;
200a678: c4 07 21 54 ld [ %i4 + 0x154 ], %g2
200a67c: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200a680: ea 04 00 00 ld [ %l0 ], %l5
{
const Chain_Control *chain = &_User_extensions_Switches_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
200a684: 80 a5 40 1b cmp %l5, %i3
200a688: 02 80 00 0b be 200a6b4 <_Thread_Dispatch+0x100> <== NEVER TAKEN
200a68c: 90 07 60 c8 add %i5, 0xc8, %o0
const User_extensions_Switch_control *extension =
(const User_extensions_Switch_control *) node;
(*extension->thread_switch)( executing, heir );
200a690: c2 05 60 08 ld [ %l5 + 8 ], %g1
200a694: 90 10 00 1d mov %i5, %o0
200a698: 9f c0 40 00 call %g1
200a69c: 92 10 00 1c mov %i4, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
200a6a0: ea 05 40 00 ld [ %l5 ], %l5
{
const Chain_Control *chain = &_User_extensions_Switches_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
200a6a4: 80 a5 40 1b cmp %l5, %i3
200a6a8: 32 bf ff fb bne,a 200a694 <_Thread_Dispatch+0xe0>
200a6ac: c2 05 60 08 ld [ %l5 + 8 ], %g1
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
200a6b0: 90 07 60 c8 add %i5, 0xc8, %o0
200a6b4: 40 00 04 ef call 200ba70 <_CPU_Context_switch>
200a6b8: 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) &&
200a6bc: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
200a6c0: 80 a0 60 00 cmp %g1, 0
200a6c4: 02 80 00 0c be 200a6f4 <_Thread_Dispatch+0x140>
200a6c8: d0 06 63 8c ld [ %i1 + 0x38c ], %o0
200a6cc: 80 a7 40 08 cmp %i5, %o0
200a6d0: 02 80 00 09 be 200a6f4 <_Thread_Dispatch+0x140>
200a6d4: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200a6d8: 02 80 00 04 be 200a6e8 <_Thread_Dispatch+0x134>
200a6dc: 01 00 00 00 nop
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200a6e0: 40 00 04 aa call 200b988 <_CPU_Context_save_fp>
200a6e4: 90 02 21 50 add %o0, 0x150, %o0
_Context_Restore_fp( &executing->fp_context );
200a6e8: 40 00 04 c5 call 200b9fc <_CPU_Context_restore_fp>
200a6ec: 90 07 61 50 add %i5, 0x150, %o0
_Thread_Allocated_fp = executing;
200a6f0: fa 26 63 8c st %i5, [ %i1 + 0x38c ]
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
200a6f4: 7f ff df c6 call 200260c <sparc_disable_interrupts>
200a6f8: fa 06 a0 10 ld [ %i2 + 0x10 ], %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 ) {
200a6fc: c2 0e a0 0c ldub [ %i2 + 0xc ], %g1
200a700: 80 a0 60 00 cmp %g1, 0
200a704: 02 80 00 08 be 200a724 <_Thread_Dispatch+0x170>
200a708: 01 00 00 00 nop
heir = _Thread_Heir;
200a70c: f8 06 a0 14 ld [ %i2 + 0x14 ], %i4
200a710: e6 26 23 20 st %l3, [ %i0 + 0x320 ]
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
200a714: c0 2e a0 0c clrb [ %i2 + 0xc ]
/*
* 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 )
200a718: 80 a7 00 1d cmp %i4, %i5
200a71c: 12 bf ff c0 bne 200a61c <_Thread_Dispatch+0x68> <== ALWAYS TAKEN
200a720: f8 26 a0 10 st %i4, [ %i2 + 0x10 ]
200a724: c0 26 23 20 clr [ %i0 + 0x320 ]
post_switch:
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 0 );
#endif
_ISR_Enable( level );
200a728: 7f ff df bd call 200261c <sparc_enable_interrupts>
200a72c: 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;
200a730: 03 00 80 78 sethi %hi(0x201e000), %g1
200a734: f8 00 63 94 ld [ %g1 + 0x394 ], %i4 ! 201e394 <_API_extensions_Post_switch_list>
200a738: 82 10 63 94 or %g1, 0x394, %g1
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
200a73c: b6 00 60 04 add %g1, 4, %i3
200a740: 80 a7 00 1b cmp %i4, %i3
200a744: 02 80 00 09 be 200a768 <_Thread_Dispatch+0x1b4>
200a748: 01 00 00 00 nop
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
200a74c: c2 07 20 08 ld [ %i4 + 8 ], %g1
200a750: 9f c0 40 00 call %g1
200a754: 90 10 00 1d mov %i5, %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
200a758: f8 07 00 00 ld [ %i4 ], %i4
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
200a75c: 80 a7 00 1b cmp %i4, %i3
200a760: 32 bf ff fc bne,a 200a750 <_Thread_Dispatch+0x19c> <== NEVER TAKEN
200a764: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
200a768: 81 c7 e0 08 ret
200a76c: 81 e8 00 00 restore
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a770: 10 bf ff af b 200a62c <_Thread_Dispatch+0x78>
200a774: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
02010168 <_Thread_Handler>:
#define INIT_NAME __main
#define EXECUTE_GLOBAL_CONSTRUCTORS
#endif
void _Thread_Handler( void )
{
2010168: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
201016c: 03 00 80 7a sethi %hi(0x201e800), %g1
2010170: fa 00 60 50 ld [ %g1 + 0x50 ], %i5 ! 201e850 <_Per_CPU_Information+0x10>
/*
* 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();
2010174: 3f 00 80 40 sethi %hi(0x2010000), %i7
2010178: be 17 e1 68 or %i7, 0x168, %i7 ! 2010168 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
201017c: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
2010180: 7f ff c9 27 call 200261c <sparc_enable_interrupts>
2010184: 91 2a 20 08 sll %o0, 8, %o0
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
2010188: c4 07 61 50 ld [ %i5 + 0x150 ], %g2
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
201018c: 03 00 80 78 sethi %hi(0x201e000), %g1
doneConstructors = true;
2010190: 86 10 20 01 mov 1, %g3
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
2010194: f6 08 60 20 ldub [ %g1 + 0x20 ], %i3
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
2010198: 80 a0 a0 00 cmp %g2, 0
201019c: 02 80 00 0c be 20101cc <_Thread_Handler+0x64>
20101a0: c6 28 60 20 stb %g3, [ %g1 + 0x20 ]
#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 );
20101a4: 39 00 80 78 sethi %hi(0x201e000), %i4
20101a8: d0 07 23 8c ld [ %i4 + 0x38c ], %o0 ! 201e38c <_Thread_Allocated_fp>
20101ac: 80 a7 40 08 cmp %i5, %o0
20101b0: 02 80 00 07 be 20101cc <_Thread_Handler+0x64>
20101b4: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
20101b8: 22 80 00 05 be,a 20101cc <_Thread_Handler+0x64>
20101bc: fa 27 23 8c st %i5, [ %i4 + 0x38c ]
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
20101c0: 7f ff ed f2 call 200b988 <_CPU_Context_save_fp>
20101c4: 90 02 21 50 add %o0, 0x150, %o0
_Thread_Allocated_fp = executing;
20101c8: fa 27 23 8c st %i5, [ %i4 + 0x38c ]
);
}
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{
_User_extensions_Iterate(
20101cc: 90 10 00 1d mov %i5, %o0
20101d0: 13 00 80 2c sethi %hi(0x200b000), %o1
20101d4: 7f ff ec 77 call 200b3b0 <_User_extensions_Iterate>
20101d8: 92 12 63 3c or %o1, 0x33c, %o1 ! 200b33c <_User_extensions_Thread_begin_visitor>
_User_extensions_Thread_begin( executing );
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
20101dc: 7f ff e9 67 call 200a778 <_Thread_Enable_dispatch>
20101e0: 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) */ {
20101e4: 80 8e e0 ff btst 0xff, %i3
20101e8: 02 80 00 10 be 2010228 <_Thread_Handler+0xc0>
20101ec: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
20101f0: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
20101f4: 80 a0 60 00 cmp %g1, 0
20101f8: 02 80 00 10 be 2010238 <_Thread_Handler+0xd0>
20101fc: 80 a0 60 01 cmp %g1, 1
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
2010200: 22 80 00 13 be,a 201024c <_Thread_Handler+0xe4> <== ALWAYS TAKEN
2010204: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
}
}
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{
_User_extensions_Iterate(
2010208: 90 10 00 1d mov %i5, %o0
201020c: 13 00 80 2c sethi %hi(0x200b000), %o1
2010210: 7f ff ec 68 call 200b3b0 <_User_extensions_Iterate>
2010214: 92 12 63 60 or %o1, 0x360, %o1 ! 200b360 <_User_extensions_Thread_exitted_visitor>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error_Occurred(
2010218: 90 10 20 00 clr %o0
201021c: 92 10 20 01 mov 1, %o1
2010220: 7f ff e3 b0 call 20090e0 <_Internal_error_Occurred>
2010224: 94 10 20 05 mov 5, %o2
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (doCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
2010228: 40 00 35 04 call 201d638 <_init>
201022c: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
2010230: 10 bf ff f1 b 20101f4 <_Thread_Handler+0x8c>
2010234: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
2010238: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
201023c: 9f c0 40 00 call %g1
2010240: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
2010244: 10 bf ff f1 b 2010208 <_Thread_Handler+0xa0>
2010248: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
201024c: 9f c0 40 00 call %g1
2010250: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
2010254: 10 bf ff ed b 2010208 <_Thread_Handler+0xa0>
2010258: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
0200aa6c <_Thread_Handler_initialization>:
#if defined(RTEMS_SMP)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
200aa6c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
200aa70: 03 00 80 6d sethi %hi(0x201b400), %g1
200aa74: 82 10 60 c8 or %g1, 0xc8, %g1 ! 201b4c8 <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200aa78: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
200aa7c: fa 00 60 14 ld [ %g1 + 0x14 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
200aa80: f8 00 60 08 ld [ %g1 + 8 ], %i4
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200aa84: 80 a0 e0 00 cmp %g3, 0
200aa88: 02 80 00 21 be 200ab0c <_Thread_Handler_initialization+0xa0><== NEVER TAKEN
200aa8c: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
200aa90: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
200aa94: 80 a0 e0 00 cmp %g3, 0
200aa98: 02 80 00 1d be 200ab0c <_Thread_Handler_initialization+0xa0>
200aa9c: 80 a0 a0 00 cmp %g2, 0
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
200aaa0: 22 80 00 05 be,a 200aab4 <_Thread_Handler_initialization+0x48>
200aaa4: 03 00 80 7a sethi %hi(0x201e800), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
200aaa8: 9f c0 80 00 call %g2
200aaac: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 201e804 <_RTEMS_Objects+0x4>
_Thread_Dispatch_necessary = false;
200aab0: 03 00 80 7a sethi %hi(0x201e800), %g1
200aab4: 82 10 60 40 or %g1, 0x40, %g1 ! 201e840 <_Per_CPU_Information>
200aab8: c0 28 60 0c clrb [ %g1 + 0xc ]
_Thread_Executing = NULL;
200aabc: c0 20 60 10 clr [ %g1 + 0x10 ]
_Thread_Heir = NULL;
200aac0: c0 20 60 14 clr [ %g1 + 0x14 ]
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
200aac4: 03 00 80 78 sethi %hi(0x201e000), %g1
200aac8: c0 20 63 8c clr [ %g1 + 0x38c ] ! 201e38c <_Thread_Allocated_fp>
#endif
_Thread_Maximum_extensions = maximum_extensions;
200aacc: 03 00 80 78 sethi %hi(0x201e000), %g1
200aad0: f8 20 63 a0 st %i4, [ %g1 + 0x3a0 ] ! 201e3a0 <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
200aad4: 03 00 80 78 sethi %hi(0x201e000), %g1
200aad8: fa 20 62 80 st %i5, [ %g1 + 0x280 ] ! 201e280 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
200aadc: 82 10 20 08 mov 8, %g1
200aae0: 11 00 80 79 sethi %hi(0x201e400), %o0
200aae4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200aae8: 90 12 20 14 or %o0, 0x14, %o0
200aaec: 92 10 20 01 mov 1, %o1
200aaf0: 94 10 20 01 mov 1, %o2
200aaf4: 96 10 20 01 mov 1, %o3
200aaf8: 98 10 21 68 mov 0x168, %o4
200aafc: 7f ff fb 22 call 2009784 <_Objects_Initialize_information>
200ab00: 9a 10 20 00 clr %o5
200ab04: 81 c7 e0 08 ret
200ab08: 81 e8 00 00 restore
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
200ab0c: 90 10 20 00 clr %o0
200ab10: 92 10 20 01 mov 1, %o1
200ab14: 7f ff f9 73 call 20090e0 <_Internal_error_Occurred>
200ab18: 94 10 20 0e mov 0xe, %o2
0200a854 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
200a854: 9d e3 bf 98 save %sp, -104, %sp
200a858: 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;
200a85c: c0 26 61 58 clr [ %i1 + 0x158 ]
200a860: c0 26 61 5c clr [ %i1 + 0x15c ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
200a864: 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
)
{
200a868: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
200a86c: 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 ) {
200a870: 80 a6 a0 00 cmp %i2, 0
200a874: 02 80 00 6f be 200aa30 <_Thread_Initialize+0x1dc>
200a878: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = true;
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
200a87c: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
200a880: 90 10 00 1b mov %i3, %o0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
200a884: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
the_stack->size = size;
200a888: 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 ) {
200a88c: 80 a7 20 00 cmp %i4, 0
200a890: 12 80 00 4c bne 200a9c0 <_Thread_Initialize+0x16c>
200a894: b6 10 20 00 clr %i3
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a898: 39 00 80 78 sethi %hi(0x201e000), %i4
200a89c: c2 07 23 a0 ld [ %i4 + 0x3a0 ], %g1 ! 201e3a0 <_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;
200a8a0: f6 26 61 50 st %i3, [ %i1 + 0x150 ]
the_thread->Start.fp_context = fp_area;
200a8a4: f6 26 60 bc st %i3, [ %i1 + 0xbc ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
200a8a8: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
200a8ac: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
200a8b0: c0 26 60 68 clr [ %i1 + 0x68 ]
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a8b4: 80 a0 60 00 cmp %g1, 0
200a8b8: 12 80 00 4a bne 200a9e0 <_Thread_Initialize+0x18c>
200a8bc: c0 26 60 6c clr [ %i1 + 0x6c ]
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
200a8c0: c0 26 61 60 clr [ %i1 + 0x160 ]
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
200a8c4: b4 10 20 00 clr %i2
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
200a8c8: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
200a8cc: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
200a8d0: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
200a8d4: 80 a4 20 02 cmp %l0, 2
200a8d8: 12 80 00 05 bne 200a8ec <_Thread_Initialize+0x98>
200a8dc: 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;
200a8e0: 03 00 80 78 sethi %hi(0x201e000), %g1
200a8e4: c2 00 62 80 ld [ %g1 + 0x280 ], %g1 ! 201e280 <_Thread_Ticks_per_timeslice>
200a8e8: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a8ec: c4 07 a0 68 ld [ %fp + 0x68 ], %g2
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
200a8f0: 03 00 80 75 sethi %hi(0x201d400), %g1
200a8f4: c2 00 63 1c ld [ %g1 + 0x31c ], %g1 ! 201d71c <_Scheduler+0x18>
200a8f8: c4 26 60 a8 st %g2, [ %i1 + 0xa8 ]
the_thread->current_state = STATES_DORMANT;
200a8fc: a0 10 20 01 mov 1, %l0
the_thread->Wait.queue = NULL;
200a900: c0 26 60 44 clr [ %i1 + 0x44 ]
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
200a904: e0 26 60 10 st %l0, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
200a908: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
200a90c: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
200a910: fa 26 60 ac st %i5, [ %i1 + 0xac ]
200a914: 9f c0 40 00 call %g1
200a918: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
200a91c: b8 92 20 00 orcc %o0, 0, %i4
200a920: 22 80 00 17 be,a 200a97c <_Thread_Initialize+0x128>
200a924: d0 06 61 54 ld [ %i1 + 0x154 ], %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
200a928: 90 10 00 19 mov %i1, %o0
200a92c: 40 00 01 ec call 200b0dc <_Thread_Set_priority>
200a930: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a934: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
200a938: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
200a93c: c0 26 60 80 clr [ %i1 + 0x80 ]
200a940: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a944: 83 28 60 02 sll %g1, 2, %g1
200a948: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200a94c: e2 26 60 0c st %l1, [ %i1 + 0xc ]
* @{
*/
static inline bool _User_extensions_Thread_create( Thread_Control *created )
{
User_extensions_Thread_create_context ctx = { created, true };
200a950: f2 27 bf f8 st %i1, [ %fp + -8 ]
200a954: e0 2f bf fc stb %l0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
200a958: 90 07 bf f8 add %fp, -8, %o0
200a95c: 13 00 80 2c sethi %hi(0x200b000), %o1
200a960: 40 00 02 94 call 200b3b0 <_User_extensions_Iterate>
200a964: 92 12 62 88 or %o1, 0x288, %o1 ! 200b288 <_User_extensions_Thread_create_visitor>
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
200a968: c2 0f bf fc ldub [ %fp + -4 ], %g1
200a96c: 80 a0 60 00 cmp %g1, 0
200a970: 12 80 00 11 bne 200a9b4 <_Thread_Initialize+0x160>
200a974: b0 10 20 01 mov 1, %i0
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
200a978: d0 06 61 54 ld [ %i1 + 0x154 ], %o0
200a97c: 40 00 03 ee call 200b934 <_Workspace_Free>
200a980: b0 10 20 00 clr %i0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
200a984: 40 00 03 ec call 200b934 <_Workspace_Free>
200a988: d0 06 61 58 ld [ %i1 + 0x158 ], %o0
200a98c: 40 00 03 ea call 200b934 <_Workspace_Free>
200a990: d0 06 61 5c ld [ %i1 + 0x15c ], %o0
_Workspace_Free( extensions_area );
200a994: 40 00 03 e8 call 200b934 <_Workspace_Free>
200a998: 90 10 00 1a mov %i2, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
200a99c: 40 00 03 e6 call 200b934 <_Workspace_Free>
200a9a0: 90 10 00 1b mov %i3, %o0
#endif
_Workspace_Free( sched );
200a9a4: 40 00 03 e4 call 200b934 <_Workspace_Free>
200a9a8: 90 10 00 1c mov %i4, %o0
_Thread_Stack_Free( the_thread );
200a9ac: 40 00 02 05 call 200b1c0 <_Thread_Stack_Free>
200a9b0: 90 10 00 19 mov %i1, %o0
200a9b4: b0 0e 20 ff and %i0, 0xff, %i0
200a9b8: 81 c7 e0 08 ret
200a9bc: 81 e8 00 00 restore
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
200a9c0: 40 00 03 d5 call 200b914 <_Workspace_Allocate>
200a9c4: 90 10 20 88 mov 0x88, %o0
if ( !fp_area )
200a9c8: b6 92 20 00 orcc %o0, 0, %i3
200a9cc: 32 bf ff b4 bne,a 200a89c <_Thread_Initialize+0x48>
200a9d0: 39 00 80 78 sethi %hi(0x201e000), %i4
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
200a9d4: b4 10 20 00 clr %i2
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;
200a9d8: 10 bf ff e8 b 200a978 <_Thread_Initialize+0x124>
200a9dc: b8 10 20 00 clr %i4
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
200a9e0: 90 00 60 01 add %g1, 1, %o0
200a9e4: 40 00 03 cc call 200b914 <_Workspace_Allocate>
200a9e8: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
200a9ec: b4 92 20 00 orcc %o0, 0, %i2
200a9f0: 02 80 00 1d be 200aa64 <_Thread_Initialize+0x210>
200a9f4: 86 10 00 1a mov %i2, %g3
goto failed;
}
the_thread->extensions = (void **) extensions_area;
200a9f8: f4 26 61 60 st %i2, [ %i1 + 0x160 ]
200a9fc: c8 07 23 a0 ld [ %i4 + 0x3a0 ], %g4
* 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++ )
200aa00: 84 10 20 00 clr %g2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
200aa04: 10 80 00 03 b 200aa10 <_Thread_Initialize+0x1bc>
200aa08: 82 10 20 00 clr %g1
200aa0c: c6 06 61 60 ld [ %i1 + 0x160 ], %g3
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
the_thread->extensions[i] = NULL;
200aa10: 85 28 a0 02 sll %g2, 2, %g2
200aa14: c0 20 c0 02 clr [ %g3 + %g2 ]
* 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++ )
200aa18: 82 00 60 01 inc %g1
200aa1c: 80 a0 40 04 cmp %g1, %g4
200aa20: 08 bf ff fb bleu 200aa0c <_Thread_Initialize+0x1b8>
200aa24: 84 10 00 01 mov %g1, %g2
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
200aa28: 10 bf ff a9 b 200a8cc <_Thread_Initialize+0x78>
200aa2c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
200aa30: 90 10 00 19 mov %i1, %o0
200aa34: 40 00 01 d3 call 200b180 <_Thread_Stack_Allocate>
200aa38: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
200aa3c: 80 a2 00 1b cmp %o0, %i3
200aa40: 0a 80 00 07 bcs 200aa5c <_Thread_Initialize+0x208>
200aa44: 80 a2 20 00 cmp %o0, 0
200aa48: 02 80 00 05 be 200aa5c <_Thread_Initialize+0x208> <== NEVER TAKEN
200aa4c: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
200aa50: f4 06 60 c0 ld [ %i1 + 0xc0 ], %i2
the_thread->Start.core_allocated_stack = true;
200aa54: 10 bf ff 8c b 200a884 <_Thread_Initialize+0x30>
200aa58: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
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 */
200aa5c: 10 bf ff d6 b 200a9b4 <_Thread_Initialize+0x160>
200aa60: b0 10 20 00 clr %i0
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;
200aa64: 10 bf ff c5 b 200a978 <_Thread_Initialize+0x124>
200aa68: b8 10 20 00 clr %i4
0200b1c0 <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
200b1c0: 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 )
200b1c4: c2 0e 20 b0 ldub [ %i0 + 0xb0 ], %g1
200b1c8: 80 a0 60 00 cmp %g1, 0
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
200b1cc: 03 00 80 6d sethi %hi(0x201b400), %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 )
200b1d0: 02 80 00 04 be 200b1e0 <_Thread_Stack_Free+0x20> <== NEVER TAKEN
200b1d4: c2 00 60 f4 ld [ %g1 + 0xf4 ], %g1 ! 201b4f4 <Configuration+0x2c>
* 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 );
200b1d8: 9f c0 40 00 call %g1
200b1dc: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
200b1e0: 81 c7 e0 08 ret
200b1e4: 81 e8 00 00 restore
0200b01c <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
200b01c: 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 )
200b020: 80 a6 20 00 cmp %i0, 0
200b024: 02 80 00 13 be 200b070 <_Thread_queue_Requeue+0x54> <== NEVER TAKEN
200b028: 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 ) {
200b02c: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
200b030: 80 a7 60 01 cmp %i5, 1
200b034: 02 80 00 04 be 200b044 <_Thread_queue_Requeue+0x28> <== ALWAYS TAKEN
200b038: 01 00 00 00 nop
200b03c: 81 c7 e0 08 ret <== NOT EXECUTED
200b040: 81 e8 00 00 restore <== NOT EXECUTED
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
200b044: 7f ff dd 72 call 200260c <sparc_disable_interrupts>
200b048: 01 00 00 00 nop
200b04c: b8 10 00 08 mov %o0, %i4
200b050: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
200b054: 03 00 00 ef sethi %hi(0x3bc00), %g1
200b058: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
200b05c: 80 88 80 01 btst %g2, %g1
200b060: 12 80 00 06 bne 200b078 <_Thread_queue_Requeue+0x5c> <== ALWAYS TAKEN
200b064: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
200b068: 7f ff dd 6d call 200261c <sparc_enable_interrupts>
200b06c: 90 10 00 1c mov %i4, %o0
200b070: 81 c7 e0 08 ret
200b074: 81 e8 00 00 restore
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
200b078: 92 10 00 19 mov %i1, %o1
200b07c: 94 10 20 01 mov 1, %o2
200b080: 40 00 0d 68 call 200e620 <_Thread_queue_Extract_priority_helper>
200b084: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
200b088: 90 10 00 18 mov %i0, %o0
200b08c: 92 10 00 19 mov %i1, %o1
200b090: 7f ff ff 35 call 200ad64 <_Thread_queue_Enqueue_priority>
200b094: 94 07 bf fc add %fp, -4, %o2
200b098: 30 bf ff f4 b,a 200b068 <_Thread_queue_Requeue+0x4c>
0200b09c <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200b09c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200b0a0: 90 10 00 18 mov %i0, %o0
200b0a4: 7f ff fd c1 call 200a7a8 <_Thread_Get>
200b0a8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200b0ac: c2 07 bf fc ld [ %fp + -4 ], %g1
200b0b0: 80 a0 60 00 cmp %g1, 0
200b0b4: 12 80 00 08 bne 200b0d4 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
200b0b8: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200b0bc: 40 00 0d 92 call 200e704 <_Thread_queue_Process_timeout>
200b0c0: 01 00 00 00 nop
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200b0c4: 03 00 80 78 sethi %hi(0x201e000), %g1
200b0c8: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 201e320 <_Thread_Dispatch_disable_level>
--level;
200b0cc: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
200b0d0: c4 20 63 20 st %g2, [ %g1 + 0x320 ]
200b0d4: 81 c7 e0 08 ret
200b0d8: 81 e8 00 00 restore
020180c4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
20180c4: 9d e3 bf 88 save %sp, -120, %sp
20180c8: 21 00 80 f2 sethi %hi(0x203c800), %l0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
20180cc: a4 07 bf e8 add %fp, -24, %l2
20180d0: b4 07 bf ec add %fp, -20, %i2
20180d4: b8 07 bf f4 add %fp, -12, %i4
20180d8: a2 07 bf f8 add %fp, -8, %l1
20180dc: 33 00 80 f2 sethi %hi(0x203c800), %i1
20180e0: 27 00 80 f2 sethi %hi(0x203c800), %l3
20180e4: f4 27 bf e8 st %i2, [ %fp + -24 ]
head->previous = NULL;
20180e8: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
20180ec: e4 27 bf f0 st %l2, [ %fp + -16 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
20180f0: e2 27 bf f4 st %l1, [ %fp + -12 ]
head->previous = NULL;
20180f4: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
20180f8: f8 27 bf fc st %i4, [ %fp + -4 ]
20180fc: a0 14 22 1c or %l0, 0x21c, %l0
2018100: b6 06 20 30 add %i0, 0x30, %i3
2018104: b2 16 60 78 or %i1, 0x78, %i1
2018108: ba 06 20 68 add %i0, 0x68, %i5
201810c: a6 14 e1 30 or %l3, 0x130, %l3
2018110: ac 06 20 08 add %i0, 8, %l6
2018114: aa 06 20 40 add %i0, 0x40, %l5
_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;
2018118: a8 10 20 01 mov 1, %l4
{
/*
* 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;
201811c: e4 26 20 78 st %l2, [ %i0 + 0x78 ]
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
2018120: c2 04 00 00 ld [ %l0 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
2018124: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018128: 90 10 00 1b mov %i3, %o0
201812c: 92 20 40 09 sub %g1, %o1, %o1
2018130: 94 10 00 1c mov %i4, %o2
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
2018134: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018138: 40 00 12 8a call 201cb60 <_Watchdog_Adjust_to_chain>
201813c: 01 00 00 00 nop
2018140: d0 1e 40 00 ldd [ %i1 ], %o0
2018144: 94 10 20 00 clr %o2
2018148: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
201814c: 40 00 51 4c call 202c67c <__divdi3>
2018150: 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;
2018154: 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 ) {
2018158: 80 a2 40 0a cmp %o1, %o2
201815c: 18 80 00 2b bgu 2018208 <_Timer_server_Body+0x144>
2018160: ae 10 00 09 mov %o1, %l7
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
2018164: 80 a2 40 0a cmp %o1, %o2
2018168: 0a 80 00 20 bcs 20181e8 <_Timer_server_Body+0x124>
201816c: 90 10 00 1d mov %i5, %o0
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
2018170: ee 26 20 74 st %l7, [ %i0 + 0x74 ]
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
2018174: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
2018178: 40 00 02 c2 call 2018c80 <_Chain_Get>
201817c: 01 00 00 00 nop
if ( timer == NULL ) {
2018180: 92 92 20 00 orcc %o0, 0, %o1
2018184: 02 80 00 10 be 20181c4 <_Timer_server_Body+0x100>
2018188: 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 ) {
201818c: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
2018190: 80 a0 60 01 cmp %g1, 1
2018194: 02 80 00 19 be 20181f8 <_Timer_server_Body+0x134>
2018198: 80 a0 60 03 cmp %g1, 3
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
201819c: 12 bf ff f6 bne 2018174 <_Timer_server_Body+0xb0> <== NEVER TAKEN
20181a0: 92 02 60 10 add %o1, 0x10, %o1
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
20181a4: 40 00 12 9b call 201cc10 <_Watchdog_Insert>
20181a8: 90 10 00 1d mov %i5, %o0
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
20181ac: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
20181b0: 40 00 02 b4 call 2018c80 <_Chain_Get>
20181b4: 01 00 00 00 nop
if ( timer == NULL ) {
20181b8: 92 92 20 00 orcc %o0, 0, %o1
20181bc: 32 bf ff f5 bne,a 2018190 <_Timer_server_Body+0xcc> <== NEVER TAKEN
20181c0: c2 02 60 38 ld [ %o1 + 0x38 ], %g1 <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
20181c4: 7f ff dd 4d call 200f6f8 <sparc_disable_interrupts>
20181c8: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
20181cc: c2 07 bf e8 ld [ %fp + -24 ], %g1
20181d0: 80 a0 40 1a cmp %g1, %i2
20181d4: 02 80 00 12 be 201821c <_Timer_server_Body+0x158> <== ALWAYS TAKEN
20181d8: 01 00 00 00 nop
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
20181dc: 7f ff dd 4b call 200f708 <sparc_enable_interrupts> <== NOT EXECUTED
20181e0: 01 00 00 00 nop <== NOT EXECUTED
20181e4: 30 bf ff cf b,a 2018120 <_Timer_server_Body+0x5c> <== NOT EXECUTED
/*
* 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 );
20181e8: 92 10 20 01 mov 1, %o1 ! 1 <PROM_START+0x1>
20181ec: 40 00 12 2d call 201caa0 <_Watchdog_Adjust>
20181f0: 94 22 80 17 sub %o2, %l7, %o2
20181f4: 30 bf ff df b,a 2018170 <_Timer_server_Body+0xac>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
20181f8: 90 10 00 1b mov %i3, %o0
20181fc: 40 00 12 85 call 201cc10 <_Watchdog_Insert>
2018200: 92 02 60 10 add %o1, 0x10, %o1
2018204: 30 bf ff dc b,a 2018174 <_Timer_server_Body+0xb0>
/*
* 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 );
2018208: 92 22 40 0a sub %o1, %o2, %o1
201820c: 90 10 00 1d mov %i5, %o0
2018210: 40 00 12 54 call 201cb60 <_Watchdog_Adjust_to_chain>
2018214: 94 10 00 1c mov %i4, %o2
2018218: 30 bf ff d6 b,a 2018170 <_Timer_server_Body+0xac>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
201821c: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
2018220: 7f ff dd 3a call 200f708 <sparc_enable_interrupts>
2018224: 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 ) ) {
2018228: c2 07 bf f4 ld [ %fp + -12 ], %g1
201822c: 80 a0 40 11 cmp %g1, %l1
2018230: 12 80 00 0c bne 2018260 <_Timer_server_Body+0x19c>
2018234: 01 00 00 00 nop
2018238: 30 80 00 13 b,a 2018284 <_Timer_server_Body+0x1c0>
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
201823c: 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;
2018240: c2 27 bf f4 st %g1, [ %fp + -12 ]
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
2018244: c0 25 e0 08 clr [ %l7 + 8 ]
_ISR_Enable( level );
2018248: 7f ff dd 30 call 200f708 <sparc_enable_interrupts>
201824c: 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 );
2018250: d0 05 e0 20 ld [ %l7 + 0x20 ], %o0
2018254: c2 05 e0 1c ld [ %l7 + 0x1c ], %g1
2018258: 9f c0 40 00 call %g1
201825c: d2 05 e0 24 ld [ %l7 + 0x24 ], %o1
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
2018260: 7f ff dd 26 call 200f6f8 <sparc_disable_interrupts>
2018264: 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;
2018268: ee 07 bf f4 ld [ %fp + -12 ], %l7
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
201826c: 80 a5 c0 11 cmp %l7, %l1
2018270: 32 bf ff f3 bne,a 201823c <_Timer_server_Body+0x178>
2018274: c2 05 c0 00 ld [ %l7 ], %g1
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
2018278: 7f ff dd 24 call 200f708 <sparc_enable_interrupts>
201827c: 01 00 00 00 nop
2018280: 30 bf ff a7 b,a 201811c <_Timer_server_Body+0x58>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
2018284: c0 2e 20 7c clrb [ %i0 + 0x7c ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2018288: c2 04 c0 00 ld [ %l3 ], %g1
++level;
201828c: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
2018290: c2 24 c0 00 st %g1, [ %l3 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
2018294: d0 06 00 00 ld [ %i0 ], %o0
2018298: 40 00 11 11 call 201c6dc <_Thread_Set_state>
201829c: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
20182a0: 7f ff ff 07 call 2017ebc <_Timer_server_Reset_interval_system_watchdog>
20182a4: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
20182a8: 7f ff ff 19 call 2017f0c <_Timer_server_Reset_tod_system_watchdog>
20182ac: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
20182b0: 40 00 0e 84 call 201bcc0 <_Thread_Enable_dispatch>
20182b4: 01 00 00 00 nop
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
20182b8: 90 10 00 16 mov %l6, %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;
20182bc: e8 2e 20 7c stb %l4, [ %i0 + 0x7c ]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
20182c0: 40 00 12 b3 call 201cd8c <_Watchdog_Remove>
20182c4: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
20182c8: 40 00 12 b1 call 201cd8c <_Watchdog_Remove>
20182cc: 90 10 00 15 mov %l5, %o0
20182d0: 30 bf ff 93 b,a 201811c <_Timer_server_Body+0x58>
02017f5c <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
2017f5c: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
2017f60: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2017f64: 80 a0 60 00 cmp %g1, 0
2017f68: 02 80 00 05 be 2017f7c <_Timer_server_Schedule_operation_method+0x20>
2017f6c: ba 10 00 19 mov %i1, %i5
* 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 );
2017f70: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
2017f74: 40 00 03 38 call 2018c54 <_Chain_Append>
2017f78: 81 e8 00 00 restore
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2017f7c: 03 00 80 f2 sethi %hi(0x203c800), %g1
2017f80: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 203c930 <_Thread_Dispatch_disable_level>
++level;
2017f84: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2017f88: c4 20 61 30 st %g2, [ %g1 + 0x130 ]
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
2017f8c: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2017f90: 80 a0 60 01 cmp %g1, 1
2017f94: 02 80 00 2b be 2018040 <_Timer_server_Schedule_operation_method+0xe4>
2017f98: 80 a0 60 03 cmp %g1, 3
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2017f9c: 02 80 00 04 be 2017fac <_Timer_server_Schedule_operation_method+0x50>
2017fa0: 01 00 00 00 nop
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
2017fa4: 40 00 0f 47 call 201bcc0 <_Thread_Enable_dispatch>
2017fa8: 81 e8 00 00 restore
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
2017fac: 7f ff dd d3 call 200f6f8 <sparc_disable_interrupts>
2017fb0: 01 00 00 00 nop
2017fb4: b8 10 00 08 mov %o0, %i4
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
2017fb8: 03 00 80 f2 sethi %hi(0x203c800), %g1
2017fbc: d0 18 60 78 ldd [ %g1 + 0x78 ], %o0 ! 203c878 <_TOD>
2017fc0: 94 10 20 00 clr %o2
2017fc4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2017fc8: 40 00 51 ad call 202c67c <__divdi3>
2017fcc: 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;
2017fd0: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
2017fd4: c4 06 20 74 ld [ %i0 + 0x74 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2017fd8: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
2017fdc: 80 a0 40 03 cmp %g1, %g3
2017fe0: 02 80 00 0a be 2018008 <_Timer_server_Schedule_operation_method+0xac>
2017fe4: 80 a2 40 02 cmp %o1, %g2
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
2017fe8: 08 80 00 34 bleu 20180b8 <_Timer_server_Schedule_operation_method+0x15c>
2017fec: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
2017ff0: 84 22 40 02 sub %o1, %g2, %g2
if (delta_interval > delta) {
2017ff4: 80 a1 00 02 cmp %g4, %g2
2017ff8: 08 80 00 03 bleu 2018004 <_Timer_server_Schedule_operation_method+0xa8><== NEVER TAKEN
2017ffc: 86 10 20 00 clr %g3
delta_interval -= delta;
2018000: 86 21 00 02 sub %g4, %g2, %g3
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
2018004: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
2018008: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
201800c: 7f ff dd bf call 200f708 <sparc_enable_interrupts>
2018010: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018014: 90 06 20 68 add %i0, 0x68, %o0
2018018: 40 00 12 fe call 201cc10 <_Watchdog_Insert>
201801c: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018020: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018024: 80 a0 60 00 cmp %g1, 0
2018028: 12 bf ff df bne 2017fa4 <_Timer_server_Schedule_operation_method+0x48>
201802c: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
2018030: 7f ff ff b7 call 2017f0c <_Timer_server_Reset_tod_system_watchdog>
2018034: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
2018038: 40 00 0f 22 call 201bcc0 <_Thread_Enable_dispatch>
201803c: 81 e8 00 00 restore
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
2018040: 7f ff dd ae call 200f6f8 <sparc_disable_interrupts>
2018044: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
2018048: 05 00 80 f2 sethi %hi(0x203c800), %g2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
201804c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
2018050: c4 00 a2 1c ld [ %g2 + 0x21c ], %g2
last_snapshot = ts->Interval_watchdogs.last_snapshot;
2018054: 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 );
2018058: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
201805c: 80 a0 40 03 cmp %g1, %g3
2018060: 02 80 00 08 be 2018080 <_Timer_server_Schedule_operation_method+0x124>
2018064: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
2018068: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
201806c: 80 a1 00 1c cmp %g4, %i4
2018070: 1a 80 00 03 bcc 201807c <_Timer_server_Schedule_operation_method+0x120>
2018074: 86 10 20 00 clr %g3
delta_interval -= delta;
2018078: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
201807c: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
2018080: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
2018084: 7f ff dd a1 call 200f708 <sparc_enable_interrupts>
2018088: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
201808c: 90 06 20 30 add %i0, 0x30, %o0
2018090: 40 00 12 e0 call 201cc10 <_Watchdog_Insert>
2018094: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018098: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
201809c: 80 a0 60 00 cmp %g1, 0
20180a0: 12 bf ff c1 bne 2017fa4 <_Timer_server_Schedule_operation_method+0x48>
20180a4: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
20180a8: 7f ff ff 85 call 2017ebc <_Timer_server_Reset_interval_system_watchdog>
20180ac: 90 10 00 18 mov %i0, %o0
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
20180b0: 40 00 0f 04 call 201bcc0 <_Thread_Enable_dispatch>
20180b4: 81 e8 00 00 restore
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
20180b8: 84 01 00 02 add %g4, %g2, %g2
delta_interval += delta;
20180bc: 10 bf ff d2 b 2018004 <_Timer_server_Schedule_operation_method+0xa8>
20180c0: 86 20 80 09 sub %g2, %o1, %g3
0200d0d8 <_Timespec_Add_to>:
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
200d0d8: d8 02 00 00 ld [ %o0 ], %o4
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
200d0dc: c4 02 40 00 ld [ %o1 ], %g2
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
200d0e0: c6 02 20 04 ld [ %o0 + 4 ], %g3
200d0e4: c2 02 60 04 ld [ %o1 + 4 ], %g1
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
200d0e8: 98 03 00 02 add %o4, %g2, %o4
time->tv_nsec += add->tv_nsec;
200d0ec: 82 00 c0 01 add %g3, %g1, %g1
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
200d0f0: d8 22 00 00 st %o4, [ %o0 ]
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
200d0f4: 09 0e e6 b2 sethi %hi(0x3b9ac800), %g4
200d0f8: 88 11 21 ff or %g4, 0x1ff, %g4 ! 3b9ac9ff <RAM_END+0x395ac9ff>
200d0fc: 80 a0 40 04 cmp %g1, %g4
200d100: 08 80 00 0d bleu 200d134 <_Timespec_Add_to+0x5c>
200d104: c2 22 20 04 st %g1, [ %o0 + 4 ]
200d108: 98 03 20 01 inc %o4
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
200d10c: 1b 31 19 4d sethi %hi(0xc4653400), %o5
#include <sys/types.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
uint32_t _Timespec_Add_to(
200d110: 98 23 00 02 sub %o4, %g2, %o4
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 ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
200d114: 9a 13 62 00 or %o5, 0x200, %o5
200d118: 82 00 40 0d add %g1, %o5, %g1
#include <sys/types.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
uint32_t _Timespec_Add_to(
200d11c: 86 03 00 02 add %o4, %g2, %g3
/* 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 ) {
200d120: 80 a0 40 04 cmp %g1, %g4
200d124: 18 bf ff fd bgu 200d118 <_Timespec_Add_to+0x40> <== NEVER TAKEN
200d128: 84 00 a0 01 inc %g2
200d12c: c2 22 20 04 st %g1, [ %o0 + 4 ]
200d130: c6 22 00 00 st %g3, [ %o0 ]
time->tv_sec++;
seconds++;
}
return seconds;
}
200d134: 81 c3 e0 08 retl
200d138: 90 10 00 02 mov %g2, %o0
0200cb38 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
200cb38: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
200cb3c: d4 1e 40 00 ldd [ %i1 ], %o2
200cb40: 80 92 80 0b orcc %o2, %o3, %g0
200cb44: 22 80 00 2f be,a 200cc00 <_Timestamp64_Divide+0xc8> <== NEVER TAKEN
200cb48: c0 26 80 00 clr [ %i2 ] <== 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;
200cb4c: e0 1e 00 00 ldd [ %i0 ], %l0
200cb50: 83 2c 20 02 sll %l0, 2, %g1
200cb54: 89 34 60 1e srl %l1, 0x1e, %g4
200cb58: 87 2c 60 02 sll %l1, 2, %g3
200cb5c: 84 11 00 01 or %g4, %g1, %g2
200cb60: 83 30 e0 1b srl %g3, 0x1b, %g1
200cb64: 9b 28 e0 05 sll %g3, 5, %o5
200cb68: 99 28 a0 05 sll %g2, 5, %o4
200cb6c: 86 a3 40 03 subcc %o5, %g3, %g3
200cb70: 98 10 40 0c or %g1, %o4, %o4
200cb74: 84 63 00 02 subx %o4, %g2, %g2
200cb78: 92 80 c0 11 addcc %g3, %l1, %o1
200cb7c: 83 32 60 1e srl %o1, 0x1e, %g1
200cb80: 90 40 80 10 addx %g2, %l0, %o0
200cb84: b3 2a 60 02 sll %o1, 2, %i1
200cb88: b1 2a 20 02 sll %o0, 2, %i0
200cb8c: 86 82 40 19 addcc %o1, %i1, %g3
200cb90: b0 10 40 18 or %g1, %i0, %i0
200cb94: 83 30 e0 1e srl %g3, 0x1e, %g1
200cb98: 84 42 00 18 addx %o0, %i0, %g2
200cb9c: bb 28 e0 02 sll %g3, 2, %i5
200cba0: b9 28 a0 02 sll %g2, 2, %i4
200cba4: 92 80 c0 1d addcc %g3, %i5, %o1
200cba8: b8 10 40 1c or %g1, %i4, %i4
200cbac: 87 32 60 1b srl %o1, 0x1b, %g3
200cbb0: 90 40 80 1c addx %g2, %i4, %o0
200cbb4: 83 2a 60 05 sll %o1, 5, %g1
200cbb8: 85 2a 20 05 sll %o0, 5, %g2
200cbbc: 92 10 00 01 mov %g1, %o1
200cbc0: 40 00 3b 46 call 201b8d8 <__divdi3>
200cbc4: 90 10 c0 02 or %g3, %g2, %o0
*_ival_percentage = answer / 1000;
200cbc8: 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;
200cbcc: b8 10 00 08 mov %o0, %i4
200cbd0: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
200cbd4: 40 00 3b 41 call 201b8d8 <__divdi3>
200cbd8: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
200cbdc: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
200cbe0: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
200cbe4: 94 10 20 00 clr %o2
200cbe8: 96 10 23 e8 mov 0x3e8, %o3
200cbec: 40 00 3c 26 call 201bc84 <__moddi3>
200cbf0: 92 10 00 1d mov %i5, %o1
200cbf4: d2 26 c0 00 st %o1, [ %i3 ]
200cbf8: 81 c7 e0 08 ret
200cbfc: 81 e8 00 00 restore
{
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
*_ival_percentage = 0;
*_fval_percentage = 0;
200cc00: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
200cc04: 81 c7 e0 08 ret <== NOT EXECUTED
200cc08: 81 e8 00 00 restore <== NOT EXECUTED
0200b480 <_User_extensions_Handler_initialization>:
}
}
void _User_extensions_Handler_initialization(void)
{
200b480: 9d e3 bf 98 save %sp, -104, %sp
uint32_t number_of_initial_extensions =
200b484: 03 00 80 6d sethi %hi(0x201b400), %g1
200b488: c2 00 61 08 ld [ %g1 + 0x108 ], %g1 ! 201b508 <Configuration+0x40>
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
200b48c: 80 a0 60 00 cmp %g1, 0
200b490: 02 80 00 0a be 200b4b8 <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
200b494: 91 28 60 02 sll %g1, 2, %o0
User_extensions_Switch_control *initial_extension_switch_controls =
_Workspace_Allocate_or_fatal_error(
number_of_initial_extensions
* sizeof( *initial_extension_switch_controls )
200b498: 83 28 60 04 sll %g1, 4, %g1
{
uint32_t number_of_initial_extensions =
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
User_extensions_Switch_control *initial_extension_switch_controls =
200b49c: 40 00 01 2c call 200b94c <_Workspace_Allocate_or_fatal_error>
200b4a0: 90 20 40 08 sub %g1, %o0, %o0
number_of_initial_extensions
* sizeof( *initial_extension_switch_controls )
);
User_extensions_Switch_context ctx = { initial_extension_switch_controls };
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
200b4a4: 13 00 80 2d sethi %hi(0x200b400), %o1
User_extensions_Switch_control *initial_extension_switch_controls =
_Workspace_Allocate_or_fatal_error(
number_of_initial_extensions
* sizeof( *initial_extension_switch_controls )
);
User_extensions_Switch_context ctx = { initial_extension_switch_controls };
200b4a8: d0 27 bf fc st %o0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
200b4ac: 92 12 60 3c or %o1, 0x3c, %o1
200b4b0: 7f ff ff c0 call 200b3b0 <_User_extensions_Iterate>
200b4b4: 90 07 bf fc add %fp, -4, %o0
200b4b8: 81 c7 e0 08 ret
200b4bc: 81 e8 00 00 restore
0200b3b0 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
200b3b0: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing = _Thread_Executing;
const User_extensions_Table *callouts_current =
200b3b4: 03 00 80 6d sethi %hi(0x201b400), %g1
200b3b8: 82 10 60 c8 or %g1, 0xc8, %g1 ! 201b4c8 <Configuration>
200b3bc: fa 00 60 44 ld [ %g1 + 0x44 ], %i5
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
200b3c0: f6 00 60 40 ld [ %g1 + 0x40 ], %i3
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
Thread_Control *executing = _Thread_Executing;
200b3c4: 03 00 80 7a sethi %hi(0x201e800), %g1
const User_extensions_Table *callouts_current =
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
200b3c8: b7 2e e0 05 sll %i3, 5, %i3
)
{
Thread_Control *executing = _Thread_Executing;
const User_extensions_Table *callouts_current =
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
200b3cc: b6 07 40 1b add %i5, %i3, %i3
callouts_current + rtems_configuration_get_number_of_initial_extensions();
const Chain_Node *node;
const Chain_Node *tail;
while ( callouts_current != callouts_end ) {
200b3d0: 80 a7 40 1b cmp %i5, %i3
200b3d4: 02 80 00 0a be 200b3fc <_User_extensions_Iterate+0x4c> <== NEVER TAKEN
200b3d8: f8 00 60 50 ld [ %g1 + 0x50 ], %i4
(*visitor)( executing, arg, callouts_current );
200b3dc: 94 10 00 1d mov %i5, %o2
200b3e0: 90 10 00 1c mov %i4, %o0
200b3e4: 9f c6 40 00 call %i1
200b3e8: 92 10 00 18 mov %i0, %o1
++callouts_current;
200b3ec: ba 07 60 20 add %i5, 0x20, %i5
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
const Chain_Node *node;
const Chain_Node *tail;
while ( callouts_current != callouts_end ) {
200b3f0: 80 a6 c0 1d cmp %i3, %i5
200b3f4: 12 bf ff fb bne 200b3e0 <_User_extensions_Iterate+0x30>
200b3f8: 94 10 00 1d mov %i5, %o2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200b3fc: 37 00 80 76 sethi %hi(0x201d800), %i3
200b400: fa 06 e0 cc ld [ %i3 + 0xcc ], %i5 ! 201d8cc <_User_extensions_List>
200b404: b6 16 e0 cc or %i3, 0xcc, %i3
++callouts_current;
}
node = _Chain_Immutable_first( &_User_extensions_List );
tail = _Chain_Immutable_tail( &_User_extensions_List );
while ( node != tail ) {
200b408: b6 06 e0 04 add %i3, 4, %i3
200b40c: 80 a7 40 1b cmp %i5, %i3
200b410: 02 80 00 09 be 200b434 <_User_extensions_Iterate+0x84>
200b414: 94 07 60 14 add %i5, 0x14, %o2
const User_extensions_Control *extension =
(const User_extensions_Control *) node;
(*visitor)( executing, arg, &extension->Callouts );
200b418: 90 10 00 1c mov %i4, %o0
200b41c: 9f c6 40 00 call %i1
200b420: 92 10 00 18 mov %i0, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
200b424: fa 07 40 00 ld [ %i5 ], %i5
++callouts_current;
}
node = _Chain_Immutable_first( &_User_extensions_List );
tail = _Chain_Immutable_tail( &_User_extensions_List );
while ( node != tail ) {
200b428: 80 a7 40 1b cmp %i5, %i3
200b42c: 12 bf ff fb bne 200b418 <_User_extensions_Iterate+0x68>
200b430: 94 07 60 14 add %i5, 0x14, %o2
200b434: 81 c7 e0 08 ret
200b438: 81 e8 00 00 restore
0200ce84 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
200ce84: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
200ce88: 7f ff d9 2f call 2003344 <sparc_disable_interrupts>
200ce8c: 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;
200ce90: 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 );
200ce94: 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 ) ) {
200ce98: 80 a0 40 1c cmp %g1, %i4
200ce9c: 02 80 00 1f be 200cf18 <_Watchdog_Adjust+0x94>
200cea0: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
200cea4: 12 80 00 1f bne 200cf20 <_Watchdog_Adjust+0x9c>
200cea8: 80 a6 60 01 cmp %i1, 1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200ceac: 80 a6 a0 00 cmp %i2, 0
200ceb0: 02 80 00 1a be 200cf18 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
200ceb4: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
200ceb8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200cebc: 80 a6 80 02 cmp %i2, %g2
200cec0: 1a 80 00 0a bcc 200cee8 <_Watchdog_Adjust+0x64> <== ALWAYS TAKEN
200cec4: b6 10 20 01 mov 1, %i3
_Watchdog_First( header )->delta_interval -= units;
200cec8: 10 80 00 1d b 200cf3c <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
200cecc: 84 20 80 1a sub %g2, %i2, %g2 <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200ced0: 02 80 00 12 be 200cf18 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
200ced4: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
200ced8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200cedc: 80 a0 80 1a cmp %g2, %i2
200cee0: 38 80 00 17 bgu,a 200cf3c <_Watchdog_Adjust+0xb8>
200cee4: 84 20 80 1a sub %g2, %i2, %g2
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
200cee8: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
200ceec: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
200cef0: 7f ff d9 19 call 2003354 <sparc_enable_interrupts>
200cef4: 01 00 00 00 nop
_Watchdog_Tickle( header );
200cef8: 40 00 00 a8 call 200d198 <_Watchdog_Tickle>
200cefc: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
200cf00: 7f ff d9 11 call 2003344 <sparc_disable_interrupts>
200cf04: 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;
200cf08: c2 06 00 00 ld [ %i0 ], %g1
if ( _Chain_Is_empty( header ) )
200cf0c: 80 a7 00 01 cmp %i4, %g1
200cf10: 12 bf ff f0 bne 200ced0 <_Watchdog_Adjust+0x4c>
200cf14: 80 a6 a0 00 cmp %i2, 0
}
break;
}
}
_ISR_Enable( level );
200cf18: 7f ff d9 0f call 2003354 <sparc_enable_interrupts>
200cf1c: 91 e8 00 08 restore %g0, %o0, %o0
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
200cf20: 12 bf ff fe bne 200cf18 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
200cf24: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
200cf28: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200cf2c: b4 00 80 1a add %g2, %i2, %i2
200cf30: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
}
break;
}
}
_ISR_Enable( level );
200cf34: 7f ff d9 08 call 2003354 <sparc_enable_interrupts>
200cf38: 91 e8 00 08 restore %g0, %o0, %o0
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
200cf3c: 10 bf ff f7 b 200cf18 <_Watchdog_Adjust+0x94>
200cf40: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
0201cb60 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
201cb60: 9d e3 bf a0 save %sp, -96, %sp
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
_ISR_Disable( level );
201cb64: 7f ff ca e5 call 200f6f8 <sparc_disable_interrupts>
201cb68: 01 00 00 00 nop
201cb6c: c2 06 00 00 ld [ %i0 ], %g1
201cb70: ba 06 20 04 add %i0, 4, %i5
201cb74: b8 06 a0 04 add %i2, 4, %i4
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
201cb78: 80 a7 40 01 cmp %i5, %g1
201cb7c: 02 80 00 20 be 201cbfc <_Watchdog_Adjust_to_chain+0x9c>
201cb80: 01 00 00 00 nop
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
201cb84: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
201cb88: 80 a6 40 02 cmp %i1, %g2
201cb8c: 2a 80 00 1e bcs,a 201cc04 <_Watchdog_Adjust_to_chain+0xa4>
201cb90: 84 20 80 19 sub %g2, %i1, %g2
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
201cb94: b2 26 40 02 sub %i1, %g2, %i1
first->delta_interval = 0;
201cb98: c0 20 60 10 clr [ %g1 + 0x10 ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
201cb9c: c4 00 60 04 ld [ %g1 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
201cba0: c6 00 40 00 ld [ %g1 ], %g3
previous = the_node->previous;
next->previous = previous;
201cba4: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
201cba8: c6 20 80 00 st %g3, [ %g2 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
201cbac: c4 06 a0 08 ld [ %i2 + 8 ], %g2
the_node->next = tail;
201cbb0: f8 20 40 00 st %i4, [ %g1 ]
tail->previous = the_node;
201cbb4: c2 26 a0 08 st %g1, [ %i2 + 8 ]
old_last->next = the_node;
201cbb8: c2 20 80 00 st %g1, [ %g2 ]
the_node->previous = old_last;
201cbbc: c4 20 60 04 st %g2, [ %g1 + 4 ]
while ( 1 ) {
_Chain_Extract_unprotected( &first->Node );
_Chain_Append_unprotected( to_fire, &first->Node );
_ISR_Flash( level );
201cbc0: 7f ff ca d2 call 200f708 <sparc_enable_interrupts>
201cbc4: 01 00 00 00 nop
201cbc8: 7f ff ca cc call 200f6f8 <sparc_disable_interrupts>
201cbcc: 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;
201cbd0: c2 06 00 00 ld [ %i0 ], %g1
if ( _Chain_Is_empty( header ) )
201cbd4: 80 a7 40 01 cmp %i5, %g1
201cbd8: 02 bf ff e9 be 201cb7c <_Watchdog_Adjust_to_chain+0x1c>
201cbdc: 01 00 00 00 nop
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
201cbe0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
201cbe4: 80 a0 a0 00 cmp %g2, 0
201cbe8: 22 bf ff ee be,a 201cba0 <_Watchdog_Adjust_to_chain+0x40>
201cbec: c4 00 60 04 ld [ %g1 + 4 ], %g2
Watchdog_Control *first;
_ISR_Disable( level );
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
201cbf0: 80 a7 40 01 cmp %i5, %g1
201cbf4: 12 bf ff e6 bne 201cb8c <_Watchdog_Adjust_to_chain+0x2c> <== ALWAYS TAKEN
201cbf8: 80 a6 40 02 cmp %i1, %g2
if ( first->delta_interval != 0 )
break;
}
}
_ISR_Enable( level );
201cbfc: 7f ff ca c3 call 200f708 <sparc_enable_interrupts>
201cc00: 91 e8 00 08 restore %g0, %o0, %o0
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
first->delta_interval -= units;
201cc04: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( first->delta_interval != 0 )
break;
}
}
_ISR_Enable( level );
201cc08: 7f ff ca c0 call 200f708 <sparc_enable_interrupts>
201cc0c: 91 e8 00 08 restore %g0, %o0, %o0
0200b63c <_Watchdog_Remove>:
#include <rtems/score/watchdog.h>
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
200b63c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
200b640: 7f ff db f3 call 200260c <sparc_disable_interrupts>
200b644: 01 00 00 00 nop
previous_state = the_watchdog->state;
200b648: fa 06 20 08 ld [ %i0 + 8 ], %i5
switch ( previous_state ) {
200b64c: 80 a7 60 01 cmp %i5, 1
200b650: 02 80 00 2a be 200b6f8 <_Watchdog_Remove+0xbc>
200b654: 03 00 80 79 sethi %hi(0x201e400), %g1
200b658: 1a 80 00 09 bcc 200b67c <_Watchdog_Remove+0x40>
200b65c: 80 a7 60 03 cmp %i5, 3
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200b660: 03 00 80 79 sethi %hi(0x201e400), %g1
200b664: c2 00 60 0c ld [ %g1 + 0xc ], %g1 ! 201e40c <_Watchdog_Ticks_since_boot>
200b668: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
200b66c: 7f ff db ec call 200261c <sparc_enable_interrupts>
200b670: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
200b674: 81 c7 e0 08 ret
200b678: 81 e8 00 00 restore
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
200b67c: 18 bf ff fa bgu 200b664 <_Watchdog_Remove+0x28> <== NEVER TAKEN
200b680: 03 00 80 79 sethi %hi(0x201e400), %g1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
200b684: c2 06 00 00 ld [ %i0 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
200b688: c0 26 20 08 clr [ %i0 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
200b68c: c4 00 40 00 ld [ %g1 ], %g2
200b690: 80 a0 a0 00 cmp %g2, 0
200b694: 02 80 00 07 be 200b6b0 <_Watchdog_Remove+0x74>
200b698: 05 00 80 79 sethi %hi(0x201e400), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
200b69c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200b6a0: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
200b6a4: 84 00 c0 02 add %g3, %g2, %g2
200b6a8: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
200b6ac: 05 00 80 79 sethi %hi(0x201e400), %g2
200b6b0: c4 00 a0 08 ld [ %g2 + 8 ], %g2 ! 201e408 <_Watchdog_Sync_count>
200b6b4: 80 a0 a0 00 cmp %g2, 0
200b6b8: 22 80 00 07 be,a 200b6d4 <_Watchdog_Remove+0x98>
200b6bc: c4 06 20 04 ld [ %i0 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
200b6c0: 05 00 80 7a sethi %hi(0x201e800), %g2
200b6c4: c6 00 a0 48 ld [ %g2 + 0x48 ], %g3 ! 201e848 <_Per_CPU_Information+0x8>
200b6c8: 05 00 80 78 sethi %hi(0x201e000), %g2
200b6cc: c6 20 a3 a8 st %g3, [ %g2 + 0x3a8 ] ! 201e3a8 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200b6d0: c4 06 20 04 ld [ %i0 + 4 ], %g2
next->previous = previous;
200b6d4: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
200b6d8: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200b6dc: 03 00 80 79 sethi %hi(0x201e400), %g1
200b6e0: c2 00 60 0c ld [ %g1 + 0xc ], %g1 ! 201e40c <_Watchdog_Ticks_since_boot>
200b6e4: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
200b6e8: 7f ff db cd call 200261c <sparc_enable_interrupts>
200b6ec: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
200b6f0: 81 c7 e0 08 ret
200b6f4: 81 e8 00 00 restore
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200b6f8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
200b6fc: c0 26 20 08 clr [ %i0 + 8 ]
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200b700: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
200b704: 7f ff db c6 call 200261c <sparc_enable_interrupts>
200b708: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
200b70c: 81 c7 e0 08 ret
200b710: 81 e8 00 00 restore
0200c8c4 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
200c8c4: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
200c8c8: 7f ff d9 9d call 2002f3c <sparc_disable_interrupts>
200c8cc: 01 00 00 00 nop
200c8d0: b6 10 00 08 mov %o0, %i3
printk( "Watchdog Chain: %s %p\n", name, header );
200c8d4: 11 00 80 78 sethi %hi(0x201e000), %o0
200c8d8: 94 10 00 19 mov %i1, %o2
200c8dc: 92 10 00 18 mov %i0, %o1
200c8e0: 7f ff e1 52 call 2004e28 <printk>
200c8e4: 90 12 21 f8 or %o0, 0x1f8, %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200c8e8: fa 06 40 00 ld [ %i1 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200c8ec: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
200c8f0: 80 a7 40 19 cmp %i5, %i1
200c8f4: 02 80 00 0f be 200c930 <_Watchdog_Report_chain+0x6c>
200c8f8: 11 00 80 78 sethi %hi(0x201e000), %o0
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
200c8fc: 92 10 00 1d mov %i5, %o1
200c900: 40 00 00 0f call 200c93c <_Watchdog_Report>
200c904: 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 )
200c908: fa 07 40 00 ld [ %i5 ], %i5
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
200c90c: 80 a7 40 19 cmp %i5, %i1
200c910: 12 bf ff fc bne 200c900 <_Watchdog_Report_chain+0x3c> <== NEVER TAKEN
200c914: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
200c918: 11 00 80 78 sethi %hi(0x201e000), %o0
200c91c: 92 10 00 18 mov %i0, %o1
200c920: 7f ff e1 42 call 2004e28 <printk>
200c924: 90 12 22 10 or %o0, 0x210, %o0
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
200c928: 7f ff d9 89 call 2002f4c <sparc_enable_interrupts>
200c92c: 91 e8 00 1b restore %g0, %i3, %o0
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
200c930: 7f ff e1 3e call 2004e28 <printk>
200c934: 90 12 22 20 or %o0, 0x220, %o0
200c938: 30 bf ff fc b,a 200c928 <_Watchdog_Report_chain+0x64>
0200b714 <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
200b714: 9d e3 bf a0 save %sp, -96, %sp
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
200b718: 7f ff db bd call 200260c <sparc_disable_interrupts>
200b71c: 01 00 00 00 nop
200b720: b8 10 00 08 mov %o0, %i4
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200b724: 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 );
200b728: b4 06 20 04 add %i0, 4, %i2
if ( _Chain_Is_empty( header ) )
200b72c: 80 a7 40 1a cmp %i5, %i2
200b730: 02 80 00 09 be 200b754 <_Watchdog_Tickle+0x40>
200b734: 01 00 00 00 nop
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
200b738: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200b73c: 80 a0 60 00 cmp %g1, 0
200b740: 02 80 00 15 be 200b794 <_Watchdog_Tickle+0x80> <== NEVER TAKEN
200b744: 82 00 7f ff add %g1, -1, %g1
the_watchdog->delta_interval--;
if ( the_watchdog->delta_interval != 0 )
200b748: 80 a0 60 00 cmp %g1, 0
200b74c: 02 80 00 12 be 200b794 <_Watchdog_Tickle+0x80>
200b750: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
200b754: 7f ff db b2 call 200261c <sparc_enable_interrupts>
200b758: 91 e8 00 1c restore %g0, %i4, %o0
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
200b75c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200b760: 9f c0 40 00 call %g1
200b764: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
200b768: 7f ff db a9 call 200260c <sparc_disable_interrupts>
200b76c: 01 00 00 00 nop
200b770: b8 10 00 08 mov %o0, %i4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200b774: fa 06 00 00 ld [ %i0 ], %i5
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
200b778: 80 a6 80 1d cmp %i2, %i5
200b77c: 02 bf ff f6 be 200b754 <_Watchdog_Tickle+0x40>
200b780: 01 00 00 00 nop
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
200b784: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200b788: 80 a0 60 00 cmp %g1, 0
200b78c: 12 bf ff f2 bne 200b754 <_Watchdog_Tickle+0x40>
200b790: 01 00 00 00 nop
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
200b794: 7f ff ff aa call 200b63c <_Watchdog_Remove>
200b798: 90 10 00 1d mov %i5, %o0
200b79c: b6 10 00 08 mov %o0, %i3
_ISR_Enable( level );
200b7a0: 7f ff db 9f call 200261c <sparc_enable_interrupts>
200b7a4: 90 10 00 1c mov %i4, %o0
switch( watchdog_state ) {
200b7a8: 80 a6 e0 02 cmp %i3, 2
200b7ac: 12 bf ff ef bne 200b768 <_Watchdog_Tickle+0x54>
200b7b0: 01 00 00 00 nop
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
200b7b4: 10 bf ff ea b 200b75c <_Watchdog_Tickle+0x48>
200b7b8: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
0200b7bc <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
200b7bc: 9d e3 bf 98 save %sp, -104, %sp
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
200b7c0: 05 00 80 6d sethi %hi(0x201b400), %g2
200b7c4: 82 10 a0 c8 or %g2, 0xc8, %g1 ! 201b4c8 <Configuration>
200b7c8: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
200b7cc: f6 00 a0 c8 ld [ %g2 + 0xc8 ], %i3
200b7d0: 80 a0 e0 00 cmp %g3, 0
200b7d4: 12 80 00 03 bne 200b7e0 <_Workspace_Handler_initialization+0x24>
200b7d8: 84 10 20 00 clr %g2
200b7dc: c4 00 60 04 ld [ %g1 + 4 ], %g2
200b7e0: b6 00 80 1b add %g2, %i3, %i3
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
200b7e4: c4 08 60 30 ldub [ %g1 + 0x30 ], %g2
bool unified = rtems_configuration_get_unified_work_area();
200b7e8: c2 08 60 31 ldub [ %g1 + 0x31 ], %g1
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
200b7ec: c4 2f bf ff stb %g2, [ %fp + -1 ]
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
200b7f0: 80 a6 60 00 cmp %i1, 0
200b7f4: 02 80 00 3c be 200b8e4 <_Workspace_Handler_initialization+0x128><== NEVER TAKEN
200b7f8: c2 2f bf fe stb %g1, [ %fp + -2 ]
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
200b7fc: 23 00 80 23 sethi %hi(0x2008c00), %l1
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
200b800: 27 00 80 78 sethi %hi(0x201e000), %l3
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
200b804: b8 10 20 00 clr %i4
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
200b808: a2 14 62 6c or %l1, 0x26c, %l1
200b80c: a0 08 a0 ff and %g2, 0xff, %l0
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
200b810: a4 08 60 ff and %g1, 0xff, %l2
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
200b814: 10 80 00 22 b 200b89c <_Workspace_Handler_initialization+0xe0>
200b818: a6 14 e3 30 or %l3, 0x330, %l3
if ( do_zero ) {
memset( area->begin, 0, area->size );
}
if ( area->size > overhead ) {
200b81c: 80 a7 60 16 cmp %i5, 0x16
200b820: 28 80 00 1c bleu,a 200b890 <_Workspace_Handler_initialization+0xd4>
200b824: b8 07 20 01 inc %i4
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
200b828: 80 a4 a0 00 cmp %l2, 0
200b82c: 32 80 00 0a bne,a 200b854 <_Workspace_Handler_initialization+0x98>
200b830: d2 06 00 00 ld [ %i0 ], %o1
size = area->size;
} else {
if ( remaining > 0 ) {
200b834: 80 a6 e0 00 cmp %i3, 0
200b838: 22 80 00 22 be,a 200b8c0 <_Workspace_Handler_initialization+0x104><== NEVER TAKEN
200b83c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
size = remaining < area->size - overhead ?
200b840: 82 07 7f ea add %i5, -22, %g1
remaining + overhead : area->size;
200b844: 80 a0 40 1b cmp %g1, %i3
200b848: 38 80 00 02 bgu,a 200b850 <_Workspace_Handler_initialization+0x94><== ALWAYS TAKEN
200b84c: ba 06 e0 16 add %i3, 0x16, %i5
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
200b850: d2 06 00 00 ld [ %i0 ], %o1
200b854: 94 10 00 1d mov %i5, %o2
200b858: 90 10 00 13 mov %l3, %o0
200b85c: 9f c4 40 00 call %l1
200b860: 96 10 20 08 mov 8, %o3
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
200b864: c2 06 00 00 ld [ %i0 ], %g1
area->size -= size;
200b868: c4 06 20 04 ld [ %i0 + 4 ], %g2
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
200b86c: 82 00 40 1d add %g1, %i5, %g1
area->size -= size;
200b870: ba 20 80 1d sub %g2, %i5, %i5
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
200b874: c2 26 00 00 st %g1, [ %i0 ]
area->size -= size;
if ( space_available < remaining ) {
200b878: 80 a2 00 1b cmp %o0, %i3
200b87c: 1a 80 00 1f bcc 200b8f8 <_Workspace_Handler_initialization+0x13c><== ALWAYS TAKEN
200b880: fa 26 20 04 st %i5, [ %i0 + 4 ]
remaining -= space_available;
200b884: b6 26 c0 08 sub %i3, %o0, %i3 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
200b888: a2 10 00 1a mov %i2, %l1 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
200b88c: b8 07 20 01 inc %i4
200b890: 80 a7 00 19 cmp %i4, %i1
200b894: 02 80 00 14 be 200b8e4 <_Workspace_Handler_initialization+0x128><== ALWAYS TAKEN
200b898: b0 06 20 08 add %i0, 8, %i0
Heap_Area *area = &areas [i];
if ( do_zero ) {
200b89c: 80 a4 20 00 cmp %l0, 0
200b8a0: 22 bf ff df be,a 200b81c <_Workspace_Handler_initialization+0x60>
200b8a4: fa 06 20 04 ld [ %i0 + 4 ], %i5
memset( area->begin, 0, area->size );
200b8a8: d0 06 00 00 ld [ %i0 ], %o0
200b8ac: d4 06 20 04 ld [ %i0 + 4 ], %o2
200b8b0: 40 00 15 58 call 2010e10 <memset>
200b8b4: 92 10 20 00 clr %o1
}
if ( area->size > overhead ) {
200b8b8: 10 bf ff d9 b 200b81c <_Workspace_Handler_initialization+0x60>
200b8bc: fa 06 20 04 ld [ %i0 + 4 ], %i5
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
200b8c0: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
200b8c4: 94 10 20 00 clr %o2 <== NOT EXECUTED
200b8c8: 9f c4 40 00 call %l1 <== NOT EXECUTED
200b8cc: 96 10 20 08 mov 8, %o3 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
200b8d0: b8 07 20 01 inc %i4 <== NOT EXECUTED
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
200b8d4: a2 10 00 1a mov %i2, %l1 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
200b8d8: 80 a7 00 19 cmp %i4, %i1 <== NOT EXECUTED
200b8dc: 12 bf ff f0 bne 200b89c <_Workspace_Handler_initialization+0xe0><== NOT EXECUTED
200b8e0: b0 06 20 08 add %i0, 8, %i0 <== NOT EXECUTED
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
200b8e4: 80 a6 e0 00 cmp %i3, 0
200b8e8: 12 80 00 07 bne 200b904 <_Workspace_Handler_initialization+0x148>
200b8ec: 90 10 20 00 clr %o0
200b8f0: 81 c7 e0 08 ret
200b8f4: 81 e8 00 00 restore
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
200b8f8: a2 10 00 1a mov %i2, %l1
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
} else {
remaining = 0;
200b8fc: 10 bf ff e4 b 200b88c <_Workspace_Handler_initialization+0xd0>
200b900: b6 10 20 00 clr %i3
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
_Internal_error_Occurred(
200b904: 92 10 20 01 mov 1, %o1
200b908: 7f ff f5 f6 call 20090e0 <_Internal_error_Occurred>
200b90c: 94 10 20 02 mov 2, %o2
0201405c <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
201405c: 9d e3 bf 98 save %sp, -104, %sp
2014060: a0 10 00 18 mov %i0, %l0
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
2014064: 80 a6 e0 00 cmp %i3, 0
2014068: 12 80 00 11 bne 20140ac <_fat_block_read+0x50> <== ALWAYS TAKEN
201406c: b0 10 20 00 clr %i0
2014070: 30 80 00 19 b,a 20140d4 <_fat_block_read+0x78> <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
2014074: fa 14 00 00 lduh [ %l0 ], %i5
memcpy((buff + cmpltd), (sec_buf + ofs), c);
2014078: d2 07 bf fc ld [ %fp + -4 ], %o1
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
201407c: ba 27 40 1a sub %i5, %i2, %i5
2014080: 80 a7 40 1b cmp %i5, %i3
2014084: 08 80 00 03 bleu 2014090 <_fat_block_read+0x34>
2014088: 92 02 40 1a add %o1, %i2, %o1
201408c: ba 10 00 1b mov %i3, %i5
memcpy((buff + cmpltd), (sec_buf + ofs), c);
2014090: 40 00 26 ce call 201dbc8 <memcpy>
2014094: 94 10 00 1d mov %i5, %o2
count -= c;
cmpltd += c;
2014098: b0 07 40 18 add %i5, %i0, %i0
sec_num++;
201409c: b2 06 60 01 inc %i1
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
20140a0: b6 a6 c0 1d subcc %i3, %i5, %i3
20140a4: 02 80 00 0c be 20140d4 <_fat_block_read+0x78>
20140a8: b4 10 20 00 clr %i2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
20140ac: 92 10 00 19 mov %i1, %o1
20140b0: 94 10 20 01 mov 1, %o2
20140b4: 96 07 bf fc add %fp, -4, %o3
20140b8: 7f ff ff bb call 2013fa4 <fat_buf_access>
20140bc: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
20140c0: 80 a2 20 00 cmp %o0, 0
20140c4: 02 bf ff ec be 2014074 <_fat_block_read+0x18> <== ALWAYS TAKEN
20140c8: 90 07 00 18 add %i4, %i0, %o0
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
20140cc: 81 c7 e0 08 ret <== NOT EXECUTED
20140d0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
20140d4: 81 c7 e0 08 ret
20140d8: 81 e8 00 00 restore
02003dd4 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2003dd4: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2003dd8: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2003ddc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2003de0: 7f ff ff e9 call 2003d84 <lstat> <== NOT EXECUTED
2003de4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
020046cc <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
20046cc: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
20046d0: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
20046d4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
20046d8: 7f ff ff e9 call 200467c <stat> <== NOT EXECUTED
20046dc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02007984 <adjtime>:
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
2007984: 9d e3 bf 98 save %sp, -104, %sp
long adjustment;
/*
* Simple validations
*/
if ( !delta )
2007988: 80 a6 20 00 cmp %i0, 0
200798c: 02 80 00 8e be 2007bc4 <adjtime+0x240>
2007990: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
2007994: c4 06 20 04 ld [ %i0 + 4 ], %g2
2007998: 03 00 03 d0 sethi %hi(0xf4000), %g1
200799c: 82 10 62 3f or %g1, 0x23f, %g1 ! f423f <PROM_START+0xf423f>
20079a0: 80 a0 80 01 cmp %g2, %g1
20079a4: 18 80 00 88 bgu 2007bc4 <adjtime+0x240>
20079a8: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
20079ac: 22 80 00 06 be,a 20079c4 <adjtime+0x40>
20079b0: c2 06 00 00 ld [ %i0 ], %g1
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
20079b4: c0 26 60 04 clr [ %i1 + 4 ]
20079b8: c4 06 20 04 ld [ %i0 + 4 ], %g2
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
olddelta->tv_sec = 0;
20079bc: c0 26 40 00 clr [ %i1 ]
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
20079c0: c2 06 00 00 ld [ %i0 ], %g1
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
20079c4: 07 00 80 77 sethi %hi(0x201dc00), %g3
20079c8: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 ! 201dc0c <Configuration+0xc>
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
20079cc: bb 28 60 08 sll %g1, 8, %i5
20079d0: 87 28 60 03 sll %g1, 3, %g3
20079d4: 86 27 40 03 sub %i5, %g3, %g3
20079d8: bb 28 e0 06 sll %g3, 6, %i5
20079dc: 86 27 40 03 sub %i5, %g3, %g3
20079e0: 82 00 c0 01 add %g3, %g1, %g1
20079e4: 83 28 60 06 sll %g1, 6, %g1
adjustment += delta->tv_usec;
20079e8: 84 00 40 02 add %g1, %g2, %g2
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
20079ec: 80 a0 80 04 cmp %g2, %g4
20079f0: 1a 80 00 05 bcc 2007a04 <adjtime+0x80>
20079f4: 03 00 80 83 sethi %hi(0x2020c00), %g1
return 0;
20079f8: 82 10 20 00 clr %g1
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
20079fc: 81 c7 e0 08 ret
2007a00: 91 e8 00 01 restore %g0, %g1, %o0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2007a04: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2
++level;
2007a08: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2007a0c: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ]
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
2007a10: 13 00 80 83 sethi %hi(0x2020c00), %o1
2007a14: 90 07 bf f8 add %fp, -8, %o0
2007a18: 40 00 07 2e call 20096d0 <_TOD_Get_with_nanoseconds>
2007a1c: 92 12 63 28 or %o1, 0x328, %o1
2007a20: f8 1a 00 00 ldd [ %o0 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007a24: 94 10 20 00 clr %o2
2007a28: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007a2c: 90 10 00 1c mov %i4, %o0
2007a30: 96 12 e2 00 or %o3, 0x200, %o3
2007a34: 40 00 51 5b call 201bfa0 <__divdi3>
2007a38: 92 10 00 1d mov %i5, %o1
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
2007a3c: f6 06 00 00 ld [ %i0 ], %i3
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007a40: 94 10 20 00 clr %o2
2007a44: b6 06 c0 09 add %i3, %o1, %i3
2007a48: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007a4c: 90 10 00 1c mov %i4, %o0
2007a50: 96 12 e2 00 or %o3, 0x200, %o3
2007a54: 40 00 52 3e call 201c34c <__moddi3>
2007a58: 92 10 00 1d mov %i5, %o1
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
2007a5c: c2 06 20 04 ld [ %i0 + 4 ], %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
2007a60: 09 31 19 4d sethi %hi(0xc4653400), %g4
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
2007a64: 87 28 60 07 sll %g1, 7, %g3
2007a68: 85 28 60 02 sll %g1, 2, %g2
2007a6c: 84 20 c0 02 sub %g3, %g2, %g2
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
2007a70: 88 11 22 00 or %g4, 0x200, %g4
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
2007a74: 82 00 80 01 add %g2, %g1, %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
2007a78: 07 0e e6 b2 sethi %hi(0x3b9ac800), %g3
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
2007a7c: 83 28 60 03 sll %g1, 3, %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
2007a80: 86 10 e1 ff or %g3, 0x1ff, %g3
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
2007a84: 92 02 40 01 add %o1, %g1, %o1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
2007a88: 80 a2 40 03 cmp %o1, %g3
2007a8c: 08 80 00 07 bleu 2007aa8 <adjtime+0x124>
2007a90: 84 06 e0 01 add %i3, 1, %g2
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
2007a94: 92 02 40 04 add %o1, %g4, %o1
ts.tv_sec++;
2007a98: b6 10 00 02 mov %g2, %i3
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
2007a9c: 80 a2 40 03 cmp %o1, %g3
2007aa0: 18 bf ff fd bgu 2007a94 <adjtime+0x110> <== NEVER TAKEN
2007aa4: 84 00 a0 01 inc %g2
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
2007aa8: 3b 0e e6 b2 sethi %hi(0x3b9ac800), %i5
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
2007aac: 07 31 19 4d sethi %hi(0xc4653400), %g3
2007ab0: 82 10 00 09 mov %o1, %g1
int _EXFUN(setitimer, (int __which, const struct itimerval *__value,
struct itimerval *__ovalue));
#if defined(__rtems__)
/* BSD function used by RTEMS code */
int _EXFUN(adjtime,(const struct timeval *, struct timeval *));
2007ab4: 84 06 ff ff add %i3, -1, %g2
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
2007ab8: ba 17 62 00 or %i5, 0x200, %i5
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
2007abc: 86 10 e2 00 or %g3, 0x200, %g3
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
2007ac0: 82 00 40 1d add %g1, %i5, %g1
ts.tv_sec--;
2007ac4: 88 10 00 02 mov %g2, %g4
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
2007ac8: 80 a0 40 03 cmp %g1, %g3
2007acc: 08 bf ff fd bleu 2007ac0 <adjtime+0x13c>
2007ad0: 84 00 bf ff add %g2, -1, %g2
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
2007ad4: 85 39 20 1f sra %g4, 0x1f, %g2
2007ad8: a6 10 00 01 mov %g1, %l3
2007adc: a5 38 60 1f sra %g1, 0x1f, %l2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
2007ae0: 83 28 a0 03 sll %g2, 3, %g1
2007ae4: 86 10 00 04 mov %g4, %g3
2007ae8: 89 31 20 1d srl %g4, 0x1d, %g4
2007aec: bb 28 e0 03 sll %g3, 3, %i5
2007af0: b8 11 00 01 or %g4, %g1, %i4
2007af4: 83 37 60 1b srl %i5, 0x1b, %g1
2007af8: a9 2f 20 05 sll %i4, 5, %l4
2007afc: ab 2f 60 05 sll %i5, 5, %l5
2007b00: a8 10 40 14 or %g1, %l4, %l4
2007b04: ba a5 40 1d subcc %l5, %i5, %i5
2007b08: 83 37 60 1a srl %i5, 0x1a, %g1
2007b0c: b8 65 00 1c subx %l4, %i4, %i4
2007b10: a3 2f 60 06 sll %i5, 6, %l1
2007b14: a1 2f 20 06 sll %i4, 6, %l0
2007b18: ba a4 40 1d subcc %l1, %i5, %i5
2007b1c: a0 10 40 10 or %g1, %l0, %l0
2007b20: b8 64 00 1c subx %l0, %i4, %i4
2007b24: ae 87 40 03 addcc %i5, %g3, %l7
2007b28: 83 35 e0 1e srl %l7, 0x1e, %g1
2007b2c: ac 47 00 02 addx %i4, %g2, %l6
2007b30: 97 2d e0 02 sll %l7, 2, %o3
2007b34: 95 2d a0 02 sll %l6, 2, %o2
2007b38: 86 85 c0 0b addcc %l7, %o3, %g3
2007b3c: 94 10 40 0a or %g1, %o2, %o2
2007b40: 9b 28 e0 02 sll %g3, 2, %o5
2007b44: 84 45 80 0a addx %l6, %o2, %g2
2007b48: 83 30 e0 1e srl %g3, 0x1e, %g1
2007b4c: ba 80 c0 0d addcc %g3, %o5, %i5
2007b50: 99 28 a0 02 sll %g2, 2, %o4
2007b54: b7 2f 60 02 sll %i5, 2, %i3
2007b58: 98 10 40 0c or %g1, %o4, %o4
2007b5c: 83 37 60 1e srl %i5, 0x1e, %g1
2007b60: b8 40 80 0c addx %g2, %o4, %i4
2007b64: 86 87 40 1b addcc %i5, %i3, %g3
2007b68: b5 2f 20 02 sll %i4, 2, %i2
2007b6c: bb 30 e0 17 srl %g3, 0x17, %i5
2007b70: b4 10 40 1a or %g1, %i2, %i2
2007b74: 84 47 00 1a addx %i4, %i2, %g2
2007b78: 83 28 e0 09 sll %g3, 9, %g1
2007b7c: 89 28 a0 09 sll %g2, 9, %g4
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
2007b80: 90 07 bf f8 add %fp, -8, %o0
2007b84: 84 17 40 04 or %i5, %g4, %g2
2007b88: ba 84 c0 01 addcc %l3, %g1, %i5
2007b8c: b8 44 80 02 addx %l2, %g2, %i4
2007b90: 40 00 06 eb call 200973c <_TOD_Set_with_timestamp>
2007b94: f8 3f bf f8 std %i4, [ %fp + -8 ]
ts.tv_sec--;
}
_TOD_Set( &ts );
_Thread_Enable_dispatch();
2007b98: 40 00 0d c7 call 200b2b4 <_Thread_Enable_dispatch>
2007b9c: 01 00 00 00 nop
/* set the user's output */
if ( olddelta )
2007ba0: 80 a6 60 00 cmp %i1, 0
2007ba4: 02 bf ff 95 be 20079f8 <adjtime+0x74>
2007ba8: 82 10 20 00 clr %g1
*olddelta = *delta;
2007bac: c4 06 00 00 ld [ %i0 ], %g2
2007bb0: c4 26 40 00 st %g2, [ %i1 ]
2007bb4: c4 06 20 04 ld [ %i0 + 4 ], %g2
2007bb8: c4 26 60 04 st %g2, [ %i1 + 4 ]
return 0;
}
2007bbc: 81 c7 e0 08 ret
2007bc0: 91 e8 00 01 restore %g0, %g1, %o0
*/
if ( !delta )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
2007bc4: 40 00 25 2c call 2011074 <__errno>
2007bc8: 01 00 00 00 nop
2007bcc: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
2007bd0: 82 10 3f ff mov -1, %g1
2007bd4: 10 bf ff 8a b 20079fc <adjtime+0x78>
2007bd8: c4 22 00 00 st %g2, [ %o0 ]
02007b90 <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
2007b90: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
2007b94: 3b 00 80 82 sethi %hi(0x2020800), %i5
2007b98: 40 00 04 85 call 2008dac <pthread_mutex_lock>
2007b9c: 90 17 60 4c or %i5, 0x4c, %o0 ! 202084c <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
2007ba0: 90 10 00 18 mov %i0, %o0
2007ba4: 40 00 1c 73 call 200ed70 <fcntl>
2007ba8: 92 10 20 01 mov 1, %o1
2007bac: 80 a2 20 00 cmp %o0, 0
2007bb0: 06 80 00 6c bl 2007d60 <aio_cancel+0x1d0>
2007bb4: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
2007bb8: 02 80 00 3b be 2007ca4 <aio_cancel+0x114>
2007bbc: 92 10 00 18 mov %i0, %o1
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
2007bc0: f8 06 40 00 ld [ %i1 ], %i4
2007bc4: 80 a7 00 18 cmp %i4, %i0
2007bc8: 12 80 00 2f bne 2007c84 <aio_cancel+0xf4>
2007bcc: 90 17 60 4c or %i5, 0x4c, %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);
2007bd0: 92 10 00 1c mov %i4, %o1
2007bd4: 11 00 80 82 sethi %hi(0x2020800), %o0
2007bd8: 94 10 20 00 clr %o2
2007bdc: 40 00 01 92 call 2008224 <rtems_aio_search_fd>
2007be0: 90 12 20 94 or %o0, 0x94, %o0
if (r_chain == NULL) {
2007be4: b6 92 20 00 orcc %o0, 0, %i3
2007be8: 22 80 00 0f be,a 2007c24 <aio_cancel+0x94>
2007bec: b6 17 60 4c or %i5, 0x4c, %i3
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007bf0: b8 06 e0 1c add %i3, 0x1c, %i4
2007bf4: 40 00 04 6e call 2008dac <pthread_mutex_lock>
2007bf8: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007bfc: 92 10 00 19 mov %i1, %o1
2007c00: 40 00 01 d2 call 2008348 <rtems_aio_remove_req>
2007c04: 90 06 e0 08 add %i3, 8, %o0
2007c08: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
2007c0c: 40 00 04 88 call 2008e2c <pthread_mutex_unlock>
2007c10: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007c14: 40 00 04 86 call 2008e2c <pthread_mutex_unlock>
2007c18: 90 17 60 4c or %i5, 0x4c, %o0
return result;
}
return AIO_ALLDONE;
}
2007c1c: 81 c7 e0 08 ret
2007c20: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
2007c24: c4 06 e0 54 ld [ %i3 + 0x54 ], %g2
2007c28: 82 06 e0 58 add %i3, 0x58, %g1
2007c2c: 80 a0 80 01 cmp %g2, %g1
2007c30: 02 80 00 0f be 2007c6c <aio_cancel+0xdc> <== NEVER TAKEN
2007c34: 90 06 e0 54 add %i3, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
2007c38: 92 10 00 1c mov %i4, %o1
2007c3c: 40 00 01 7a call 2008224 <rtems_aio_search_fd>
2007c40: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007c44: 80 a2 20 00 cmp %o0, 0
2007c48: 02 80 00 0e be 2007c80 <aio_cancel+0xf0>
2007c4c: 92 10 00 19 mov %i1, %o1
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007c50: 40 00 01 be call 2008348 <rtems_aio_remove_req>
2007c54: 90 02 20 08 add %o0, 8, %o0
2007c58: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007c5c: 40 00 04 74 call 2008e2c <pthread_mutex_unlock>
2007c60: 90 10 00 1b mov %i3, %o0
return result;
2007c64: 81 c7 e0 08 ret
2007c68: 81 e8 00 00 restore
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
return AIO_ALLDONE;
2007c6c: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
2007c70: 40 00 04 6f call 2008e2c <pthread_mutex_unlock>
2007c74: 90 17 60 4c or %i5, 0x4c, %o0
return AIO_ALLDONE;
2007c78: 81 c7 e0 08 ret
2007c7c: 81 e8 00 00 restore
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
2007c80: 90 10 00 1b mov %i3, %o0
2007c84: 40 00 04 6a call 2008e2c <pthread_mutex_unlock>
2007c88: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one (EINVAL);
2007c8c: 40 00 2a eb call 2012838 <__errno>
2007c90: 01 00 00 00 nop
2007c94: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007c98: c2 22 00 00 st %g1, [ %o0 ]
2007c9c: 81 c7 e0 08 ret
2007ca0: 81 e8 00 00 restore
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
2007ca4: 11 00 80 82 sethi %hi(0x2020800), %o0
2007ca8: 94 10 20 00 clr %o2
2007cac: 40 00 01 5e call 2008224 <rtems_aio_search_fd>
2007cb0: 90 12 20 94 or %o0, 0x94, %o0
if (r_chain == NULL) {
2007cb4: b8 92 20 00 orcc %o0, 0, %i4
2007cb8: 02 80 00 0f be 2007cf4 <aio_cancel+0x164>
2007cbc: b6 07 20 1c add %i4, 0x1c, %i3
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007cc0: 40 00 04 3b call 2008dac <pthread_mutex_lock>
2007cc4: 90 10 00 1b mov %i3, %o0
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2007cc8: 40 00 0b 3a call 200a9b0 <_Chain_Extract>
2007ccc: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007cd0: 40 00 01 8a call 20082f8 <rtems_aio_remove_fd>
2007cd4: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
2007cd8: 40 00 04 55 call 2008e2c <pthread_mutex_unlock>
2007cdc: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
2007ce0: b0 10 20 00 clr %i0
pthread_mutex_lock (&r_chain->mutex);
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
2007ce4: 40 00 04 52 call 2008e2c <pthread_mutex_unlock>
2007ce8: 90 17 60 4c or %i5, 0x4c, %o0
return AIO_CANCELED;
2007cec: 81 c7 e0 08 ret
2007cf0: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2007cf4: b8 17 60 4c or %i5, 0x4c, %i4
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
2007cf8: c4 07 20 54 ld [ %i4 + 0x54 ], %g2
2007cfc: 82 07 20 58 add %i4, 0x58, %g1
2007d00: 80 a0 80 01 cmp %g2, %g1
2007d04: 02 bf ff da be 2007c6c <aio_cancel+0xdc> <== NEVER TAKEN
2007d08: 90 07 20 54 add %i4, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
2007d0c: 92 10 00 18 mov %i0, %o1
2007d10: 40 00 01 45 call 2008224 <rtems_aio_search_fd>
2007d14: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007d18: b6 92 20 00 orcc %o0, 0, %i3
2007d1c: 22 bf ff d5 be,a 2007c70 <aio_cancel+0xe0>
2007d20: b0 10 20 02 mov 2, %i0
2007d24: 40 00 0b 23 call 200a9b0 <_Chain_Extract>
2007d28: ba 06 e0 1c add %i3, 0x1c, %i5
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007d2c: 40 00 01 73 call 20082f8 <rtems_aio_remove_fd>
2007d30: 90 10 00 1b mov %i3, %o0
pthread_mutex_destroy (&r_chain->mutex);
2007d34: 40 00 03 72 call 2008afc <pthread_mutex_destroy>
2007d38: 90 10 00 1d mov %i5, %o0
pthread_cond_destroy (&r_chain->mutex);
2007d3c: 40 00 02 94 call 200878c <pthread_cond_destroy>
2007d40: 90 10 00 1d mov %i5, %o0
free (r_chain);
2007d44: 7f ff ef 9a call 2003bac <free>
2007d48: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
2007d4c: b0 10 20 00 clr %i0
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
pthread_cond_destroy (&r_chain->mutex);
free (r_chain);
pthread_mutex_unlock (&aio_request_queue.mutex);
2007d50: 40 00 04 37 call 2008e2c <pthread_mutex_unlock>
2007d54: 90 10 00 1c mov %i4, %o0
return AIO_CANCELED;
2007d58: 81 c7 e0 08 ret
2007d5c: 81 e8 00 00 restore
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
2007d60: 40 00 04 33 call 2008e2c <pthread_mutex_unlock>
2007d64: 90 17 60 4c or %i5, 0x4c, %o0
rtems_set_errno_and_return_minus_one (EBADF);
2007d68: 40 00 2a b4 call 2012838 <__errno>
2007d6c: b0 10 3f ff mov -1, %i0
2007d70: 82 10 20 09 mov 9, %g1
2007d74: c2 22 00 00 st %g1, [ %o0 ]
2007d78: 81 c7 e0 08 ret
2007d7c: 81 e8 00 00 restore
02007d88 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
2007d88: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
2007d8c: 03 00 00 08 sethi %hi(0x2000), %g1
2007d90: 80 a6 00 01 cmp %i0, %g1
2007d94: 12 80 00 14 bne 2007de4 <aio_fsync+0x5c>
2007d98: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
2007d9c: d0 06 40 00 ld [ %i1 ], %o0
2007da0: 40 00 1b f4 call 200ed70 <fcntl>
2007da4: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2007da8: 90 0a 20 03 and %o0, 3, %o0
2007dac: 90 02 3f ff add %o0, -1, %o0
2007db0: 80 a2 20 01 cmp %o0, 1
2007db4: 18 80 00 0c bgu 2007de4 <aio_fsync+0x5c>
2007db8: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2007dbc: 7f ff f0 a3 call 2004048 <malloc>
2007dc0: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2007dc4: 80 a2 20 00 cmp %o0, 0
2007dc8: 02 80 00 06 be 2007de0 <aio_fsync+0x58> <== NEVER TAKEN
2007dcc: 82 10 20 03 mov 3, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
2007dd0: f2 22 20 14 st %i1, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_SYNC;
2007dd4: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
2007dd8: 40 00 01 78 call 20083b8 <rtems_aio_enqueue>
2007ddc: 91 e8 00 08 restore %g0, %o0, %o0
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2007de0: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
2007de4: 82 10 3f ff mov -1, %g1
2007de8: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
2007dec: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
2007df0: 40 00 2a 92 call 2012838 <__errno>
2007df4: b0 10 3f ff mov -1, %i0
2007df8: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
2007dfc: 81 c7 e0 08 ret
2007e00: 81 e8 00 00 restore
0200859c <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
200859c: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
20085a0: d0 06 00 00 ld [ %i0 ], %o0
20085a4: 92 10 20 03 mov 3, %o1
20085a8: 40 00 19 f2 call 200ed70 <fcntl>
20085ac: ba 10 20 09 mov 9, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
20085b0: 80 8a 20 01 btst 1, %o0
20085b4: 12 80 00 0b bne 20085e0 <aio_read+0x44>
20085b8: 82 10 3f ff mov -1, %g1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
20085bc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20085c0: 80 a0 60 00 cmp %g1, 0
20085c4: 12 80 00 06 bne 20085dc <aio_read+0x40>
20085c8: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
20085cc: c2 06 20 08 ld [ %i0 + 8 ], %g1
20085d0: 80 a0 60 00 cmp %g1, 0
20085d4: 16 80 00 0a bge 20085fc <aio_read+0x60>
20085d8: 01 00 00 00 nop
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
20085dc: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xfdbfffff>
20085e0: fa 26 20 34 st %i5, [ %i0 + 0x34 ]
20085e4: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
20085e8: 40 00 28 94 call 2012838 <__errno>
20085ec: b0 10 3f ff mov -1, %i0
20085f0: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
20085f4: 81 c7 e0 08 ret
20085f8: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
20085fc: 7f ff ee 93 call 2004048 <malloc>
2008600: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2008604: 80 a2 20 00 cmp %o0, 0
2008608: 02 80 00 06 be 2008620 <aio_read+0x84> <== NEVER TAKEN
200860c: 82 10 20 01 mov 1, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
2008610: f0 22 20 14 st %i0, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_READ;
2008614: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
2008618: 7f ff ff 68 call 20083b8 <rtems_aio_enqueue>
200861c: 91 e8 00 08 restore %g0, %o0, %o0
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2008620: 10 bf ff ef b 20085dc <aio_read+0x40> <== NOT EXECUTED
2008624: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
02008630 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
2008630: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
2008634: d0 06 00 00 ld [ %i0 ], %o0
2008638: 40 00 19 ce call 200ed70 <fcntl>
200863c: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2008640: 90 0a 20 03 and %o0, 3, %o0
2008644: 90 02 3f ff add %o0, -1, %o0
2008648: 80 a2 20 01 cmp %o0, 1
200864c: 18 80 00 0a bgu 2008674 <aio_write+0x44>
2008650: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
2008654: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2008658: 80 a0 60 00 cmp %g1, 0
200865c: 12 80 00 06 bne 2008674 <aio_write+0x44>
2008660: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
2008664: c2 06 20 08 ld [ %i0 + 8 ], %g1
2008668: 80 a0 60 00 cmp %g1, 0
200866c: 16 80 00 0a bge 2008694 <aio_write+0x64>
2008670: 01 00 00 00 nop
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2008674: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xfdbfffff>
2008678: fa 26 20 34 st %i5, [ %i0 + 0x34 ]
200867c: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
2008680: 40 00 28 6e call 2012838 <__errno>
2008684: b0 10 3f ff mov -1, %i0
2008688: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
200868c: 81 c7 e0 08 ret
2008690: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2008694: 7f ff ee 6d call 2004048 <malloc>
2008698: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
200869c: 80 a2 20 00 cmp %o0, 0
20086a0: 02 80 00 06 be 20086b8 <aio_write+0x88> <== NEVER TAKEN
20086a4: 82 10 20 02 mov 2, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
20086a8: f0 22 20 14 st %i0, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
20086ac: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
20086b0: 7f ff ff 42 call 20083b8 <rtems_aio_enqueue>
20086b4: 91 e8 00 08 restore %g0, %o0, %o0
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
20086b8: 10 bf ff ef b 2008674 <aio_write+0x44> <== NOT EXECUTED
20086bc: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
02008c38 <check_and_merge>:
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
2008c38: 80 a2 ff f8 cmp %o3, -8
2008c3c: 02 80 00 23 be 2008cc8 <check_and_merge+0x90>
2008c40: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
2008c44: c2 02 c0 00 ld [ %o3 ], %g1
2008c48: 80 a0 60 00 cmp %g1, 0
2008c4c: 22 80 00 1c be,a 2008cbc <check_and_merge+0x84>
2008c50: c4 02 e0 04 ld [ %o3 + 4 ], %g2
if (b->begin < a->begin) {
2008c54: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3
2008c58: c4 02 a0 18 ld [ %o2 + 0x18 ], %g2
2008c5c: 80 a0 c0 02 cmp %g3, %g2
2008c60: 3a 80 00 07 bcc,a 2008c7c <check_and_merge+0x44>
2008c64: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4
2008c68: 84 10 00 0a mov %o2, %g2
2008c6c: c2 02 80 00 ld [ %o2 ], %g1
2008c70: 94 10 00 0b mov %o3, %o2
2008c74: 96 10 00 02 mov %g2, %o3
a = b;
b = t;
}
a->size += b->size;
2008c78: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4
2008c7c: c6 02 e0 1c ld [ %o3 + 0x1c ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
2008c80: c4 02 e0 04 ld [ %o3 + 4 ], %g2
2008c84: 86 01 00 03 add %g4, %g3, %g3
2008c88: c6 22 a0 1c st %g3, [ %o2 + 0x1c ]
next->previous = previous;
previous->next = next;
2008c8c: c2 20 80 00 st %g1, [ %g2 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
2008c90: c4 20 60 04 st %g2, [ %g1 + 4 ]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2008c94: c2 02 00 00 ld [ %o0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008c98: d0 22 e0 04 st %o0, [ %o3 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
2008c9c: d6 22 00 00 st %o3, [ %o0 ]
the_node->next = before_node;
2008ca0: c2 22 c0 00 st %g1, [ %o3 ]
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
2008ca4: 90 10 00 09 mov %o1, %o0
before_node->previous = the_node;
2008ca8: d6 20 60 04 st %o3, [ %g1 + 4 ]
2008cac: 92 02 e0 08 add %o3, 8, %o1
2008cb0: 82 13 c0 00 mov %o7, %g1
2008cb4: 40 00 07 32 call 200a97c <_RBTree_Extract_unprotected>
2008cb8: 9e 10 40 00 mov %g1, %o7
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
2008cbc: 80 a0 a0 00 cmp %g2, 0
2008cc0: 32 bf ff e6 bne,a 2008c58 <check_and_merge+0x20> <== NEVER TAKEN
2008cc4: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3 <== NOT EXECUTED
2008cc8: 81 c3 e0 08 retl
02003a00 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
2003a00: 9d e3 bf 48 save %sp, -184, %sp
/*
* We use the global environment for path evaluation. This makes it possible
* to escape from a chroot environment referencing an unmounted file system.
*/
rtems_filesystem_eval_path_start_with_root_and_current(
2003a04: 94 10 20 19 mov 0x19, %o2
2003a08: 92 10 00 18 mov %i0, %o1
2003a0c: 90 07 bf c8 add %fp, -56, %o0
2003a10: 17 00 80 4a sethi %hi(0x2012800), %o3
2003a14: 96 12 e3 74 or %o3, 0x374, %o3 ! 2012b74 <rtems_global_user_env+0x4>
2003a18: 40 00 04 f3 call 2004de4 <rtems_filesystem_eval_path_start_with_root_and_current>
2003a1c: 98 02 ff fc add %o3, -4, %o4
2003a20: 92 07 bf e0 add %fp, -32, %o1
2003a24: 40 00 06 0b call 2005250 <rtems_filesystem_location_copy_and_detach>
2003a28: 90 07 bf b0 add %fp, -80, %o0
&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 );
2003a2c: 40 00 06 98 call 200548c <rtems_filesystem_location_transform_to_global>
2003a30: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
2003a34: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
2003a38: 39 00 80 49 sethi %hi(0x2012400), %i4
2003a3c: b8 17 20 44 or %i4, 0x44, %i4 ! 2012444 <rtems_filesystem_null_handlers>
2003a40: 80 a0 40 1c cmp %g1, %i4
2003a44: 02 80 00 16 be 2003a9c <chroot+0x9c>
2003a48: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
2003a4c: 40 00 06 56 call 20053a4 <rtems_filesystem_global_location_obtain>
2003a50: 90 07 bf ac add %fp, -84, %o0
rtems_filesystem_global_location_obtain( &new_current_loc );
rtems_filesystem_node_types_t type =
(*new_root_loc->location.mt_entry->ops->node_type_h)(
2003a54: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
2003a58: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
rtems_filesystem_global_location_t *new_root_loc =
rtems_filesystem_global_location_obtain( &new_current_loc );
rtems_filesystem_node_types_t type =
2003a5c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2003a60: 9f c0 40 00 call %g1
2003a64: ba 10 00 08 mov %o0, %i5
(*new_root_loc->location.mt_entry->ops->node_type_h)(
&new_root_loc->location
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
2003a68: 80 a2 20 00 cmp %o0, 0
2003a6c: 02 80 00 13 be 2003ab8 <chroot+0xb8>
2003a70: 01 00 00 00 nop
static inline void rtems_filesystem_location_error(
const rtems_filesystem_location_info_t *loc,
int eno
)
{
if ( !rtems_filesystem_location_is_null( loc ) ) {
2003a74: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2003a78: 80 a0 40 1c cmp %g1, %i4
2003a7c: 02 80 00 06 be 2003a94 <chroot+0x94> <== NEVER TAKEN
2003a80: 01 00 00 00 nop
errno = eno;
2003a84: 40 00 22 41 call 200c388 <__errno>
2003a88: 01 00 00 00 nop
2003a8c: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2003a90: 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 );
2003a94: 40 00 06 24 call 2005324 <rtems_filesystem_global_location_release>
2003a98: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003a9c: 40 00 05 1c call 2004f0c <rtems_filesystem_eval_path_cleanup>
2003aa0: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
2003aa4: d0 07 bf ac ld [ %fp + -84 ], %o0
2003aa8: 40 00 06 1f call 2005324 <rtems_filesystem_global_location_release>
2003aac: b0 10 3f ff mov -1, %i0
}
return rv;
}
2003ab0: 81 c7 e0 08 ret
2003ab4: 81 e8 00 00 restore
(*new_root_loc->location.mt_entry->ops->node_type_h)(
&new_root_loc->location
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
sc = rtems_libio_set_private_env();
2003ab8: 40 00 03 11 call 20046fc <rtems_libio_set_private_env>
2003abc: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
2003ac0: 80 a2 20 00 cmp %o0, 0
2003ac4: 02 80 00 09 be 2003ae8 <chroot+0xe8>
2003ac8: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
2003acc: 02 bf ff f2 be 2003a94 <chroot+0x94> <== NEVER TAKEN
2003ad0: 01 00 00 00 nop
errno = ENOMEM;
2003ad4: 40 00 22 2d call 200c388 <__errno>
2003ad8: 01 00 00 00 nop
2003adc: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
2003ae0: 10 bf ff ed b 2003a94 <chroot+0x94>
2003ae4: c2 22 00 00 st %g1, [ %o0 ]
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
sc = rtems_libio_set_private_env();
if (sc == RTEMS_SUCCESSFUL) {
rtems_filesystem_global_location_assign(
2003ae8: 39 00 80 4a sethi %hi(0x2012800), %i4
2003aec: d0 07 23 6c ld [ %i4 + 0x36c ], %o0 ! 2012b6c <rtems_current_user_env>
2003af0: 92 10 00 1d mov %i5, %o1
2003af4: 40 00 06 22 call 200537c <rtems_filesystem_global_location_assign>
2003af8: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
2003afc: d2 07 bf ac ld [ %fp + -84 ], %o1
2003b00: d0 07 23 6c ld [ %i4 + 0x36c ], %o0
2003b04: 40 00 06 1e call 200537c <rtems_filesystem_global_location_assign>
2003b08: b0 10 20 00 clr %i0
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003b0c: 40 00 05 00 call 2004f0c <rtems_filesystem_eval_path_cleanup>
2003b10: 90 07 bf c8 add %fp, -56, %o0
2003b14: 81 c7 e0 08 ret
2003b18: 81 e8 00 00 restore
020077f0 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
20077f0: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
20077f4: 80 a6 60 00 cmp %i1, 0
20077f8: 02 80 00 0a be 2007820 <clock_gettime+0x30>
20077fc: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
2007800: 02 80 00 19 be 2007864 <clock_gettime+0x74>
2007804: 80 a6 20 04 cmp %i0, 4
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
2007808: 02 80 00 12 be 2007850 <clock_gettime+0x60> <== NEVER TAKEN
200780c: 80 a6 20 02 cmp %i0, 2
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
2007810: 02 80 00 10 be 2007850 <clock_gettime+0x60>
2007814: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
2007818: 02 80 00 08 be 2007838 <clock_gettime+0x48>
200781c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
2007820: 40 00 27 76 call 20115f8 <__errno>
2007824: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff>
2007828: 82 10 20 16 mov 0x16, %g1
200782c: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
2007830: 81 c7 e0 08 ret
2007834: 81 e8 00 00 restore
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
2007838: 40 00 27 70 call 20115f8 <__errno>
200783c: b0 10 3f ff mov -1, %i0
2007840: 82 10 20 58 mov 0x58, %g1
2007844: c2 22 00 00 st %g1, [ %o0 ]
2007848: 81 c7 e0 08 ret
200784c: 81 e8 00 00 restore
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
_TOD_Get_uptime_as_timespec( tp );
2007850: 90 10 00 19 mov %i1, %o0
2007854: 40 00 08 b6 call 2009b2c <_TOD_Get_uptime_as_timespec>
2007858: b0 10 20 00 clr %i0
return 0;
200785c: 81 c7 e0 08 ret
2007860: 81 e8 00 00 restore
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
2007864: 90 07 bf f8 add %fp, -8, %o0
2007868: 13 00 80 86 sethi %hi(0x2021800), %o1
200786c: 40 00 08 9f call 2009ae8 <_TOD_Get_with_nanoseconds>
2007870: 92 12 60 d8 or %o1, 0xd8, %o1 ! 20218d8 <_TOD>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
2007874: f8 1a 00 00 ldd [ %o0 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007878: 94 10 20 00 clr %o2
200787c: 90 10 00 1c mov %i4, %o0
2007880: 92 10 00 1d mov %i5, %o1
2007884: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007888: 40 00 55 69 call 201ce2c <__divdi3>
200788c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007890: 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);
2007894: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007898: 90 10 00 1c mov %i4, %o0
200789c: 92 10 00 1d mov %i5, %o1
20078a0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
return 0;
20078a4: b0 10 20 00 clr %i0
20078a8: 40 00 56 4c call 201d1d8 <__moddi3>
20078ac: 96 12 e2 00 or %o3, 0x200, %o3
20078b0: d2 26 60 04 st %o1, [ %i1 + 4 ]
20078b4: 81 c7 e0 08 ret
20078b8: 81 e8 00 00 restore
02029350 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
2029350: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2029354: 80 a6 60 00 cmp %i1, 0
2029358: 02 80 00 08 be 2029378 <clock_settime+0x28> <== NEVER TAKEN
202935c: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
2029360: 02 80 00 0c be 2029390 <clock_settime+0x40>
2029364: 80 a6 20 02 cmp %i0, 2
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
2029368: 02 80 00 49 be 202948c <clock_settime+0x13c>
202936c: 80 a6 20 03 cmp %i0, 3
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
2029370: 02 80 00 47 be 202948c <clock_settime+0x13c>
2029374: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
2029378: 40 00 4a bc call 203be68 <__errno>
202937c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff>
2029380: 82 10 20 16 mov 0x16, %g1
2029384: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
2029388: 81 c7 e0 08 ret
202938c: 81 e8 00 00 restore
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
2029390: c4 06 40 00 ld [ %i1 ], %g2
2029394: 03 08 76 b9 sethi %hi(0x21dae400), %g1
2029398: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff <RAM_END+0x1f9ae4ff>
202939c: 80 a0 80 01 cmp %g2, %g1
20293a0: 08 bf ff f6 bleu 2029378 <clock_settime+0x28>
20293a4: 03 00 81 9c sethi %hi(0x2067000), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
20293a8: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 2067360 <_Thread_Dispatch_disable_level>
++level;
20293ac: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
20293b0: c4 20 63 60 st %g2, [ %g1 + 0x360 ]
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
20293b4: c6 06 40 00 ld [ %i1 ], %g3
20293b8: e2 06 60 04 ld [ %i1 + 4 ], %l1
20293bc: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
20293c0: 83 28 a0 03 sll %g2, 3, %g1
20293c4: bb 28 e0 03 sll %g3, 3, %i5
20293c8: 89 30 e0 1d srl %g3, 0x1d, %g4
20293cc: b8 11 00 01 or %g4, %g1, %i4
20293d0: 83 37 60 1b srl %i5, 0x1b, %g1
20293d4: a5 2f 20 05 sll %i4, 5, %l2
20293d8: a7 2f 60 05 sll %i5, 5, %l3
20293dc: a4 10 40 12 or %g1, %l2, %l2
20293e0: ba a4 c0 1d subcc %l3, %i5, %i5
20293e4: 83 37 60 1a srl %i5, 0x1a, %g1
20293e8: b8 64 80 1c subx %l2, %i4, %i4
20293ec: 97 2f 60 06 sll %i5, 6, %o3
20293f0: 95 2f 20 06 sll %i4, 6, %o2
20293f4: ba a2 c0 1d subcc %o3, %i5, %i5
20293f8: 94 10 40 0a or %g1, %o2, %o2
20293fc: b8 62 80 1c subx %o2, %i4, %i4
2029400: aa 87 40 03 addcc %i5, %g3, %l5
2029404: 83 35 60 1e srl %l5, 0x1e, %g1
2029408: a8 47 00 02 addx %i4, %g2, %l4
202940c: 9b 2d 60 02 sll %l5, 2, %o5
2029410: 99 2d 20 02 sll %l4, 2, %o4
2029414: 86 85 40 0d addcc %l5, %o5, %g3
2029418: 98 10 40 0c or %g1, %o4, %o4
202941c: b3 28 e0 02 sll %g3, 2, %i1
2029420: 84 45 00 0c addx %l4, %o4, %g2
2029424: 83 30 e0 1e srl %g3, 0x1e, %g1
2029428: ba 80 c0 19 addcc %g3, %i1, %i5
202942c: b1 28 a0 02 sll %g2, 2, %i0
2029430: b7 2f 60 02 sll %i5, 2, %i3
2029434: b0 10 40 18 or %g1, %i0, %i0
2029438: 83 37 60 1e srl %i5, 0x1e, %g1
202943c: b8 40 80 18 addx %g2, %i0, %i4
2029440: 86 87 40 1b addcc %i5, %i3, %g3
2029444: b5 2f 20 02 sll %i4, 2, %i2
2029448: bb 30 e0 17 srl %g3, 0x17, %i5
202944c: b4 10 40 1a or %g1, %i2, %i2
2029450: 84 47 00 1a addx %i4, %i2, %g2
2029454: 83 28 e0 09 sll %g3, 9, %g1
2029458: 89 28 a0 09 sll %g2, 9, %g4
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
202945c: 90 07 bf f8 add %fp, -8, %o0
2029460: 84 17 40 04 or %i5, %g4, %g2
2029464: ba 84 40 01 addcc %l1, %g1, %i5
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
2029468: a1 3c 60 1f sra %l1, 0x1f, %l0
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
202946c: b0 10 20 00 clr %i0
2029470: b8 44 00 02 addx %l0, %g2, %i4
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
2029474: 40 00 04 80 call 202a674 <_TOD_Set_with_timestamp>
2029478: f8 3f bf f8 std %i4, [ %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();
202947c: 7f ff 83 ee call 200a434 <_Thread_Enable_dispatch>
2029480: 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;
2029484: 81 c7 e0 08 ret
2029488: 81 e8 00 00 restore
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
202948c: 40 00 4a 77 call 203be68 <__errno>
2029490: b0 10 3f ff mov -1, %i0
2029494: 82 10 20 58 mov 0x58, %g1
2029498: c2 22 00 00 st %g1, [ %o0 ]
202949c: 81 c7 e0 08 ret
20294a0: 81 e8 00 00 restore
02003578 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
2003578: 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) {
200357c: 25 00 80 89 sethi %hi(0x2022400), %l2
2003580: fa 04 a1 f0 ld [ %l2 + 0x1f0 ], %i5 ! 20225f0 <disktab_size>
2003584: 80 a6 00 1d cmp %i0, %i5
2003588: 1a 80 00 30 bcc 2003648 <create_disk+0xd0>
200358c: a2 10 00 18 mov %i0, %l1
2003590: 03 00 80 89 sethi %hi(0x2022400), %g1
2003594: e0 00 61 f4 ld [ %g1 + 0x1f4 ], %l0 ! 20225f4 <disktab>
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
disktab_size = new_size;
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
2003598: 83 2c 60 03 sll %l1, 3, %g1
200359c: fa 04 00 01 ld [ %l0 + %g1 ], %i5
20035a0: a0 04 00 01 add %l0, %g1, %l0
20035a4: 80 a7 60 00 cmp %i5, 0
20035a8: 02 80 00 0f be 20035e4 <create_disk+0x6c>
20035ac: f0 04 20 04 ld [ %l0 + 4 ], %i0
20035b0: 80 a6 40 18 cmp %i1, %i0
20035b4: 1a 80 00 0d bcc 20035e8 <create_disk+0x70>
20035b8: 80 a6 20 00 cmp %i0, 0
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab [major].minor = table;
disktab [major].size = new_size;
}
return disktab [major].minor + minor;
20035bc: 83 2e 60 02 sll %i1, 2, %g1
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
20035c0: a0 87 40 01 addcc %i5, %g1, %l0
20035c4: 02 80 00 1f be 2003640 <create_disk+0xc8> <== NEVER TAKEN
20035c8: 01 00 00 00 nop
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
20035cc: c2 07 40 01 ld [ %i5 + %g1 ], %g1
20035d0: 80 a0 60 00 cmp %g1, 0
20035d4: 02 80 00 36 be 20036ac <create_disk+0x134>
20035d8: b0 10 20 0c mov 0xc, %i0
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
20035dc: 81 c7 e0 08 ret
20035e0: 81 e8 00 00 restore
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
20035e4: 80 a6 20 00 cmp %i0, 0
20035e8: 12 80 00 2b bne 2003694 <create_disk+0x11c>
20035ec: a4 10 20 08 mov 8, %l2
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
20035f0: 80 a6 40 12 cmp %i1, %l2
20035f4: 3a 80 00 02 bcc,a 20035fc <create_disk+0x84>
20035f8: a4 06 60 01 add %i1, 1, %l2
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
20035fc: 90 10 00 1d mov %i5, %o0
2003600: 40 00 08 bb call 20058ec <realloc>
2003604: 93 2c a0 02 sll %l2, 2, %o1
if (table == NULL) {
2003608: ba 92 20 00 orcc %o0, 0, %i5
200360c: 02 80 00 0d be 2003640 <create_disk+0xc8>
2003610: 94 24 80 18 sub %l2, %i0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2003614: 91 2e 20 02 sll %i0, 2, %o0
2003618: 92 10 20 00 clr %o1
200361c: 90 07 40 08 add %i5, %o0, %o0
2003620: 40 00 47 ba call 2015508 <memset>
2003624: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
2003628: fa 24 00 00 st %i5, [ %l0 ]
disktab [major].size = new_size;
200362c: e4 24 20 04 st %l2, [ %l0 + 4 ]
}
return disktab [major].minor + minor;
2003630: 83 2e 60 02 sll %i1, 2, %g1
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
2003634: a0 87 40 01 addcc %i5, %g1, %l0
2003638: 32 bf ff e6 bne,a 20035d0 <create_disk+0x58> <== ALWAYS TAKEN
200363c: c2 07 40 01 ld [ %i5 + %g1 ], %g1
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
return RTEMS_NO_MEMORY;
2003640: 81 c7 e0 08 ret
2003644: 91 e8 20 1a restore %g0, 0x1a, %o0
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
2003648: 27 00 80 89 sethi %hi(0x2022400), %l3
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
200364c: b1 2f 60 01 sll %i5, 1, %i0
if (major >= new_size) {
2003650: 80 a4 40 18 cmp %l1, %i0
2003654: 0a 80 00 03 bcs 2003660 <create_disk+0xe8> <== NEVER TAKEN
2003658: d0 04 e1 f4 ld [ %l3 + 0x1f4 ], %o0
new_size = major + 1;
200365c: b0 04 60 01 add %l1, 1, %i0
}
table = realloc(table, new_size * sizeof(*table));
2003660: 40 00 08 a3 call 20058ec <realloc>
2003664: 93 2e 20 03 sll %i0, 3, %o1
if (table == NULL) {
2003668: a0 92 20 00 orcc %o0, 0, %l0
200366c: 02 bf ff f5 be 2003640 <create_disk+0xc8> <== ALWAYS TAKEN
2003670: 94 26 00 1d sub %i0, %i5, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2003674: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
2003678: 92 10 20 00 clr %o1 <== NOT EXECUTED
200367c: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
2003680: 40 00 47 a2 call 2015508 <memset> <== NOT EXECUTED
2003684: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
2003688: e0 24 e1 f4 st %l0, [ %l3 + 0x1f4 ] <== NOT EXECUTED
disktab_size = new_size;
200368c: 10 bf ff c3 b 2003598 <create_disk+0x20> <== NOT EXECUTED
2003690: f0 24 a1 f0 st %i0, [ %l2 + 0x1f0 ] <== NOT EXECUTED
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
2003694: a5 2e 20 01 sll %i0, 1, %l2
}
if (minor >= new_size) {
2003698: 80 a6 40 12 cmp %i1, %l2
200369c: 0a bf ff d9 bcs 2003600 <create_disk+0x88> <== ALWAYS TAKEN
20036a0: 90 10 00 1d mov %i5, %o0
20036a4: 10 bf ff d7 b 2003600 <create_disk+0x88> <== NOT EXECUTED
20036a8: a4 06 60 01 add %i1, 1, %l2 <== NOT EXECUTED
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
20036ac: 40 00 05 bc call 2004d9c <malloc>
20036b0: 90 10 20 78 mov 0x78, %o0
if (dd == NULL) {
20036b4: ba 92 20 00 orcc %o0, 0, %i5
20036b8: 02 bf ff e2 be 2003640 <create_disk+0xc8> <== NEVER TAKEN
20036bc: 80 a6 a0 00 cmp %i2, 0
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
20036c0: 02 80 00 0f be 20036fc <create_disk+0x184>
20036c4: b0 10 20 00 clr %i0
alloc_name = strdup(name);
20036c8: 40 00 48 c7 call 20159e4 <strdup>
20036cc: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
20036d0: b0 92 20 00 orcc %o0, 0, %i0
20036d4: 02 80 00 16 be 200372c <create_disk+0x1b4> <== NEVER TAKEN
20036d8: b4 10 00 08 mov %o0, %i2
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
20036dc: 94 10 00 11 mov %l1, %o2
20036e0: 13 00 00 18 sethi %hi(0x6000), %o1
20036e4: 96 10 00 19 mov %i1, %o3
20036e8: 40 00 06 1c call 2004f58 <mknod>
20036ec: 92 12 61 ff or %o1, 0x1ff, %o1
20036f0: 80 a2 20 00 cmp %o0, 0
20036f4: 06 80 00 07 bl 2003710 <create_disk+0x198> <== NEVER TAKEN
20036f8: 01 00 00 00 nop
free(dd);
return RTEMS_UNSATISFIED;
}
}
*dd_entry = dd;
20036fc: fa 24 00 00 st %i5, [ %l0 ]
*dd_ptr = dd;
2003700: fa 26 c0 00 st %i5, [ %i3 ]
*alloc_name_ptr = alloc_name;
2003704: f0 27 00 00 st %i0, [ %i4 ]
return RTEMS_SUCCESSFUL;
2003708: 81 c7 e0 08 ret
200370c: 91 e8 20 00 restore %g0, 0, %o0
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
2003710: 40 00 04 5b call 200487c <free> <== NOT EXECUTED
2003714: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
2003718: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200371c: 40 00 04 58 call 200487c <free> <== NOT EXECUTED
2003720: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2003724: 81 c7 e0 08 ret <== NOT EXECUTED
2003728: 81 e8 00 00 restore <== NOT EXECUTED
if (name != NULL) {
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
200372c: 40 00 04 54 call 200487c <free> <== NOT EXECUTED
2003730: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2003734: 30 bf ff c3 b,a 2003640 <create_disk+0xc8> <== NOT EXECUTED
02004bd4 <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)
2004bd4: 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)
2004bd8: 90 10 20 01 mov 1, %o0
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
2004bdc: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
2004be0: 40 00 03 41 call 20058e4 <calloc>
2004be4: 92 10 20 28 mov 0x28, %o1
* 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)
2004be8: 82 10 00 18 mov %i0, %g1
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
2004bec: ba 10 00 08 mov %o0, %i5
2004bf0: 80 a2 20 00 cmp %o0, 0
2004bf4: 02 80 00 40 be 2004cf4 <data_to_part_desc.part.1+0x120> <== NEVER TAKEN
2004bf8: b0 10 20 1a mov 0x1a, %i0
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));
2004bfc: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
2004c00: da 08 60 08 ldub [ %g1 + 8 ], %o5
2004c04: de 08 60 09 ldub [ %g1 + 9 ], %o7
2004c08: f0 08 60 0a ldub [ %g1 + 0xa ], %i0
part_desc->start = LE_TO_CPU_U32(temp);
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
2004c0c: f6 08 60 0d ldub [ %g1 + 0xd ], %i3
2004c10: f8 08 60 0e ldub [ %g1 + 0xe ], %i4
2004c14: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
2004c18: f4 08 60 0c ldub [ %g1 + 0xc ], %i2
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));
2004c1c: c6 2f bf ff stb %g3, [ %fp + -1 ]
2004c20: da 2f bf fc stb %o5, [ %fp + -4 ]
2004c24: de 2f bf fd stb %o7, [ %fp + -3 ]
2004c28: f0 2f bf fe stb %i0, [ %fp + -2 ]
part_desc->start = LE_TO_CPU_U32(temp);
2004c2c: c4 07 bf fc ld [ %fp + -4 ], %g2
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
2004c30: d2 08 60 04 ldub [ %g1 + 4 ], %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);
2004c34: c6 08 40 00 ldub [ %g1 ], %g3
/* 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));
2004c38: f6 2f bf fd stb %i3, [ %fp + -3 ]
2004c3c: f8 2f bf fe stb %i4, [ %fp + -2 ]
2004c40: c8 2f bf ff stb %g4, [ %fp + -1 ]
2004c44: f4 2f bf fc stb %i2, [ %fp + -4 ]
part_desc->size = LE_TO_CPU_U32(temp);
2004c48: c2 07 bf fc ld [ %fp + -4 ], %g1
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2004c4c: b7 28 a0 18 sll %g2, 0x18, %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
2004c50: 89 30 a0 18 srl %g2, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
2004c54: b9 30 a0 08 srl %g2, 8, %i4
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2004c58: 88 16 c0 04 or %i3, %g4, %g4
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
2004c5c: b8 0f 20 ff and %i4, 0xff, %i4
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2004c60: b9 2f 20 10 sll %i4, 0x10, %i4
2004c64: 88 11 00 1c or %g4, %i4, %g4
2004c68: b7 28 60 18 sll %g1, 0x18, %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
2004c6c: b9 30 60 18 srl %g1, 0x18, %i4
byte3 = (value >> 16) & 0xff;
2004c70: 85 30 a0 10 srl %g2, 0x10, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2004c74: b8 16 c0 1c or %i3, %i4, %i4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2004c78: 84 08 a0 ff and %g2, 0xff, %g2
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
2004c7c: c6 2a 00 00 stb %g3, [ %o0 ]
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2004c80: 85 28 a0 08 sll %g2, 8, %g2
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
2004c84: d2 2a 20 01 stb %o1, [ %o0 + 1 ]
2004c88: 84 11 00 02 or %g4, %g2, %g2
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
2004c8c: 89 30 60 08 srl %g1, 8, %g4
/* 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);
2004c90: c4 22 20 04 st %g2, [ %o0 + 4 ]
2004c94: 88 09 20 ff and %g4, 0xff, %g4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2004c98: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2004c9c: 89 29 20 10 sll %g4, 0x10, %g4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2004ca0: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2004ca4: b8 17 00 04 or %i4, %g4, %i4
2004ca8: 83 28 60 08 sll %g1, 8, %g1
2004cac: b8 17 00 01 or %i4, %g1, %i4
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
2004cb0: 82 0a 60 7f and %o1, 0x7f, %g1
2004cb4: 80 a0 60 05 cmp %g1, 5
2004cb8: 02 80 00 11 be 2004cfc <data_to_part_desc.part.1+0x128>
2004cbc: f8 22 20 08 st %i4, [ %o0 + 8 ]
DOS_P32MB_PARTITION,
FAT32_PARTITION ,FAT32_LBA_PARTITION,
FAT16_LBA_PARTITION
};
return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
2004cc0: 92 0a 60 ff and %o1, 0xff, %o1
2004cc4: 11 00 80 95 sethi %hi(0x2025400), %o0
2004cc8: 94 10 20 06 mov 6, %o2
2004ccc: 40 00 47 03 call 20168d8 <memchr>
2004cd0: 90 12 23 18 or %o0, 0x318, %o0
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
2004cd4: 80 a2 20 00 cmp %o0, 0
2004cd8: 02 80 00 04 be 2004ce8 <data_to_part_desc.part.1+0x114>
2004cdc: 80 a7 20 00 cmp %i4, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
2004ce0: 32 80 00 08 bne,a 2004d00 <data_to_part_desc.part.1+0x12c><== ALWAYS TAKEN
2004ce4: fa 26 40 00 st %i5, [ %i1 ]
*new_part_desc = part_desc;
}
else {
/* empty partition */
free(part_desc);
2004ce8: 90 10 00 1d mov %i5, %o0
2004cec: 40 00 03 cf call 2005c28 <free>
2004cf0: b0 10 20 00 clr %i0
}
return RTEMS_SUCCESSFUL;
}
2004cf4: 81 c7 e0 08 ret
2004cf8: 81 e8 00 00 restore
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
*new_part_desc = part_desc;
2004cfc: fa 26 40 00 st %i5, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
}
return RTEMS_SUCCESSFUL;
2004d00: 81 c7 e0 08 ret
2004d04: 91 e8 20 00 restore %g0, 0, %o0
02002af4 <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
2002af4: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
2002af8: 03 00 80 6b sethi %hi(0x201ac00), %g1
2002afc: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 201ac74 <rtems_current_user_env>
if (rootloc->mt_entry->ops == &devFS_ops) {
2002b00: 05 00 80 64 sethi %hi(0x2019000), %g2
2002b04: c2 00 60 04 ld [ %g1 + 4 ], %g1
2002b08: 84 10 a0 dc or %g2, 0xdc, %g2
2002b0c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2002b10: c6 00 60 0c ld [ %g1 + 0xc ], %g3
2002b14: 80 a0 c0 02 cmp %g3, %g2
2002b18: 22 80 00 04 be,a 2002b28 <devFS_Show+0x34> <== ALWAYS TAKEN
2002b1c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2002b20: 81 c7 e0 08 ret <== NOT EXECUTED
2002b24: 81 e8 00 00 restore <== NOT EXECUTED
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
2002b28: f0 00 60 04 ld [ %g1 + 4 ], %i0
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002b2c: 80 a6 20 00 cmp %i0, 0
2002b30: 02 bf ff fc be 2002b20 <devFS_Show+0x2c> <== NEVER TAKEN
2002b34: f8 00 40 00 ld [ %g1 ], %i4
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
2002b38: 23 00 80 64 sethi %hi(0x2019000), %l1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002b3c: 35 00 80 64 sethi %hi(0x2019000), %i2
}
printk(
2002b40: 21 00 80 64 sethi %hi(0x2019000), %l0
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) {
2002b44: b2 10 20 00 clr %i1
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
2002b48: a2 14 61 30 or %l1, 0x130, %l1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002b4c: b4 16 a1 48 or %i2, 0x148, %i2
}
printk(
2002b50: a0 14 21 38 or %l0, 0x138, %l0
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
devFS_node *current = nodes + i;
if (current->name != NULL) {
2002b54: c2 07 00 00 ld [ %i4 ], %g1
2002b58: 80 a0 60 00 cmp %g1, 0
2002b5c: 22 80 00 15 be,a 2002bb0 <devFS_Show+0xbc>
2002b60: b2 06 60 01 inc %i1
size_t j = 0;
size_t m = current->namelen;
2002b64: f6 07 20 04 ld [ %i4 + 4 ], %i3
printk("/");
2002b68: 40 00 04 a6 call 2003e00 <printk>
2002b6c: 90 10 00 11 mov %l1, %o0
for (j = 0; j < m; ++j) {
2002b70: 80 a6 e0 00 cmp %i3, 0
2002b74: 02 80 00 0a be 2002b9c <devFS_Show+0xa8> <== NEVER TAKEN
2002b78: ba 10 20 00 clr %i5
printk("%c", current->name [j]);
2002b7c: c2 07 00 00 ld [ %i4 ], %g1
2002b80: 90 10 00 1a mov %i2, %o0
2002b84: d2 48 40 1d ldsb [ %g1 + %i5 ], %o1
2002b88: 40 00 04 9e call 2003e00 <printk>
2002b8c: ba 07 60 01 inc %i5
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
2002b90: 80 a7 40 1b cmp %i5, %i3
2002b94: 32 bf ff fb bne,a 2002b80 <devFS_Show+0x8c>
2002b98: c2 07 00 00 ld [ %i4 ], %g1
printk("%c", current->name [j]);
}
printk(
2002b9c: d2 07 20 08 ld [ %i4 + 8 ], %o1
2002ba0: d4 07 20 0c ld [ %i4 + 0xc ], %o2
2002ba4: 40 00 04 97 call 2003e00 <printk>
2002ba8: 90 10 00 10 mov %l0, %o0
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002bac: b2 06 60 01 inc %i1
2002bb0: 80 a6 40 18 cmp %i1, %i0
2002bb4: 12 bf ff e8 bne 2002b54 <devFS_Show+0x60>
2002bb8: b8 07 20 14 add %i4, 0x14, %i4
2002bbc: 81 c7 e0 08 ret
2002bc0: 81 e8 00 00 restore
0200c478 <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
200c478: 9d e3 bf a0 save %sp, -96, %sp
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return (const devFS_data *) loc->mt_entry->immutable_fs_info;
200c47c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
static inline const char *rtems_filesystem_eval_path_get_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->path;
200c480: e2 06 00 00 ld [ %i0 ], %l1
200c484: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
static inline size_t rtems_filesystem_eval_path_get_pathlen(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->pathlen;
200c488: f2 06 20 04 ld [ %i0 + 4 ], %i1
size_t pathlen,
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
200c48c: e0 00 60 04 ld [ %g1 + 4 ], %l0
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) {
200c490: 80 a4 20 00 cmp %l0, 0
200c494: 02 80 00 3d be 200c588 <devFS_eval_path+0x110>
200c498: fa 00 40 00 ld [ %g1 ], %i5
)
{
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
200c49c: b4 10 20 00 clr %i2
devFS_node *free_node = NULL;
200c4a0: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200c4a4: 10 80 00 09 b 200c4c8 <devFS_eval_path+0x50>
200c4a8: b8 10 20 00 clr %i4
200c4ac: 80 a6 a0 00 cmp %i2, 0
200c4b0: 12 80 00 18 bne 200c510 <devFS_eval_path+0x98>
200c4b4: b8 07 20 01 inc %i4
200c4b8: ba 07 60 14 add %i5, 0x14, %i5
200c4bc: 80 a7 00 10 cmp %i4, %l0
200c4c0: 02 80 00 1f be 200c53c <devFS_eval_path+0xc4>
200c4c4: 82 10 00 1b mov %i3, %g1
devFS_node *current = nodes + i;
if (current->name != NULL) {
200c4c8: d0 07 40 00 ld [ %i5 ], %o0
200c4cc: 80 a2 20 00 cmp %o0, 0
200c4d0: 02 bf ff f7 be 200c4ac <devFS_eval_path+0x34>
200c4d4: b6 10 00 1d mov %i5, %i3
if (
200c4d8: c4 07 60 04 ld [ %i5 + 4 ], %g2
200c4dc: 80 a6 40 02 cmp %i1, %g2
200c4e0: 12 bf ff f3 bne 200c4ac <devFS_eval_path+0x34>
200c4e4: b6 10 00 01 mov %g1, %i3
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
200c4e8: 92 10 00 11 mov %l1, %o1
200c4ec: 40 00 0c c6 call 200f804 <memcmp>
200c4f0: 94 10 00 19 mov %i1, %o2
200c4f4: 80 a2 20 00 cmp %o0, 0
200c4f8: 12 bf ff ee bne 200c4b0 <devFS_eval_path+0x38>
200c4fc: 80 a6 a0 00 cmp %i2, 0
200c500: b4 10 00 1d mov %i5, %i2
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) {
200c504: 80 a6 a0 00 cmp %i2, 0
200c508: 02 bf ff ec be 200c4b8 <devFS_eval_path+0x40> <== NEVER TAKEN
200c50c: b8 07 20 01 inc %i4
200c510: 80 a6 e0 00 cmp %i3, 0
200c514: 22 bf ff ea be,a 200c4bc <devFS_eval_path+0x44>
200c518: ba 07 60 14 add %i5, 0x14, %i5
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
200c51c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
200c520: 80 88 60 40 btst 0x40, %g1
200c524: 12 80 00 15 bne 200c578 <devFS_eval_path+0x100>
200c528: 01 00 00 00 nop
currentloc->node_access = node;
200c52c: f4 26 20 20 st %i2, [ %i0 + 0x20 ]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
200c530: c0 26 20 04 clr [ %i0 + 4 ]
200c534: 81 c7 e0 08 ret
200c538: 81 e8 00 00 restore
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
200c53c: 80 a6 a0 00 cmp %i2, 0
200c540: 12 bf ff f8 bne 200c520 <devFS_eval_path+0xa8>
200c544: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
200c548: 80 88 60 20 btst 0x20, %g1
200c54c: 02 80 00 0d be 200c580 <devFS_eval_path+0x108> <== NEVER TAKEN
200c550: 80 a6 e0 00 cmp %i3, 0
if (free_node != NULL) {
200c554: 02 80 00 11 be 200c598 <devFS_eval_path+0x120> <== NEVER TAKEN
200c558: 82 10 21 ff mov 0x1ff, %g1
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
200c55c: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
currentloc->node_access = free_node;
200c560: f6 26 20 20 st %i3, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
200c564: e2 26 20 08 st %l1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
200c568: f2 26 20 0c st %i1, [ %i0 + 0xc ]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
200c56c: c0 26 20 04 clr [ %i0 + 4 ]
200c570: 81 c7 e0 08 ret
200c574: 81 e8 00 00 restore
if (node != NULL) {
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
currentloc->node_access = node;
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
200c578: 7f ff e1 fe call 2004d70 <rtems_filesystem_eval_path_error>
200c57c: 93 e8 20 11 restore %g0, 0x11, %o1
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200c580: 7f ff e1 fc call 2004d70 <rtems_filesystem_eval_path_error><== NOT EXECUTED
200c584: 93 e8 20 02 restore %g0, 2, %o1 <== NOT EXECUTED
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
200c588: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200c58c: 80 88 60 20 btst 0x20, %g1
200c590: 02 bf ff fc be 200c580 <devFS_eval_path+0x108> <== NEVER TAKEN
200c594: 01 00 00 00 nop
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);
200c598: 7f ff e1 f6 call 2004d70 <rtems_filesystem_eval_path_error>
200c59c: 93 e8 20 1c restore %g0, 0x1c, %o1
020036a8 <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
20036a8: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
20036ac: 80 a6 a0 03 cmp %i2, 3
20036b0: 22 80 00 18 be,a 2003710 <devFS_mknod+0x68>
20036b4: c2 4e 40 00 ldsb [ %i1 ], %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
20036b8: 05 00 00 2c sethi %hi(0xb000), %g2
20036bc: 03 00 00 08 sethi %hi(0x2000), %g1
20036c0: 84 0e c0 02 and %i3, %g2, %g2
20036c4: 80 a0 80 01 cmp %g2, %g1
20036c8: 12 80 00 23 bne 2003754 <devFS_mknod+0xac>
20036cc: 01 00 00 00 nop
char *dupname = malloc(namelen);
20036d0: 40 00 01 f6 call 2003ea8 <malloc>
20036d4: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
20036d8: 84 92 20 00 orcc %o0, 0, %g2
20036dc: 02 80 00 24 be 200376c <devFS_mknod+0xc4>
20036e0: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
20036e4: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
20036e8: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
20036ec: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
20036f0: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
20036f4: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
20036f8: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
20036fc: 94 10 00 1a mov %i2, %o2
2003700: 40 00 30 6b call 200f8ac <memcpy>
2003704: b0 10 20 00 clr %i0
2003708: 81 c7 e0 08 ret
200370c: 81 e8 00 00 restore
dev_t dev
)
{
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
2003710: 80 a0 60 64 cmp %g1, 0x64
2003714: 12 bf ff ea bne 20036bc <devFS_mknod+0x14> <== NEVER TAKEN
2003718: 05 00 00 2c sethi %hi(0xb000), %g2
200371c: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
2003720: 80 a0 60 65 cmp %g1, 0x65
2003724: 12 bf ff e7 bne 20036c0 <devFS_mknod+0x18> <== NEVER TAKEN
2003728: 03 00 00 08 sethi %hi(0x2000), %g1
200372c: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
2003730: 80 a0 60 76 cmp %g1, 0x76
2003734: 12 bf ff e3 bne 20036c0 <devFS_mknod+0x18> <== NEVER TAKEN
2003738: 03 00 00 08 sethi %hi(0x2000), %g1
} else {
errno = ENOTSUP;
rv = -1;
}
} else {
if (!S_ISDIR(mode)) {
200373c: 03 00 00 3c sethi %hi(0xf000), %g1
2003740: b6 0e c0 01 and %i3, %g1, %i3
2003744: 03 00 00 10 sethi %hi(0x4000), %g1
2003748: 80 a6 c0 01 cmp %i3, %g1
200374c: 02 bf ff ef be 2003708 <devFS_mknod+0x60> <== ALWAYS TAKEN
2003750: b0 10 20 00 clr %i0
errno = ENOTSUP;
2003754: 40 00 2d bd call 200ee48 <__errno>
2003758: b0 10 3f ff mov -1, %i0
200375c: 82 10 20 86 mov 0x86, %g1
2003760: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
}
return rv;
}
2003764: 81 c7 e0 08 ret
2003768: 81 e8 00 00 restore
node->major = rtems_filesystem_dev_major_t(dev);
node->minor = rtems_filesystem_dev_minor_t(dev);
node->mode = mode;
memcpy(dupname, name, namelen);
} else {
errno = ENOMEM;
200376c: 40 00 2d b7 call 200ee48 <__errno>
2003770: b0 10 3f ff mov -1, %i0
2003774: 82 10 20 0c mov 0xc, %g1
2003778: c2 22 00 00 st %g1, [ %o0 ]
200377c: 81 c7 e0 08 ret
2003780: 81 e8 00 00 restore
02003500 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
2003500: 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);
2003504: 03 00 80 89 sethi %hi(0x2022400), %g1
2003508: d0 00 61 ec ld [ %g1 + 0x1ec ], %o0 ! 20225ec <diskdevs_mutex>
200350c: 92 10 20 00 clr %o1
2003510: 94 10 20 00 clr %o2
2003514: 40 00 16 8a call 2008f3c <rtems_semaphore_obtain>
2003518: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
200351c: 80 a2 20 00 cmp %o0, 0
2003520: 12 80 00 05 bne 2003534 <disk_lock+0x34> <== NEVER TAKEN
2003524: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
2003528: 03 00 80 89 sethi %hi(0x2022400), %g1
return RTEMS_SUCCESSFUL;
200352c: 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;
2003530: c4 28 61 e8 stb %g2, [ %g1 + 0x1e8 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
2003534: 81 c7 e0 08 ret
2003538: 81 e8 00 00 restore
0200353c <disk_unlock>:
static void
disk_unlock(void)
{
200353c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
2003540: 03 00 80 89 sethi %hi(0x2022400), %g1
2003544: d0 00 61 ec ld [ %g1 + 0x1ec ], %o0 ! 20225ec <diskdevs_mutex>
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
2003548: 03 00 80 89 sethi %hi(0x2022400), %g1
200354c: c0 28 61 e8 clrb [ %g1 + 0x1e8 ] ! 20225e8 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
2003550: 40 00 16 ca call 2009078 <rtems_semaphore_release>
2003554: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003558: 80 a2 20 00 cmp %o0, 0
200355c: 12 80 00 04 bne 200356c <disk_unlock+0x30> <== NEVER TAKEN
2003560: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
2003564: 81 c7 e0 08 ret
2003568: 81 e8 00 00 restore
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
200356c: 40 00 18 40 call 200966c <rtems_fatal_error_occurred> <== NOT EXECUTED
2003570: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
0200535c <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
200535c: 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);
2005360: 7f ff f4 ab call 200260c <sparc_disable_interrupts>
2005364: 01 00 00 00 nop
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
2005368: c4 06 20 84 ld [ %i0 + 0x84 ], %g2
200536c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
2005370: 80 a0 80 01 cmp %g2, %g1
2005374: 02 80 00 14 be 20053c4 <drainOutput.part.0+0x68> <== ALWAYS TAKEN
2005378: 01 00 00 00 nop
tty->rawOutBufState = rob_wait;
200537c: b8 10 20 02 mov 2, %i4 ! 2 <PROM_START+0x2> <== NOT EXECUTED
2005380: f8 26 20 94 st %i4, [ %i0 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable (level);
2005384: 7f ff f4 a6 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
2005388: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
200538c: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
2005390: 92 10 20 00 clr %o1 <== NOT EXECUTED
2005394: 40 00 09 f3 call 2007b60 <rtems_semaphore_obtain> <== NOT EXECUTED
2005398: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200539c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20053a0: 12 80 00 0b bne 20053cc <drainOutput.part.0+0x70> <== NOT EXECUTED
20053a4: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
20053a8: 7f ff f4 99 call 200260c <sparc_disable_interrupts> <== NOT EXECUTED
20053ac: 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) {
20053b0: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED
20053b4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
20053b8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20053bc: 32 bf ff f2 bne,a 2005384 <drainOutput.part.0+0x28> <== NOT EXECUTED
20053c0: f8 26 20 94 st %i4, [ %i0 + 0x94 ] <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
20053c4: 7f ff f4 96 call 200261c <sparc_enable_interrupts>
20053c8: 91 e8 00 08 restore %g0, %o0, %o0
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
20053cc: 40 00 0b ca call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
02003b90 <dup2>:
*/
int dup2(
int fildes,
int fildes2
)
{
2003b90: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
2003b94: 90 10 00 18 mov %i0, %o0
2003b98: 40 00 01 ea call 2004340 <fstat>
2003b9c: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
2003ba0: 80 a2 3f ff cmp %o0, -1
2003ba4: 02 80 00 0c be 2003bd4 <dup2+0x44>
2003ba8: 90 10 00 19 mov %i1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
2003bac: 40 00 01 e5 call 2004340 <fstat>
2003bb0: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
2003bb4: 80 a2 3f ff cmp %o0, -1
2003bb8: 02 80 00 07 be 2003bd4 <dup2+0x44> <== NEVER TAKEN
2003bbc: 90 10 00 18 mov %i0, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
2003bc0: 92 10 20 00 clr %o1
2003bc4: 40 00 00 af call 2003e80 <fcntl>
2003bc8: 94 10 00 19 mov %i1, %o2
}
2003bcc: 81 c7 e0 08 ret
2003bd0: 91 e8 00 08 restore %g0, %o0, %o0
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
if ( status == -1 )
return -1;
2003bd4: 81 c7 e0 08 ret
2003bd8: 91 e8 3f ff restore %g0, -1, %o0
02006180 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
2006180: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
2006184: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
2006188: 80 88 62 00 btst 0x200, %g1
200618c: 02 80 00 0d be 20061c0 <echo+0x40> <== NEVER TAKEN
2006190: 03 00 80 76 sethi %hi(0x201d800), %g1
iscntrl(c) && (c != '\t') && (c != '\n')) {
2006194: c2 00 61 a8 ld [ %g1 + 0x1a8 ], %g1 ! 201d9a8 <__ctype_ptr__>
2006198: 82 00 40 18 add %g1, %i0, %g1
200619c: c2 08 60 01 ldub [ %g1 + 1 ], %g1
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
20061a0: 80 88 60 20 btst 0x20, %g1
20061a4: 02 80 00 08 be 20061c4 <echo+0x44>
20061a8: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
20061ac: 82 06 3f f7 add %i0, -9, %g1
20061b0: 82 08 60 ff and %g1, 0xff, %g1
20061b4: 80 a0 60 01 cmp %g1, 1
20061b8: 18 80 00 07 bgu 20061d4 <echo+0x54>
20061bc: 82 10 20 5e mov 0x5e, %g1
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
20061c0: 90 10 00 18 mov %i0, %o0
20061c4: 7f ff ff 8f call 2006000 <oproc>
20061c8: 92 10 00 19 mov %i1, %o1
20061cc: 81 c7 e0 08 ret
20061d0: 81 e8 00 00 restore
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
20061d4: b0 1e 20 40 xor %i0, 0x40, %i0
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
20061d8: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
20061dc: f0 2f bf f9 stb %i0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
20061e0: 90 07 bf f8 add %fp, -8, %o0
20061e4: 92 10 20 02 mov 2, %o1
20061e8: 7f ff ff 36 call 2005ec0 <rtems_termios_puts>
20061ec: 94 10 00 19 mov %i1, %o2
tty->column += 2;
20061f0: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
20061f4: 82 00 60 02 add %g1, 2, %g1
20061f8: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
20061fc: 81 c7 e0 08 ret
2006200: 81 e8 00 00 restore
0202827c <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
202827c: 03 00 81 9b sethi %hi(0x2066c00), %g1
2028280: d0 00 61 a8 ld [ %g1 + 0x1a8 ], %o0 ! 2066da8 <group_fp>
2028284: 80 a2 20 00 cmp %o0, 0
2028288: 02 80 00 05 be 202829c <endgrent+0x20> <== NEVER TAKEN
202828c: 01 00 00 00 nop
fclose(group_fp);
2028290: 82 13 c0 00 mov %o7, %g1
2028294: 40 00 4f 47 call 203bfb0 <fclose>
2028298: 9e 10 40 00 mov %g1, %o7
202829c: 81 c3 e0 08 retl <== NOT EXECUTED
020280e0 <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
20280e0: 03 00 81 9b sethi %hi(0x2066c00), %g1
20280e4: d0 00 60 c8 ld [ %g1 + 0xc8 ], %o0 ! 2066cc8 <passwd_fp>
20280e8: 80 a2 20 00 cmp %o0, 0
20280ec: 02 80 00 05 be 2028100 <endpwent+0x20> <== NEVER TAKEN
20280f0: 01 00 00 00 nop
fclose(passwd_fp);
20280f4: 82 13 c0 00 mov %o7, %g1
20280f8: 40 00 4f ae call 203bfb0 <fclose>
20280fc: 9e 10 40 00 mov %g1, %o7
2028100: 81 c3 e0 08 retl <== NOT EXECUTED
02006204 <erase.part.2>:
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
2006204: 9d e3 bf a0 save %sp, -96, %sp
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
2006208: 37 00 80 70 sethi %hi(0x201c000), %i3
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
200620c: ba 10 00 18 mov %i0, %i5
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
2006210: 35 00 80 76 sethi %hi(0x201d800), %i2
rtems_termios_puts ("\b \b", 3, tty);
2006214: 31 00 80 70 sethi %hi(0x201c000), %i0
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
2006218: b6 16 e1 00 or %i3, 0x100, %i3
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
200621c: 10 80 00 0f b 2006258 <erase.part.2+0x54>
2006220: b0 16 21 08 or %i0, 0x108, %i0
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
2006224: 90 12 21 08 or %o0, 0x108, %o0
2006228: 92 10 20 03 mov 3, %o1
200622c: 7f ff ff 25 call 2005ec0 <rtems_termios_puts>
2006230: 94 10 00 1d mov %i5, %o2
if (tty->column)
2006234: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006238: 80 a0 60 00 cmp %g1, 0
200623c: 02 80 00 05 be 2006250 <erase.part.2+0x4c> <== NEVER TAKEN
2006240: 80 a6 60 00 cmp %i1, 0
tty->column--;
2006244: 82 00 7f ff add %g1, -1, %g1
2006248: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
200624c: 80 a6 60 00 cmp %i1, 0
2006250: 02 80 00 58 be 20063b0 <erase.part.2+0x1ac>
2006254: 01 00 00 00 nop
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
2006258: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
200625c: 80 a0 a0 00 cmp %g2, 0
2006260: 02 80 00 54 be 20063b0 <erase.part.2+0x1ac>
2006264: 84 00 bf ff add %g2, -1, %g2
unsigned char c = tty->cbuf[--tty->ccount];
2006268: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
if (tty->termios.c_lflag & ECHO) {
200626c: c6 07 60 3c ld [ %i5 + 0x3c ], %g3
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
2006270: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
2006274: 80 88 e0 08 btst 8, %g3
2006278: 02 bf ff f5 be 200624c <erase.part.2+0x48> <== NEVER TAKEN
200627c: c2 09 00 02 ldub [ %g4 + %g2 ], %g1
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
2006280: 80 a6 60 00 cmp %i1, 0
2006284: 12 80 00 05 bne 2006298 <erase.part.2+0x94>
2006288: 82 08 60 ff and %g1, 0xff, %g1
200628c: 80 88 e0 10 btst 0x10, %g3
2006290: 22 80 00 4d be,a 20063c4 <erase.part.2+0x1c0> <== NEVER TAKEN
2006294: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
2006298: 80 a0 60 09 cmp %g1, 9
200629c: 02 80 00 1e be 2006314 <erase.part.2+0x110>
20062a0: 80 a0 a0 00 cmp %g2, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
20062a4: c4 06 a1 a8 ld [ %i2 + 0x1a8 ], %g2
20062a8: b8 00 60 01 add %g1, 1, %i4
20062ac: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
20062b0: 80 88 60 20 btst 0x20, %g1
20062b4: 02 bf ff dc be 2006224 <erase.part.2+0x20> <== ALWAYS TAKEN
20062b8: 11 00 80 70 sethi %hi(0x201c000), %o0
20062bc: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED
20062c0: 02 bf ff e4 be 2006250 <erase.part.2+0x4c> <== NOT EXECUTED
20062c4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
20062c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20062cc: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
20062d0: 7f ff fe fc call 2005ec0 <rtems_termios_puts> <== NOT EXECUTED
20062d4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
20062d8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
20062dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20062e0: 12 80 00 3b bne 20063cc <erase.part.2+0x1c8> <== NOT EXECUTED
20062e4: 11 00 80 70 sethi %hi(0x201c000), %o0 <== NOT EXECUTED
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
20062e8: c2 06 a1 a8 ld [ %i2 + 0x1a8 ], %g1 <== NOT EXECUTED
20062ec: c2 08 40 1c ldub [ %g1 + %i4 ], %g1 <== NOT EXECUTED
20062f0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
20062f4: 22 bf ff cd be,a 2006228 <erase.part.2+0x24> <== NOT EXECUTED
20062f8: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
20062fc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
2006300: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
2006304: 32 bf ff c9 bne,a 2006228 <erase.part.2+0x24> <== NOT EXECUTED
2006308: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
200630c: 10 bf ff d1 b 2006250 <erase.part.2+0x4c> <== NOT EXECUTED
2006310: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2006314: 02 80 00 17 be 2006370 <erase.part.2+0x16c>
2006318: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
200631c: da 06 a1 a8 ld [ %i2 + 0x1a8 ], %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;
2006320: 82 10 20 00 clr %g1
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)
2006324: 10 80 00 07 b 2006340 <erase.part.2+0x13c>
2006328: 98 08 e2 00 and %g3, 0x200, %o4
200632c: 32 80 00 02 bne,a 2006334 <erase.part.2+0x130> <== NOT EXECUTED
2006330: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2006334: 80 a0 80 01 cmp %g2, %g1
2006338: 22 80 00 0f be,a 2006374 <erase.part.2+0x170> <== NEVER TAKEN
200633c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
c = tty->cbuf[i++];
2006340: c6 09 00 01 ldub [ %g4 + %g1 ], %g3
2006344: 82 00 60 01 inc %g1
if (c == '\t') {
2006348: 80 a0 e0 09 cmp %g3, 9
200634c: 02 80 00 1b be 20063b8 <erase.part.2+0x1b4>
2006350: 9e 03 40 03 add %o5, %g3, %o7
col = (col | 7) + 1;
} else if (iscntrl (c)) {
2006354: de 0b e0 01 ldub [ %o7 + 1 ], %o7
2006358: 80 8b e0 20 btst 0x20, %o7
200635c: 12 bf ff f4 bne 200632c <erase.part.2+0x128> <== NEVER TAKEN
2006360: 80 a3 20 00 cmp %o4, 0
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2006364: 80 a0 80 01 cmp %g2, %g1
2006368: 12 bf ff f6 bne 2006340 <erase.part.2+0x13c>
200636c: b8 07 20 01 inc %i4
}
/*
* Back up over the tab
*/
while (tty->column > col) {
2006370: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006374: 80 a0 40 1c cmp %g1, %i4
2006378: 04 bf ff b6 ble 2006250 <erase.part.2+0x4c> <== NEVER TAKEN
200637c: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
2006380: 90 10 00 1b mov %i3, %o0
2006384: 92 10 20 01 mov 1, %o1
2006388: 7f ff fe ce call 2005ec0 <rtems_termios_puts>
200638c: 94 10 00 1d mov %i5, %o2
tty->column--;
2006390: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006394: 82 00 7f ff add %g1, -1, %g1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
2006398: 80 a0 40 1c cmp %g1, %i4
200639c: 14 bf ff f9 bg 2006380 <erase.part.2+0x17c>
20063a0: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
20063a4: 80 a6 60 00 cmp %i1, 0
20063a8: 32 bf ff ad bne,a 200625c <erase.part.2+0x58> <== ALWAYS TAKEN
20063ac: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
20063b0: 81 c7 e0 08 ret
20063b4: 81 e8 00 00 restore
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
20063b8: b8 17 20 07 or %i4, 7, %i4
20063bc: 10 bf ff de b 2006334 <erase.part.2+0x130>
20063c0: b8 07 20 01 inc %i4
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
20063c4: 7f ff ff 6f call 2006180 <echo> <== NOT EXECUTED
20063c8: 93 e8 00 1d restore %g0, %i5, %o1 <== NOT EXECUTED
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
20063cc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20063d0: 10 bf ff c6 b 20062e8 <erase.part.2+0xe4> <== NOT EXECUTED
20063d4: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
02004890 <eval_path_start>:
size_t pathlen,
int eval_flags,
rtems_filesystem_global_location_t *const *global_root_ptr,
rtems_filesystem_global_location_t *const *global_current_ptr
)
{
2004890: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
2004894: 92 10 20 00 clr %o1
2004898: 90 10 00 18 mov %i0, %o0
200489c: 40 00 31 5d call 2010e10 <memset>
20048a0: 94 10 20 38 mov 0x38, %o2
ctx->path = path;
20048a4: f2 26 00 00 st %i1, [ %i0 ]
ctx->pathlen = pathlen;
20048a8: f4 26 20 04 st %i2, [ %i0 + 4 ]
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_global_location_t *const *global_root_ptr,
rtems_filesystem_global_location_t *const *global_current_ptr
)
{
if (ctx->pathlen > 0) {
20048ac: 80 a6 a0 00 cmp %i2, 0
20048b0: 02 80 00 21 be 2004934 <eval_path_start+0xa4>
20048b4: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
20048b8: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
20048bc: 40 00 01 a3 call 2004f48 <rtems_filesystem_global_location_obtain>
20048c0: 90 10 00 1c mov %i4, %o0
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
20048c4: 83 2e e0 18 sll %i3, 0x18, %g1
20048c8: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
20048cc: 80 a0 60 5c cmp %g1, 0x5c
20048d0: 12 80 00 32 bne 2004998 <eval_path_start+0x108> <== ALWAYS TAKEN
20048d4: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
++ctx->path;
20048d8: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
--ctx->pathlen;
20048dc: c2 06 20 04 ld [ %i0 + 4 ], %g1
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
20048e0: 84 00 a0 01 inc %g2
--ctx->pathlen;
20048e4: 82 00 7f ff add %g1, -1, %g1
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
20048e8: c4 26 00 00 st %g2, [ %i0 ]
--ctx->pathlen;
20048ec: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
20048f0: 40 00 01 96 call 2004f48 <rtems_filesystem_global_location_obtain>
20048f4: 90 06 20 30 add %i0, 0x30, %o0
20048f8: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
20048fc: 82 10 00 08 mov %o0, %g1
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2004900: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
2004904: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2004908: c2 00 40 00 ld [ %g1 ], %g1
200490c: 9f c0 40 00 call %g1
2004910: ba 06 20 18 add %i0, 0x18, %i5
set_startloc(ctx, global_root_ptr, global_current_ptr);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(
2004914: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
2004918: 40 00 1f 81 call 200c71c <rtems_filesystem_location_clone>
200491c: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
2004920: 90 10 00 18 mov %i0, %o0
2004924: 7f ff ff be call 200481c <rtems_filesystem_eval_path_continue>
2004928: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
200492c: 81 c7 e0 08 ret
2004930: 81 e8 00 00 restore
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
2004934: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
2004938: 40 00 01 84 call 2004f48 <rtems_filesystem_global_location_obtain>
200493c: 90 07 bf fc add %fp, -4, %o0
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
2004940: c0 27 bf fc clr [ %fp + -4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
global_current_ptr
);
}
} else {
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
2004944: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
return rtems_filesystem_global_location_obtain( &global_loc );
2004948: 40 00 01 80 call 2004f48 <rtems_filesystem_global_location_obtain>
200494c: 90 07 bf fc add %fp, -4, %o0
ctx->startloc = rtems_filesystem_global_location_obtain_null();
errno = ENOENT;
2004950: 40 00 2e a2 call 20103d8 <__errno>
2004954: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
2004958: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
200495c: 84 10 20 02 mov 2, %g2
2004960: c4 22 00 00 st %g2, [ %o0 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2004964: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
2004968: c2 02 20 0c ld [ %o0 + 0xc ], %g1
200496c: c2 00 40 00 ld [ %g1 ], %g1
2004970: 9f c0 40 00 call %g1
2004974: ba 06 20 18 add %i0, 0x18, %i5
set_startloc(ctx, global_root_ptr, global_current_ptr);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(
2004978: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
200497c: 40 00 1f 68 call 200c71c <rtems_filesystem_location_clone>
2004980: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
2004984: 90 10 00 18 mov %i0, %o0
2004988: 7f ff ff a5 call 200481c <rtems_filesystem_eval_path_continue>
200498c: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
2004990: 81 c7 e0 08 ret
2004994: 81 e8 00 00 restore
if (ctx->pathlen > 0) {
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
2004998: 80 a0 60 2f cmp %g1, 0x2f
200499c: 22 bf ff d0 be,a 20048dc <eval_path_start+0x4c>
20049a0: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
&ctx->rootloc
);
} else {
ctx->startloc = rtems_filesystem_global_location_obtain(
20049a4: 40 00 01 69 call 2004f48 <rtems_filesystem_global_location_obtain>
20049a8: 90 10 00 1d mov %i5, %o0
20049ac: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
20049b0: 82 10 00 08 mov %o0, %g1
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
20049b4: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
20049b8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
20049bc: c2 00 40 00 ld [ %g1 ], %g1
20049c0: 9f c0 40 00 call %g1
20049c4: ba 06 20 18 add %i0, 0x18, %i5
set_startloc(ctx, global_root_ptr, global_current_ptr);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(
20049c8: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
20049cc: 40 00 1f 54 call 200c71c <rtems_filesystem_location_clone>
20049d0: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
20049d4: 90 10 00 18 mov %i0, %o0
20049d8: 7f ff ff 91 call 200481c <rtems_filesystem_eval_path_continue>
20049dc: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
20049e0: 81 c7 e0 08 ret
20049e4: 81 e8 00 00 restore
02013fa4 <fat_buf_access>:
int
fat_buf_access(fat_fs_info_t *fs_info,
const uint32_t sec_num,
const int op_type,
uint8_t **sec_buf)
{
2013fa4: 9d e3 bf a0 save %sp, -96, %sp
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
2013fa8: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
2013fac: c4 0e 20 0c ldub [ %i0 + 0xc ], %g2
sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset (fs_info,
sec_num,
0);
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
2013fb0: c6 0e 20 89 ldub [ %i0 + 0x89 ], %g3
2013fb4: 84 20 80 01 sub %g2, %g1, %g2
2013fb8: 80 a0 e0 00 cmp %g3, 0
2013fbc: bb 36 40 02 srl %i1, %g2, %i5
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
2013fc0: 85 2f 40 02 sll %i5, %g2, %g2
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
2013fc4: 84 26 40 02 sub %i1, %g2, %g2
2013fc8: 02 80 00 06 be 2013fe0 <fat_buf_access+0x3c>
2013fcc: b9 28 80 01 sll %g2, %g1, %i4
2013fd0: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2013fd4: 80 a0 40 19 cmp %g1, %i1
2013fd8: 22 80 00 12 be,a 2014020 <fat_buf_access+0x7c>
2013fdc: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
{
fat_buf_release(fs_info);
2013fe0: 7f ff ff 7a call 2013dc8 <fat_buf_release>
2013fe4: 90 10 00 18 mov %i0, %o0
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2013fe8: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
2013fec: 92 10 00 1d mov %i5, %o1
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
{
fat_buf_release(fs_info);
if (op_type == FAT_OP_TYPE_READ)
2013ff0: 80 a6 a0 01 cmp %i2, 1
2013ff4: 02 80 00 10 be 2014034 <fat_buf_access+0x90>
2013ff8: 94 06 20 8c add %i0, 0x8c, %o2
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);
2013ffc: 7f ff f6 c9 call 2011b20 <rtems_bdbuf_get>
2014000: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
2014004: 80 a2 20 00 cmp %o0, 0
2014008: 12 80 00 0f bne 2014044 <fat_buf_access+0xa0> <== NEVER TAKEN
201400c: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = sec_num;
2014010: f2 26 20 84 st %i1, [ %i0 + 0x84 ]
fs_info->c.modified = 0;
2014014: c0 2e 20 88 clrb [ %i0 + 0x88 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
2014018: c2 2e 20 89 stb %g1, [ %i0 + 0x89 ]
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
201401c: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
2014020: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2014024: b8 00 40 1c add %g1, %i4, %i4
2014028: f8 26 c0 00 st %i4, [ %i3 ]
return RC_OK;
}
201402c: 81 c7 e0 08 ret
2014030: 91 e8 20 00 restore %g0, 0, %o0
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
{
fat_buf_release(fs_info);
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2014034: 7f ff f6 fb call 2011c20 <rtems_bdbuf_read>
2014038: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
201403c: 10 bf ff f3 b 2014008 <fat_buf_access+0x64>
2014040: 80 a2 20 00 cmp %o0, 0
rtems_set_errno_and_return_minus_one(EIO);
2014044: 40 00 24 22 call 201d0cc <__errno> <== NOT EXECUTED
2014048: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201404c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2014050: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014054: 81 c7 e0 08 ret <== NOT EXECUTED
2014058: 81 e8 00 00 restore <== NOT EXECUTED
02013dc8 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2013dc8: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
2013dcc: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2013dd0: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
2013dd4: 80 a0 60 00 cmp %g1, 0
2013dd8: 02 80 00 6b be 2013f84 <fat_buf_release+0x1bc>
2013ddc: b0 10 20 00 clr %i0
return RC_OK;
if (fs_info->c.modified)
2013de0: c2 0f 60 88 ldub [ %i5 + 0x88 ], %g1
2013de4: 80 a0 60 00 cmp %g1, 0
2013de8: 02 80 00 47 be 2013f04 <fat_buf_release+0x13c>
2013dec: 01 00 00 00 nop
{
uint32_t sec_num = fs_info->c.blk_num;
2013df0: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
2013df4: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
2013df8: 80 a0 40 02 cmp %g1, %g2
2013dfc: 0a 80 00 06 bcs 2013e14 <fat_buf_release+0x4c>
2013e00: b8 10 20 00 clr %i4
2013e04: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2013e08: 80 a0 40 02 cmp %g1, %g2
2013e0c: 2a 80 00 46 bcs,a 2013f24 <fat_buf_release+0x15c>
2013e10: c4 0f 60 54 ldub [ %i5 + 0x54 ], %g2
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
2013e14: 7f ff f8 40 call 2011f14 <rtems_bdbuf_release_modified>
2013e18: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
2013e1c: 80 a2 20 00 cmp %o0, 0
2013e20: 12 80 00 5b bne 2013f8c <fat_buf_release+0x1c4> <== NEVER TAKEN
2013e24: 80 8f 20 ff btst 0xff, %i4
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
2013e28: 02 80 00 3c be 2013f18 <fat_buf_release+0x150>
2013e2c: c0 2f 60 88 clrb [ %i5 + 0x88 ]
2013e30: c2 0f 60 54 ldub [ %i5 + 0x54 ], %g1
2013e34: 80 a0 60 00 cmp %g1, 0
2013e38: 32 80 00 39 bne,a 2013f1c <fat_buf_release+0x154> <== NEVER TAKEN
2013e3c: c0 2f 60 89 clrb [ %i5 + 0x89 ] <== NOT EXECUTED
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
2013e40: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
2013e44: 80 a0 60 01 cmp %g1, 1
2013e48: 08 80 00 34 bleu 2013f18 <fat_buf_release+0x150> <== NEVER TAKEN
2013e4c: b6 10 20 01 mov 1, %i3
2013e50: 10 80 00 16 b 2013ea8 <fat_buf_release+0xe0>
2013e54: 90 10 20 01 mov 1, %o0
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
2013e58: 7f ff f7 72 call 2011c20 <rtems_bdbuf_read>
2013e5c: 94 07 bf fc add %fp, -4, %o2
}
if ( sc != RTEMS_SUCCESSFUL)
2013e60: 80 a2 20 00 cmp %o0, 0
2013e64: 12 80 00 44 bne 2013f74 <fat_buf_release+0x1ac> <== NEVER TAKEN
2013e68: c2 07 bf fc ld [ %fp + -4 ], %g1
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
2013e6c: d2 07 60 90 ld [ %i5 + 0x90 ], %o1
2013e70: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2013e74: d4 17 40 00 lduh [ %i5 ], %o2
2013e78: 40 00 27 54 call 201dbc8 <memcpy>
2013e7c: 90 02 00 1c add %o0, %i4, %o0
sc = rtems_bdbuf_release_modified(bd);
2013e80: d0 07 bf fc ld [ %fp + -4 ], %o0
2013e84: 7f ff f8 24 call 2011f14 <rtems_bdbuf_release_modified>
2013e88: b6 06 e0 01 inc %i3
if ( sc != RTEMS_SUCCESSFUL)
2013e8c: 80 a2 20 00 cmp %o0, 0
2013e90: 12 80 00 39 bne 2013f74 <fat_buf_release+0x1ac> <== NEVER TAKEN
2013e94: 90 0e e0 ff and %i3, 0xff, %o0
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
2013e98: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
2013e9c: 80 a2 00 01 cmp %o0, %g1
2013ea0: 3a 80 00 1f bcc,a 2013f1c <fat_buf_release+0x154> <== ALWAYS TAKEN
2013ea4: c0 2f 60 89 clrb [ %i5 + 0x89 ]
{
rtems_bdbuf_buffer *bd;
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
2013ea8: 7f ff b9 b9 call 200258c <.umul>
2013eac: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
2013eb0: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
2013eb4: c6 07 60 84 ld [ %i5 + 0x84 ], %g3
2013eb8: c4 0f 60 0c ldub [ %i5 + 0xc ], %g2
2013ebc: 90 02 00 03 add %o0, %g3, %o0
2013ec0: 84 20 80 01 sub %g2, %g1, %g2
2013ec4: 93 32 00 02 srl %o0, %g2, %o1
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
2013ec8: 85 2a 40 02 sll %o1, %g2, %g2
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
2013ecc: 90 22 00 02 sub %o0, %g2, %o0
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
2013ed0: b9 2a 00 01 sll %o0, %g1, %i4
blk = fat_sector_num_to_block_num(fs_info, sec_num);
blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (blk_ofs == 0
2013ed4: 80 a7 20 00 cmp %i4, 0
2013ed8: 12 bf ff e0 bne 2013e58 <fat_buf_release+0x90>
2013edc: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
2013ee0: c4 17 40 00 lduh [ %i5 ], %g2
2013ee4: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
2013ee8: 80 a0 80 01 cmp %g2, %g1
2013eec: 12 bf ff db bne 2013e58 <fat_buf_release+0x90>
2013ef0: 01 00 00 00 nop
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
2013ef4: 7f ff f7 0b call 2011b20 <rtems_bdbuf_get>
2013ef8: 94 07 bf fc add %fp, -4, %o2
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
}
if ( sc != RTEMS_SUCCESSFUL)
2013efc: 10 bf ff da b 2013e64 <fat_buf_release+0x9c>
2013f00: 80 a2 20 00 cmp %o0, 0
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2013f04: 7f ff f7 cc call 2011e34 <rtems_bdbuf_release>
2013f08: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
2013f0c: 80 a2 20 00 cmp %o0, 0
2013f10: 12 80 00 1f bne 2013f8c <fat_buf_release+0x1c4> <== NEVER TAKEN
2013f14: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
2013f18: c0 2f 60 89 clrb [ %i5 + 0x89 ]
return RC_OK;
2013f1c: 81 c7 e0 08 ret
2013f20: 91 e8 20 00 restore %g0, 0, %o0
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
2013f24: c8 0f 60 02 ldub [ %i5 + 2 ], %g4
2013f28: c6 0f 60 0c ldub [ %i5 + 0xc ], %g3
uint32_t blk = fat_sector_num_to_block_num(fs_info, sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
2013f2c: 80 a0 a0 00 cmp %g2, 0
2013f30: 12 bf ff b9 bne 2013e14 <fat_buf_release+0x4c> <== NEVER TAKEN
2013f34: b8 10 20 01 mov 1, %i4
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
2013f38: c4 07 60 8c ld [ %i5 + 0x8c ], %g2
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
2013f3c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2013f40: d2 00 a0 1c ld [ %g2 + 0x1c ], %o1
2013f44: d4 17 40 00 lduh [ %i5 ], %o2
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
2013f48: 84 09 20 ff and %g4, 0xff, %g2
2013f4c: 86 08 e0 ff and %g3, 0xff, %g3
2013f50: 86 20 c0 02 sub %g3, %g2, %g3
2013f54: 89 30 40 03 srl %g1, %g3, %g4
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
2013f58: 87 29 00 03 sll %g4, %g3, %g3
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
2013f5c: 82 20 40 03 sub %g1, %g3, %g1
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
2013f60: 85 28 40 02 sll %g1, %g2, %g2
return RC_OK;
if (fs_info->c.modified)
{
uint32_t sec_num = fs_info->c.blk_num;
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
2013f64: b8 10 20 01 mov 1, %i4
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
2013f68: 40 00 27 18 call 201dbc8 <memcpy>
2013f6c: 92 02 40 02 add %o1, %g2, %o1
2013f70: 30 bf ff a9 b,a 2013e14 <fat_buf_release+0x4c>
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(bd);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
2013f74: 40 00 24 56 call 201d0cc <__errno> <== NOT EXECUTED
2013f78: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013f7c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
2013f80: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013f84: 81 c7 e0 08 ret
2013f88: 81 e8 00 00 restore
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
2013f8c: 40 00 24 50 call 201d0cc <__errno> <== NOT EXECUTED
2013f90: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013f94: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2013f98: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013f9c: 81 c7 e0 08 ret <== NOT EXECUTED
2013fa0: 81 e8 00 00 restore <== NOT EXECUTED
0201418c <fat_cluster_set>:
fat_fs_info_t *fs_info,
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
201418c: 9d e3 bf 98 save %sp, -104, %sp
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
2014190: c2 16 20 06 lduh [ %i0 + 6 ], %g1
2014194: 82 20 40 1a sub %g1, %i2, %g1
2014198: 80 a6 c0 01 cmp %i3, %g1
201419c: 38 80 00 02 bgu,a 20141a4 <fat_cluster_set+0x18> <== NEVER TAKEN
20141a0: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
20141a4: 80 a6 60 00 cmp %i1, 0
20141a8: 32 80 00 06 bne,a 20141c0 <fat_cluster_set+0x34> <== ALWAYS TAKEN
20141ac: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
20141b0: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1 <== NOT EXECUTED
20141b4: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
20141b8: 12 80 00 50 bne 20142f8 <fat_cluster_set+0x16c> <== NOT EXECUTED
20141bc: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
20141c0: e0 0e 20 02 ldub [ %i0 + 2 ], %l0
20141c4: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
20141c8: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
20141cc: a0 20 40 10 sub %g1, %l0, %l0
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
20141d0: b2 06 7f fe add %i1, -2, %i1
20141d4: a1 30 c0 10 srl %g3, %l0, %l0
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
20141d8: 84 20 80 01 sub %g2, %g1, %g2
20141dc: b3 2e 40 02 sll %i1, %g2, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
20141e0: a0 04 00 19 add %l0, %i1, %l0
const uint8_t pattern)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
20141e4: 85 36 80 01 srl %i2, %g1, %g2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
20141e8: 83 28 80 01 sll %g2, %g1, %g1
ssize_t bytes_written = 0;
20141ec: a2 10 20 00 clr %l1
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
20141f0: b4 26 80 01 sub %i2, %g1, %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
20141f4: a0 00 80 10 add %g2, %l0, %l0
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
ssize_t rc = RC_OK;
20141f8: 82 10 20 00 clr %g1
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
20141fc: 80 a6 e0 00 cmp %i3, 0
2014200: 02 80 00 25 be 2014294 <fat_cluster_set+0x108> <== NEVER TAKEN
2014204: a4 10 20 01 mov 1, %l2
2014208: 80 a0 60 00 cmp %g1, 0
201420c: 32 80 00 39 bne,a 20142f0 <fat_cluster_set+0x164> <== NEVER TAKEN
2014210: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
&& (0 < bytes_to_write))
{
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
2014214: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
2014218: 82 20 80 1a sub %g2, %i2, %g1
201421c: 80 a0 40 1b cmp %g1, %i3
2014220: 08 80 00 03 bleu 201422c <fat_cluster_set+0xa0> <== ALWAYS TAKEN
2014224: ba 10 00 01 mov %g1, %i5
2014228: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
201422c: 80 a7 40 01 cmp %i5, %g1
2014230: 08 80 00 03 bleu 201423c <fat_cluster_set+0xb0> <== ALWAYS TAKEN
2014234: b2 10 00 1d mov %i5, %i1
2014238: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
201423c: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
2014240: 80 a6 60 00 cmp %i1, 0
2014244: 02 80 00 24 be 20142d4 <fat_cluster_set+0x148> <== NEVER TAKEN
2014248: d2 0e 20 0c ldub [ %i0 + 0xc ], %o1
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
201424c: 92 22 40 01 sub %o1, %g1, %o1
{
if (bytes_to_write == fs_info->vol.bytes_per_block)
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
2014250: 90 10 00 18 mov %i0, %o0
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
{
if (bytes_to_write == fs_info->vol.bytes_per_block)
2014254: 80 a0 80 19 cmp %g2, %i1
2014258: 02 80 00 21 be 20142dc <fat_cluster_set+0x150>
201425c: 93 2c 00 09 sll %l0, %o1, %o1
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
2014260: 94 10 20 01 mov 1, %o2
2014264: 7f ff ff 50 call 2013fa4 <fat_buf_access>
2014268: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
201426c: 80 a2 20 00 cmp %o0, 0
2014270: 22 80 00 14 be,a 20142c0 <fat_cluster_set+0x134> <== ALWAYS TAKEN
2014274: d0 07 bf fc ld [ %fp + -4 ], %o0
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
2014278: 80 a2 00 1d cmp %o0, %i5
201427c: 02 80 00 0b be 20142a8 <fat_cluster_set+0x11c> <== ALWAYS TAKEN
2014280: 82 10 3f ff mov -1, %g1
2014284: b4 10 20 00 clr %i2 <== NOT EXECUTED
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
2014288: 80 a6 e0 00 cmp %i3, 0
201428c: 12 bf ff e0 bne 201420c <fat_cluster_set+0x80> <== NEVER TAKEN
2014290: 80 a0 60 00 cmp %g1, 0
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
2014294: 80 a0 60 00 cmp %g1, 0
2014298: 12 80 00 16 bne 20142f0 <fat_cluster_set+0x164> <== NEVER TAKEN
201429c: b0 10 3f ff mov -1, %i0
20142a0: 81 c7 e0 08 ret
20142a4: 91 e8 00 11 restore %g0, %l1, %o0
pattern);
if (c != ret)
rc = -1;
else
{
bytes_to_write -= ret;
20142a8: b6 26 c0 08 sub %i3, %o0, %i3
bytes_written += ret;
20142ac: a2 04 40 08 add %l1, %o0, %l1
++cur_blk;
20142b0: a0 04 20 01 inc %l0
20142b4: 82 10 20 00 clr %g1
20142b8: 10 bf ff f4 b 2014288 <fat_cluster_set+0xfc>
20142bc: b4 10 20 00 clr %i2
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
{
memset(blk_buf + offset, pattern, bytes_to_write);
20142c0: 92 10 00 1c mov %i4, %o1
20142c4: 90 02 00 1a add %o0, %i2, %o0
20142c8: 40 00 26 7d call 201dcbc <memset>
20142cc: 94 10 00 19 mov %i1, %o2
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
20142d0: e4 2e 20 88 stb %l2, [ %i0 + 0x88 ]
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
20142d4: 10 bf ff e9 b 2014278 <fat_cluster_set+0xec>
20142d8: 90 10 00 19 mov %i1, %o0
if (0 < bytes_to_write)
{
if (bytes_to_write == fs_info->vol.bytes_per_block)
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
20142dc: 94 10 20 02 mov 2, %o2
20142e0: 7f ff ff 31 call 2013fa4 <fat_buf_access>
20142e4: 96 07 bf fc add %fp, -4, %o3
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
20142e8: 10 bf ff e2 b 2014270 <fat_cluster_set+0xe4>
20142ec: 80 a2 20 00 cmp %o0, 0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
20142f0: 81 c7 e0 08 ret <== NOT EXECUTED
20142f4: 81 e8 00 00 restore <== NOT EXECUTED
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
20142f8: c4 0e 20 02 ldub [ %i0 + 2 ], %g2 <== NOT EXECUTED
20142fc: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED
2014300: 84 20 40 02 sub %g1, %g2, %g2 <== NOT EXECUTED
2014304: 10 bf ff b8 b 20141e4 <fat_cluster_set+0x58> <== NOT EXECUTED
2014308: a1 34 00 02 srl %l0, %g2, %l0 <== NOT EXECUTED
0201430c <fat_cluster_write>:
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
201430c: 9d e3 bf 98 save %sp, -104, %sp
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
2014310: c2 16 20 06 lduh [ %i0 + 6 ], %g1
2014314: 82 20 40 1a sub %g1, %i2, %g1
2014318: 80 a6 c0 01 cmp %i3, %g1
201431c: 38 80 00 02 bgu,a 2014324 <fat_cluster_write+0x18> <== NEVER TAKEN
2014320: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2014324: 80 a6 60 00 cmp %i1, 0
2014328: 32 80 00 06 bne,a 2014340 <fat_cluster_write+0x34>
201432c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
2014330: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
2014334: 80 88 60 03 btst 3, %g1
2014338: 12 80 00 52 bne 2014480 <fat_cluster_write+0x174> <== ALWAYS TAKEN
201433c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
2014340: e2 0e 20 02 ldub [ %i0 + 2 ], %l1
2014344: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
2014348: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
201434c: a2 20 40 11 sub %g1, %l1, %l1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
2014350: b2 06 7f fe add %i1, -2, %i1
2014354: a3 30 c0 11 srl %g3, %l1, %l1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
2014358: 84 20 80 01 sub %g2, %g1, %g2
201435c: b3 2e 40 02 sll %i1, %g2, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
2014360: a2 04 40 19 add %l1, %i1, %l1
const bool overwrite_cluster)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
2014364: 85 36 80 01 srl %i2, %g1, %g2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
2014368: 83 28 80 01 sll %g2, %g1, %g1
ssize_t bytes_written = 0;
201436c: a4 10 20 00 clr %l2
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
2014370: b4 26 80 01 sub %i2, %g1, %i2
ssize_t bytes_written = 0;
uint8_t *buffer = (uint8_t*)buff;
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
2014374: a2 00 80 11 add %g2, %l1, %l1
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
ssize_t rc = RC_OK;
2014378: 82 10 20 00 clr %g1
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
201437c: 80 a6 e0 00 cmp %i3, 0
2014380: 02 80 00 27 be 201441c <fat_cluster_write+0x110> <== NEVER TAKEN
2014384: a6 10 20 01 mov 1, %l3
2014388: 80 a0 60 00 cmp %g1, 0
201438c: 32 80 00 3b bne,a 2014478 <fat_cluster_write+0x16c> <== NEVER TAKEN
2014390: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
2014394: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
2014398: 82 20 80 1a sub %g2, %i2, %g1
201439c: 80 a0 40 1b cmp %g1, %i3
20143a0: 08 80 00 03 bleu 20143ac <fat_cluster_write+0xa0>
20143a4: b2 10 00 01 mov %g1, %i1
20143a8: b2 10 00 1b mov %i3, %i1
const uint32_t count,
const void *buf,
const bool overwrite_block)
{
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
20143ac: 80 a6 40 01 cmp %i1, %g1
20143b0: 08 80 00 03 bleu 20143bc <fat_cluster_write+0xb0> <== ALWAYS TAKEN
20143b4: a0 10 00 19 mov %i1, %l0
20143b8: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
20143bc: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
20143c0: 80 a4 20 00 cmp %l0, 0
20143c4: 02 80 00 26 be 201445c <fat_cluster_write+0x150> <== NEVER TAKEN
20143c8: d2 0e 20 0c ldub [ %i0 + 0xc ], %o1
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
20143cc: 92 22 40 01 sub %o1, %g1, %o1
{
if ( overwrite_block
|| (bytes_to_write == fs_info->vol.bytes_per_block))
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
20143d0: 90 10 00 18 mov %i0, %o0
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
{
if ( overwrite_block
20143d4: 80 a7 60 00 cmp %i5, 0
20143d8: 12 80 00 23 bne 2014464 <fat_cluster_write+0x158>
20143dc: 93 2c 40 09 sll %l1, %o1, %o1
|| (bytes_to_write == fs_info->vol.bytes_per_block))
20143e0: 80 a0 80 10 cmp %g2, %l0
20143e4: 02 80 00 20 be 2014464 <fat_cluster_write+0x158>
20143e8: 94 10 20 01 mov 1, %o2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
20143ec: 7f ff fe ee call 2013fa4 <fat_buf_access>
20143f0: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
20143f4: 80 a2 20 00 cmp %o0, 0
20143f8: 22 80 00 14 be,a 2014448 <fat_cluster_write+0x13c> <== ALWAYS TAKEN
20143fc: d0 07 bf fc ld [ %fp + -4 ], %o0
cur_blk,
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
2014400: 80 a2 00 19 cmp %o0, %i1
2014404: 02 80 00 0b be 2014430 <fat_cluster_write+0x124> <== ALWAYS TAKEN
2014408: 82 10 3f ff mov -1, %g1
201440c: b4 10 20 00 clr %i2 <== NOT EXECUTED
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
2014410: 80 a6 e0 00 cmp %i3, 0
2014414: 12 bf ff de bne 201438c <fat_cluster_write+0x80> <== NEVER TAKEN
2014418: 80 a0 60 00 cmp %g1, 0
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
201441c: 80 a0 60 00 cmp %g1, 0
2014420: 12 80 00 16 bne 2014478 <fat_cluster_write+0x16c> <== NEVER TAKEN
2014424: b0 10 3f ff mov -1, %i0
2014428: 81 c7 e0 08 ret
201442c: 91 e8 00 12 restore %g0, %l2, %o0
overwrite_cluster);
if (c != ret)
rc = -1;
else
{
bytes_to_write -= ret;
2014430: b6 26 c0 08 sub %i3, %o0, %i3
bytes_written += ret;
2014434: a4 04 80 08 add %l2, %o0, %l2
++cur_blk;
2014438: a2 04 60 01 inc %l1
201443c: 82 10 20 00 clr %g1
2014440: 10 bf ff f4 b 2014410 <fat_cluster_write+0x104>
2014444: b4 10 20 00 clr %i2
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
{
memcpy(blk_buf + offset, buf, bytes_to_write);
2014448: 92 07 00 12 add %i4, %l2, %o1
201444c: 90 02 00 1a add %o0, %i2, %o0
2014450: 40 00 25 de call 201dbc8 <memcpy>
2014454: 94 10 00 10 mov %l0, %o2
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
2014458: e6 2e 20 88 stb %l3, [ %i0 + 0x88 ]
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
201445c: 10 bf ff e9 b 2014400 <fat_cluster_write+0xf4>
2014460: 90 10 00 10 mov %l0, %o0
if (0 < bytes_to_write)
{
if ( overwrite_block
|| (bytes_to_write == fs_info->vol.bytes_per_block))
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
2014464: 94 10 20 02 mov 2, %o2
2014468: 7f ff fe cf call 2013fa4 <fat_buf_access>
201446c: 96 07 bf fc add %fp, -4, %o3
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
2014470: 10 bf ff e2 b 20143f8 <fat_cluster_write+0xec>
2014474: 80 a2 20 00 cmp %o0, 0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
2014478: 81 c7 e0 08 ret <== NOT EXECUTED
201447c: 81 e8 00 00 restore <== NOT EXECUTED
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
2014480: c4 0e 20 02 ldub [ %i0 + 2 ], %g2
2014484: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
2014488: 84 20 40 02 sub %g1, %g2, %g2
201448c: 10 bf ff b6 b 2014364 <fat_cluster_write+0x58>
2014490: a3 34 40 02 srl %l1, %g2, %l1
02013614 <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
2013614: 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)
2013618: c2 06 60 08 ld [ %i1 + 8 ], %g1
201361c: 80 a0 60 01 cmp %g1, 1
2013620: 08 80 00 06 bleu 2013638 <fat_file_close+0x24>
2013624: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
2013628: 90 10 20 00 clr %o0
* 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)
{
fat_fd->links_num--;
201362c: c2 26 60 08 st %g1, [ %i1 + 8 ]
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
return rc;
}
2013630: 81 c7 e0 08 ret
2013634: 91 e8 00 08 restore %g0, %o0, %o0
return rc;
}
key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
2013638: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
201363c: 80 88 60 01 btst 1, %g1
2013640: 22 80 00 15 be,a 2013694 <fat_file_close+0x80>
2013644: d2 06 60 0c ld [ %i1 + 0xc ], %o1
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
2013648: 90 10 00 18 mov %i0, %o0
201364c: 92 10 00 19 mov %i1, %o1
2013650: 7f ff ff b0 call 2013510 <fat_file_truncate>
2013654: 94 10 20 00 clr %o2
if ( rc != RC_OK )
2013658: 80 a2 20 00 cmp %o0, 0
201365c: 12 bf ff f5 bne 2013630 <fat_file_close+0x1c> <== NEVER TAKEN
2013660: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2013664: 40 00 0f d1 call 20175a8 <_Chain_Extract>
2013668: 90 10 00 19 mov %i1, %o0
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
201366c: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2013670: 40 00 06 7a call 2015058 <fat_ino_is_unique>
2013674: 90 10 00 18 mov %i0, %o0
2013678: 80 8a 20 ff btst 0xff, %o0
201367c: 32 80 00 11 bne,a 20136c0 <fat_file_close+0xac> <== NEVER TAKEN
2013680: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
fat_fd->links_num = 0;
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
2013684: 7f ff c7 76 call 200545c <free>
2013688: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
201368c: 40 00 01 cf call 2013dc8 <fat_buf_release>
2013690: 81 e8 00 00 restore
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
2013694: 40 00 06 71 call 2015058 <fat_ino_is_unique>
2013698: 90 10 00 18 mov %i0, %o0
201369c: 80 8a 20 ff btst 0xff, %o0
20136a0: 02 80 00 05 be 20136b4 <fat_file_close+0xa0> <== ALWAYS TAKEN
20136a4: 01 00 00 00 nop
{
fat_fd->links_num = 0;
20136a8: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
20136ac: 40 00 01 c7 call 2013dc8 <fat_buf_release> <== NOT EXECUTED
20136b0: 81 e8 00 00 restore <== NOT EXECUTED
20136b4: 40 00 0f bd call 20175a8 <_Chain_Extract>
20136b8: 90 10 00 19 mov %i1, %o0
20136bc: 30 bf ff f2 b,a 2013684 <fat_file_close+0x70>
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
fat_free_unique_ino(fs_info, fat_fd->ino);
20136c0: 40 00 06 5b call 201502c <fat_free_unique_ino> <== NOT EXECUTED
20136c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20136c8: 30 bf ff ef b,a 2013684 <fat_file_close+0x70> <== NOT EXECUTED
020137a0 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
20137a0: 9d e3 bf 90 save %sp, -112, %sp
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
20137a4: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
20137a8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
20137ac: 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;
20137b0: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
20137b4: 80 a6 c0 01 cmp %i3, %g1
20137b8: 08 80 00 16 bleu 2013810 <fat_file_extend+0x70>
20137bc: ba 10 00 18 mov %i0, %i5
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
20137c0: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
20137c4: 80 a0 a0 01 cmp %g2, 1
20137c8: 22 80 00 56 be,a 2013920 <fat_file_extend+0x180>
20137cc: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
(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))) &
20137d0: e0 17 60 06 lduh [ %i5 + 6 ], %l0
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
20137d4: 86 26 c0 01 sub %i3, %g1, %g3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
20137d8: 84 04 3f ff add %l0, -1, %g2
20137dc: a4 08 80 01 and %g2, %g1, %l2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
20137e0: a0 24 00 12 sub %l0, %l2, %l0
20137e4: a0 0c 00 02 and %l0, %g2, %l0
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
if (bytes2add > bytes_remain)
20137e8: 80 a4 00 03 cmp %l0, %g3
20137ec: 1a 80 00 03 bcc 20137f8 <fat_file_extend+0x58>
20137f0: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
20137f4: a2 20 c0 10 sub %g3, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
20137f8: 80 a4 20 00 cmp %l0, 0
20137fc: 12 80 00 3c bne 20138ec <fat_file_extend+0x14c>
2013800: 80 a6 a0 00 cmp %i2, 0
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
2013804: 80 a4 60 00 cmp %l1, 0
2013808: 32 80 00 04 bne,a 2013818 <fat_file_extend+0x78>
201380c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
2013810: 81 c7 e0 08 ret
2013814: 91 e8 20 00 restore %g0, 0, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2013818: a4 04 7f ff add %l1, -1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
201381c: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2013820: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2013824: 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;
2013828: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
201382c: 96 07 bf fc add %fp, -4, %o3
2013830: 94 10 00 12 mov %l2, %o2
2013834: 98 07 bf f8 add %fp, -8, %o4
2013838: 40 00 1e dc call 201b3a8 <fat_scan_fat_for_free_clusters>
201383c: 9a 10 00 1a mov %i2, %o5
&cls_added, &last_cl, zero_fill);
/* this means that low level I/O error occured */
if (rc != RC_OK)
2013840: b0 92 20 00 orcc %o0, 0, %i0
2013844: 12 80 00 28 bne 20138e4 <fat_file_extend+0x144> <== NEVER TAKEN
2013848: 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))
201384c: 80 94 00 01 orcc %l0, %g1, %g0
2013850: 02 80 00 3b be 201393c <fat_file_extend+0x19c> <== NEVER TAKEN
2013854: 80 a4 80 01 cmp %l2, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
2013858: 02 80 00 09 be 201387c <fat_file_extend+0xdc> <== ALWAYS TAKEN
201385c: a4 24 80 01 sub %l2, %g1, %l2
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
2013860: c6 17 60 06 lduh [ %i5 + 6 ], %g3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
2013864: c4 0f 60 08 ldub [ %i5 + 8 ], %g2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
2013868: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
201386c: a2 0c 40 03 and %l1, %g3, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
2013870: a5 2c 80 02 sll %l2, %g2, %l2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
2013874: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
2013878: b6 26 c0 12 sub %i3, %l2, %i3 <== NOT EXECUTED
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
201387c: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
2013880: 80 a2 e0 00 cmp %o3, 0
2013884: 32 80 00 43 bne,a 2013990 <fat_file_extend+0x1f0>
2013888: d2 06 60 3c ld [ %i1 + 0x3c ], %o1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
201388c: c4 07 bf f0 ld [ %fp + -16 ], %g2
fat_fd->map.file_cln = 0;
2013890: c0 26 60 34 clr [ %i1 + 0x34 ]
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
2013894: c4 26 60 1c st %g2, [ %i1 + 0x1c ]
2013898: c4 26 60 38 st %g2, [ %i1 + 0x38 ]
}
fat_buf_release(fs_info);
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
201389c: 80 a0 60 00 cmp %g1, 0
20138a0: 22 80 00 39 be,a 2013984 <fat_file_extend+0x1e4> <== NEVER TAKEN
20138a4: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
20138a8: c4 07 bf f8 ld [ %fp + -8 ], %g2
if (fat_fd->fat_file_type == FAT_DIRECTORY)
20138ac: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
20138b0: 80 a0 60 00 cmp %g1, 0
20138b4: 12 80 00 33 bne 2013980 <fat_file_extend+0x1e0>
20138b8: c4 26 60 3c st %g2, [ %i1 + 0x3c ]
{
rc = fat_init_clusters_chain(fs_info, chain);
20138bc: d2 07 bf f0 ld [ %fp + -16 ], %o1
20138c0: 40 00 05 80 call 2014ec0 <fat_init_clusters_chain>
20138c4: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
20138c8: 82 92 20 00 orcc %o0, 0, %g1
20138cc: 22 80 00 2e be,a 2013984 <fat_file_extend+0x1e4> <== ALWAYS TAKEN
20138d0: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
20138d4: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
20138d8: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
20138dc: 40 00 1e 7b call 201b2c8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
20138e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20138e4: 81 c7 e0 08 ret <== NOT EXECUTED
20138e8: 81 e8 00 00 restore <== NOT EXECUTED
if (bytes2add > bytes_remain)
bytes2add -= bytes_remain;
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
20138ec: 02 bf ff c7 be 2013808 <fat_file_extend+0x68>
20138f0: 80 a4 60 00 cmp %l1, 0
uint32_t start = fat_fd->fat_file_size;
uint32_t cl_start = start >> fs_info->vol.bpc_log2;
20138f4: d4 0f 60 08 ldub [ %i5 + 8 ], %o2
uint32_t ofs = start & (fs_info->vol.bpc - 1);
uint32_t cur_cln;
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
20138f8: 90 10 00 1d mov %i5, %o0
20138fc: 92 10 00 19 mov %i1, %o1
2013900: 95 30 40 0a srl %g1, %o2, %o2
2013904: 7f ff fd 9b call 2012f70 <fat_file_lseek>
2013908: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
201390c: b0 92 60 00 orcc %o1, 0, %i0
2013910: 02 80 00 11 be 2013954 <fat_file_extend+0x1b4> <== ALWAYS TAKEN
2013914: d2 07 bf fc ld [ %fp + -4 ], %o1
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
2013918: 81 c7 e0 08 ret <== NOT EXECUTED
201391c: 81 e8 00 00 restore <== 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)) &&
2013920: 80 a0 a0 00 cmp %g2, 0
2013924: 32 bf ff ac bne,a 20137d4 <fat_file_extend+0x34> <== NEVER TAKEN
2013928: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
201392c: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013930: 80 88 a0 03 btst 3, %g2
2013934: 22 bf ff a8 be,a 20137d4 <fat_file_extend+0x34> <== NEVER TAKEN
2013938: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
if (rc != RC_OK)
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
201393c: 40 00 25 e4 call 201d0cc <__errno>
2013940: b0 10 3f ff mov -1, %i0
2013944: 82 10 20 1c mov 0x1c, %g1
2013948: c2 22 00 00 st %g1, [ %o0 ]
201394c: 81 c7 e0 08 ret
2013950: 81 e8 00 00 restore
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
2013954: 90 10 00 1d mov %i5, %o0
2013958: 94 10 00 12 mov %l2, %o2
201395c: 96 10 00 10 mov %l0, %o3
2013960: 98 10 20 00 clr %o4
2013964: 40 00 02 0a call 201418c <fat_cluster_set>
2013968: b0 10 3f ff mov -1, %i0
if (bytes_remain != bytes_written)
201396c: 80 a2 00 10 cmp %o0, %l0
2013970: 02 bf ff a6 be 2013808 <fat_file_extend+0x68> <== ALWAYS TAKEN
2013974: 80 a4 60 00 cmp %l1, 0
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
2013978: 81 c7 e0 08 ret <== NOT EXECUTED
201397c: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
*a_length = new_length;
2013980: f6 27 00 00 st %i3, [ %i4 ]
fat_fd->fat_file_size = new_length;
2013984: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
2013988: 81 c7 e0 08 ret
201398c: 81 e8 00 00 restore
fat_fd->map.disk_cln = fat_fd->cln = chain;
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
2013990: 80 a2 7f ff cmp %o1, -1
2013994: 22 80 00 0d be,a 20139c8 <fat_file_extend+0x228> <== NEVER TAKEN
2013998: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
201399c: d2 27 bf f4 st %o1, [ %fp + -12 ]
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
20139a0: d4 07 bf f0 ld [ %fp + -16 ], %o2
20139a4: 40 00 1d 97 call 201b000 <fat_set_fat_cluster>
20139a8: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
20139ac: 82 92 20 00 orcc %o0, 0, %g1
20139b0: 12 bf ff ca bne 20138d8 <fat_file_extend+0x138> <== NEVER TAKEN
20139b4: d2 07 bf f0 ld [ %fp + -16 ], %o1
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
20139b8: 40 00 01 04 call 2013dc8 <fat_buf_release>
20139bc: 90 10 00 1d mov %i5, %o0
20139c0: 10 bf ff b7 b 201389c <fat_file_extend+0xfc>
20139c4: c2 07 bf fc ld [ %fp + -4 ], %g1
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
20139c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20139cc: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
20139d0: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
20139d4: 7f ff ff 3e call 20136cc <fat_file_ioctl> <== NOT EXECUTED
20139d8: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
20139dc: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
20139e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20139e4: 02 bf ff ef be 20139a0 <fat_file_extend+0x200> <== NOT EXECUTED
20139e8: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
20139ec: 10 bf ff bb b 20138d8 <fat_file_extend+0x138> <== NOT EXECUTED
20139f0: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
020136cc <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
20136cc: 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);
20136d0: 82 07 a0 50 add %fp, 0x50, %g1
20136d4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
20136d8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
20136dc: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
fat_file_fd_t *fat_fd,
int cmd,
...)
{
int rc = RC_OK;
uint32_t cur_cln = 0;
20136e0: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
20136e4: 80 a6 a0 01 cmp %i2, 1
20136e8: 02 80 00 08 be 2013708 <fat_file_ioctl+0x3c> <== ALWAYS TAKEN
20136ec: c2 27 bf fc st %g1, [ %fp + -4 ]
*ret = cur_cln;
break;
default:
errno = EINVAL;
20136f0: 40 00 26 77 call 201d0cc <__errno> <== NOT EXECUTED
20136f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20136f8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20136fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
break;
}
va_end(ap);
return rc;
}
2013700: 81 c7 e0 08 ret <== NOT EXECUTED
2013704: 81 e8 00 00 restore <== NOT EXECUTED
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
2013708: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
201370c: 86 07 a0 58 add %fp, 0x58, %g3
2013710: c6 27 bf fc st %g3, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
2013714: 80 a6 c0 02 cmp %i3, %g2
2013718: 1a 80 00 1c bcc 2013788 <fat_file_ioctl+0xbc> <== NEVER TAKEN
201371c: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013720: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2013724: 80 a0 60 01 cmp %g1, 1
2013728: 22 80 00 0e be,a 2013760 <fat_file_ioctl+0x94>
201372c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
2013730: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
2013734: 90 10 00 18 mov %i0, %o0
2013738: 92 10 00 19 mov %i1, %o1
201373c: 95 36 c0 0a srl %i3, %o2, %o2
2013740: 7f ff fe 0c call 2012f70 <fat_file_lseek>
2013744: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
2013748: b0 92 60 00 orcc %o1, 0, %i0
201374c: 12 bf ff ed bne 2013700 <fat_file_ioctl+0x34> <== NEVER TAKEN
2013750: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
2013754: c2 27 40 00 st %g1, [ %i5 ]
break;
2013758: 81 c7 e0 08 ret
201375c: 81 e8 00 00 restore
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)) &&
2013760: 80 a0 60 00 cmp %g1, 0
2013764: 32 bf ff f4 bne,a 2013734 <fat_file_ioctl+0x68> <== NEVER TAKEN
2013768: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
201376c: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013770: 80 88 60 03 btst 3, %g1
2013774: 22 bf ff f0 be,a 2013734 <fat_file_ioctl+0x68>
2013778: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
201377c: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
2013780: 81 c7 e0 08 ret
2013784: 91 e8 20 00 restore %g0, 0, %o0
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
2013788: 40 00 26 51 call 201d0cc <__errno> <== NOT EXECUTED
201378c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013790: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2013794: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013798: 81 c7 e0 08 ret <== NOT EXECUTED
201379c: 81 e8 00 00 restore <== NOT EXECUTED
02012f70 <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
2012f70: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
2012f74: f8 06 60 34 ld [ %i1 + 0x34 ], %i4
2012f78: 80 a7 00 1a cmp %i4, %i2
2012f7c: 22 80 00 26 be,a 2013014 <fat_file_lseek+0xa4>
2012f80: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
2012f84: 2a 80 00 19 bcs,a 2012fe8 <fat_file_lseek+0x78>
2012f88: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
2012f8c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2012f90: b8 10 00 1a mov %i2, %i4
2012f94: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
2012f98: 80 a7 20 00 cmp %i4, 0
2012f9c: 12 80 00 07 bne 2012fb8 <fat_file_lseek+0x48>
2012fa0: ba 10 20 00 clr %i5
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
2012fa4: 10 80 00 14 b 2012ff4 <fat_file_lseek+0x84>
2012fa8: c2 07 bf fc ld [ %fp + -4 ], %g1
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
2012fac: 80 a7 40 1c cmp %i5, %i4
2012fb0: 02 80 00 11 be 2012ff4 <fat_file_lseek+0x84>
2012fb4: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2012fb8: d2 07 bf fc ld [ %fp + -4 ], %o1
2012fbc: 90 10 00 18 mov %i0, %o0
2012fc0: 40 00 1f 8c call 201adf0 <fat_get_fat_cluster>
2012fc4: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2012fc8: 80 a2 20 00 cmp %o0, 0
2012fcc: 22 bf ff f8 be,a 2012fac <fat_file_lseek+0x3c> <== ALWAYS TAKEN
2012fd0: ba 07 60 01 inc %i5
return rc;
2012fd4: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
2012fd8: 85 3a 20 1f sra %o0, 0x1f, %g2 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
2012fdc: b2 10 00 03 mov %g3, %i1 <== NOT EXECUTED
2012fe0: 81 c7 e0 08 ret <== NOT EXECUTED
2012fe4: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
2012fe8: b8 26 80 1c sub %i2, %i4, %i4
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
2012fec: 10 bf ff eb b 2012f98 <fat_file_lseek+0x28>
2012ff0: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
2012ff4: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
2012ff8: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
}
return RC_OK;
2012ffc: 84 10 20 00 clr %g2
2013000: 86 10 20 00 clr %g3
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
2013004: c2 26 c0 00 st %g1, [ %i3 ]
}
return RC_OK;
}
2013008: b0 10 00 02 mov %g2, %i0
201300c: 81 c7 e0 08 ret
2013010: 93 e8 00 03 restore %g0, %g3, %o1
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
2013014: 84 10 20 00 clr %g2
2013018: 86 10 20 00 clr %g3
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
201301c: c2 26 c0 00 st %g1, [ %i3 ]
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
2013020: b0 10 00 02 mov %g2, %i0
2013024: 81 c7 e0 08 ret
2013028: 93 e8 00 03 restore %g0, %g3, %o1
02013c58 <fat_file_mark_removed>:
void
fat_file_mark_removed(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
2013c58: 9d e3 bf a0 save %sp, -96, %sp
2013c5c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
2013c60: 80 a0 60 01 cmp %g1, 1
2013c64: 02 80 00 26 be 2013cfc <fat_file_mark_removed+0xa4> <== NEVER TAKEN
2013c68: 80 a0 60 00 cmp %g1, 0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2013c6c: 32 80 00 1f bne,a 2013ce8 <fat_file_mark_removed+0x90> <== NEVER TAKEN
2013c70: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
2013c74: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
2013c78: 80 88 a0 03 btst 3, %g2
2013c7c: 22 80 00 1b be,a 2013ce8 <fat_file_mark_removed+0x90> <== NEVER TAKEN
2013c80: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2013c84: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
2013c88: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
2013c8c: bb 2f 40 02 sll %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
2013c90: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
2013c94: 90 10 00 19 mov %i1, %o0
2013c98: 87 30 a0 09 srl %g2, 9, %g3
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
2013c9c: 85 30 a0 05 srl %g2, 5, %g2
2013ca0: 84 08 a0 0f and %g2, 0xf, %g2
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
2013ca4: ba 07 40 03 add %i5, %g3, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
2013ca8: bb 2f 60 04 sll %i5, 4, %i5
2013cac: 40 00 0e 3f call 20175a8 <_Chain_Extract>
2013cb0: ba 07 40 02 add %i5, %g2, %i5
*/
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);
2013cb4: d0 06 20 70 ld [ %i0 + 0x70 ], %o0
2013cb8: 82 0f 60 01 and %i5, 1, %g1
2013cbc: 85 28 60 02 sll %g1, 2, %g2
2013cc0: 83 28 60 04 sll %g1, 4, %g1
2013cc4: 82 20 40 02 sub %g1, %g2, %g1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
2013cc8: 92 10 00 19 mov %i1, %o1
2013ccc: 7f ff db 0c call 200a8fc <_Chain_Append>
2013cd0: 90 02 00 01 add %o0, %g1, %o0
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
_hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);
fat_fd->flags |= FAT_FILE_REMOVED;
2013cd4: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
2013cd8: 82 10 60 01 or %g1, 1, %g1
2013cdc: c2 2e 60 30 stb %g1, [ %i1 + 0x30 ]
2013ce0: 81 c7 e0 08 ret
2013ce4: 81 e8 00 00 restore
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2013ce8: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 <== NOT EXECUTED
2013cec: ba 00 7f fe add %g1, -2, %i5 <== NOT EXECUTED
2013cf0: bb 2f 40 03 sll %i5, %g3, %i5 <== NOT EXECUTED
2013cf4: 10 bf ff e5 b 2013c88 <fat_file_mark_removed+0x30> <== NOT EXECUTED
2013cf8: ba 07 40 02 add %i5, %g2, %i5 <== NOT EXECUTED
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
2013cfc: 10 bf ff e5 b 2013c90 <fat_file_mark_removed+0x38> <== NOT EXECUTED
2013d00: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
0201302c <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
201302c: 9d e3 bf a0 save %sp, -96, %sp
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
2013030: c2 06 40 00 ld [ %i1 ], %g1
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
2013034: 80 a0 60 01 cmp %g1, 1
2013038: 02 80 00 9c be 20132a8 <fat_file_open+0x27c>
201303c: 80 a0 60 00 cmp %g1, 0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2013040: 32 80 00 7b bne,a 201322c <fat_file_open+0x200>
2013044: c6 0e 20 05 ldub [ %i0 + 5 ], %g3
2013048: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
201304c: 80 88 a0 03 btst 3, %g2
2013050: 22 80 00 77 be,a 201322c <fat_file_open+0x200> <== NEVER TAKEN
2013054: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2013058: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
201305c: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
2013060: bb 2f 40 02 sll %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
2013064: c2 06 60 04 ld [ %i1 + 4 ], %g1
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
2013068: de 06 20 6c ld [ %i0 + 0x6c ], %o7
201306c: 85 30 60 09 srl %g1, 9, %g2
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
2013070: 83 30 60 05 srl %g1, 5, %g1
2013074: 82 08 60 0f and %g1, 0xf, %g1
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
2013078: ba 07 40 02 add %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
201307c: bb 2f 60 04 sll %i5, 4, %i5
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
2013080: ba 07 40 01 add %i5, %g1, %i5
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
2013084: 82 0f 60 01 and %i5, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
2013088: 85 28 60 02 sll %g1, 2, %g2
201308c: b7 28 60 04 sll %g1, 4, %i3
2013090: b6 26 c0 02 sub %i3, %g2, %i3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2013094: c2 03 c0 1b ld [ %o7 + %i3 ], %g1
2013098: 9e 03 c0 1b add %o7, %i3, %o7
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 ));
201309c: 9e 03 e0 04 add %o7, 4, %o7
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
20130a0: 80 a0 40 0f cmp %g1, %o7
20130a4: 22 80 00 1e be,a 201311c <fat_file_open+0xf0>
20130a8: c4 06 20 70 ld [ %i0 + 0x70 ], %g2
20130ac: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
20130b0: 80 a0 a0 01 cmp %g2, 1
20130b4: 02 80 00 6d be 2013268 <fat_file_open+0x23c>
20130b8: 80 a0 a0 00 cmp %g2, 0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
20130bc: 32 80 00 61 bne,a 2013240 <fat_file_open+0x214>
20130c0: c8 0e 20 05 ldub [ %i0 + 5 ], %g4
20130c4: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3
20130c8: 80 88 e0 03 btst 3, %g3
20130cc: 22 80 00 5d be,a 2013240 <fat_file_open+0x214> <== NEVER TAKEN
20130d0: c8 0e 20 05 ldub [ %i0 + 5 ], %g4 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
20130d4: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
20130d8: c6 0e 20 03 ldub [ %i0 + 3 ], %g3
20130dc: b9 2f 00 03 sll %i4, %g3, %i4
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
20130e0: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
20130e4: 85 30 e0 05 srl %g3, 5, %g2
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
20130e8: 89 30 e0 09 srl %g3, 9, %g4
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
20130ec: 84 08 a0 0f and %g2, 0xf, %g2
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
20130f0: 86 07 00 04 add %i4, %g4, %g3
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
20130f4: 87 28 e0 04 sll %g3, 4, %g3
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
20130f8: 86 00 c0 02 add %g3, %g2, %g3
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
20130fc: 80 a7 40 03 cmp %i5, %g3
2013100: 22 80 00 55 be,a 2013254 <fat_file_open+0x228>
2013104: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
2013108: c2 00 40 00 ld [ %g1 ], %g1
)
{
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) ; )
201310c: 80 a3 c0 01 cmp %o7, %g1
2013110: 32 bf ff e8 bne,a 20130b0 <fat_file_open+0x84>
2013114: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
2013118: c4 06 20 70 ld [ %i0 + 0x70 ], %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
201311c: c2 00 80 1b ld [ %g2 + %i3 ], %g1
2013120: 84 00 80 1b add %g2, %i3, %g2
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 ));
2013124: 9e 00 a0 04 add %g2, 4, %o7
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
2013128: 80 a0 40 0f cmp %g1, %o7
201312c: 02 80 00 1e be 20131a4 <fat_file_open+0x178> <== ALWAYS TAKEN
2013130: a0 10 3f ff mov -1, %l0
2013134: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
2013138: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
201313c: 02 80 00 59 be 20132a0 <fat_file_open+0x274> <== NOT EXECUTED
2013140: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2013144: 32 80 00 4b bne,a 2013270 <fat_file_open+0x244> <== NOT EXECUTED
2013148: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
201314c: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3 <== NOT EXECUTED
2013150: 80 88 e0 03 btst 3, %g3 <== NOT EXECUTED
2013154: 22 80 00 47 be,a 2013270 <fat_file_open+0x244> <== NOT EXECUTED
2013158: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
201315c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4 <== NOT EXECUTED
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
2013160: c8 0e 20 03 ldub [ %i0 + 3 ], %g4 <== NOT EXECUTED
2013164: b9 2f 00 04 sll %i4, %g4, %i4 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
2013168: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
201316c: 85 30 e0 05 srl %g3, 5, %g2 <== NOT EXECUTED
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
2013170: 89 30 e0 09 srl %g3, 9, %g4 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
2013174: 84 08 a0 0f and %g2, 0xf, %g2 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
2013178: 86 07 00 04 add %i4, %g4, %g3 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
201317c: 87 28 e0 04 sll %g3, 4, %g3 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
2013180: 86 00 c0 02 add %g3, %g2, %g3 <== NOT EXECUTED
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
2013184: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
2013188: 02 80 00 3f be 2013284 <fat_file_open+0x258> <== NOT EXECUTED
201318c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
2013190: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
2013194: 80 a0 40 0f cmp %g1, %o7 <== NOT EXECUTED
2013198: 32 bf ff e8 bne,a 2013138 <fat_file_open+0x10c> <== NOT EXECUTED
201319c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
return 0;
}
}
the_node = the_node->next;
}
return -1;
20131a0: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
20131a4: 7f ff ca 01 call 20059a8 <malloc>
20131a8: 90 10 20 44 mov 0x44, %o0
20131ac: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
20131b0: 80 a2 20 00 cmp %o0, 0
20131b4: 02 80 00 46 be 20132cc <fat_file_open+0x2a0> <== NEVER TAKEN
20131b8: b8 10 00 08 mov %o0, %i4
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
20131bc: 92 10 20 00 clr %o1
20131c0: 40 00 2a bf call 201dcbc <memset>
20131c4: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
20131c8: de 0f 20 30 ldub [ %i4 + 0x30 ], %o7
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
20131cc: c8 06 40 00 ld [ %i1 ], %g4
20131d0: c6 06 60 04 ld [ %i1 + 4 ], %g3
20131d4: c4 06 60 08 ld [ %i1 + 8 ], %g2
20131d8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
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;
20131dc: b2 0b ff fe and %o7, -2, %i1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
20131e0: c8 27 20 20 st %g4, [ %i4 + 0x20 ]
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
20131e4: 9e 10 20 01 mov 1, %o7
lfat_fd->flags &= ~FAT_FILE_REMOVED;
20131e8: f2 2f 20 30 stb %i1, [ %i4 + 0x30 ]
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
20131ec: de 27 20 08 st %o7, [ %i4 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
20131f0: b2 10 3f ff mov -1, %i1
lfat_fd->dir_pos = *dir_pos;
20131f4: c6 27 20 24 st %g3, [ %i4 + 0x24 ]
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;
20131f8: f2 27 20 3c st %i1, [ %i4 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
20131fc: c4 27 20 28 st %g2, [ %i4 + 0x28 ]
if ( rc != RC_OK )
2013200: 80 a4 20 00 cmp %l0, 0
2013204: 02 80 00 2b be 20132b0 <fat_file_open+0x284> <== NEVER TAKEN
2013208: c2 27 20 2c st %g1, [ %i4 + 0x2c ]
lfat_fd->ino = key;
201320c: fa 27 20 0c st %i5, [ %i4 + 0xc ]
*/
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);
2013210: d0 06 20 6c ld [ %i0 + 0x6c ], %o0
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
2013214: 92 10 00 1c mov %i4, %o1
2013218: 90 02 00 1b add %o0, %i3, %o0
201321c: 7f ff dd b8 call 200a8fc <_Chain_Append>
2013220: b0 10 20 00 clr %i0
2013224: 81 c7 e0 08 ret
2013228: 81 e8 00 00 restore
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
201322c: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
2013230: ba 00 7f fe add %g1, -2, %i5
2013234: bb 2f 40 03 sll %i5, %g3, %i5
2013238: 10 bf ff 89 b 201305c <fat_file_open+0x30>
201323c: ba 07 40 02 add %i5, %g2, %i5
2013240: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
2013244: b8 00 bf fe add %g2, -2, %i4
2013248: b9 2f 00 04 sll %i4, %g4, %i4
201324c: 10 bf ff a3 b 20130d8 <fat_file_open+0xac>
2013250: b8 07 00 03 add %i4, %g3, %i4
/* access "valid" hash table */
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
2013254: c2 26 80 00 st %g1, [ %i2 ]
lfat_fd->links_num++;
2013258: 84 00 a0 01 inc %g2
201325c: c4 20 60 08 st %g2, [ %g1 + 8 ]
2013260: 81 c7 e0 08 ret
2013264: 91 e8 20 00 restore %g0, 0, %o0
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
2013268: 10 bf ff 9e b 20130e0 <fat_file_open+0xb4>
201326c: b8 10 20 01 mov 1, %i4
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2013270: c8 06 20 34 ld [ %i0 + 0x34 ], %g4 <== NOT EXECUTED
2013274: b8 00 bf fe add %g2, -2, %i4 <== NOT EXECUTED
2013278: b9 2f 00 03 sll %i4, %g3, %i4 <== NOT EXECUTED
201327c: 10 bf ff b9 b 2013160 <fat_file_open+0x134> <== NOT EXECUTED
2013280: b8 07 00 04 add %i4, %g4, %i4 <== NOT EXECUTED
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
2013284: 02 bf ff c8 be 20131a4 <fat_file_open+0x178> <== NOT EXECUTED
2013288: a0 10 20 00 clr %l0 <== NOT EXECUTED
201328c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
2013290: 80 a7 40 02 cmp %i5, %g2 <== NOT EXECUTED
2013294: 32 bf ff c0 bne,a 2013194 <fat_file_open+0x168> <== NOT EXECUTED
2013298: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
201329c: 30 bf ff c2 b,a 20131a4 <fat_file_open+0x178> <== NOT EXECUTED
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
20132a0: 10 bf ff b2 b 2013168 <fat_file_open+0x13c> <== NOT EXECUTED
20132a4: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
20132a8: 10 bf ff 6f b 2013064 <fat_file_open+0x38>
20132ac: ba 10 20 01 mov 1, %i5
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
20132b0: 40 00 07 23 call 2014f3c <fat_get_unique_ino> <== NOT EXECUTED
20132b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
20132b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20132bc: 12 bf ff d5 bne 2013210 <fat_file_open+0x1e4> <== NOT EXECUTED
20132c0: d0 27 20 0c st %o0, [ %i4 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
20132c4: 7f ff c8 66 call 200545c <free> <== NOT EXECUTED
20132c8: 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 );
20132cc: 40 00 27 80 call 201d0cc <__errno> <== NOT EXECUTED
20132d0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20132d4: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
20132d8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20132dc: 81 c7 e0 08 ret <== NOT EXECUTED
20132e0: 81 e8 00 00 restore <== NOT EXECUTED
020132fc <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
20132fc: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
2013300: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2013304: ba 10 00 18 mov %i0, %i5
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
2013308: 80 a6 e0 00 cmp %i3, 0
201330c: 02 80 00 7f be 2013508 <fat_file_read+0x20c> <== NEVER TAKEN
2013310: 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 )
2013314: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
2013318: 80 a0 40 1a cmp %g1, %i2
201331c: 08 80 00 7b bleu 2013508 <fat_file_read+0x20c>
2013320: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
2013324: 08 80 00 4c bleu 2013454 <fat_file_read+0x158> <== ALWAYS TAKEN
2013328: 84 20 40 1b sub %g1, %i3, %g2
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
201332c: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013330: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2013334: 80 a0 60 01 cmp %g1, 1
2013338: 22 80 00 4c be,a 2013468 <fat_file_read+0x16c>
201333c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
2013340: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
2013344: e0 17 60 06 lduh [ %i5 + 6 ], %l0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
2013348: a5 36 80 12 srl %i2, %l2, %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
201334c: 90 10 00 1d mov %i5, %o0
2013350: 92 10 00 19 mov %i1, %o1
2013354: 94 10 00 12 mov %l2, %o2
2013358: 7f ff ff 06 call 2012f70 <fat_file_lseek>
201335c: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2013360: b0 92 60 00 orcc %o1, 0, %i0
2013364: 12 80 00 69 bne 2013508 <fat_file_read+0x20c> <== NEVER TAKEN
2013368: a1 2c 20 10 sll %l0, 0x10, %l0
return rc;
while (count > 0)
201336c: a6 10 20 00 clr %l3
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
2013370: a1 34 20 10 srl %l0, 0x10, %l0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
2013374: a2 10 20 00 clr %l1
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
2013378: a0 04 3f ff add %l0, -1, %l0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
201337c: 80 a6 e0 00 cmp %i3, 0
2013380: 02 80 00 5b be 20134ec <fat_file_read+0x1f0> <== NEVER TAKEN
2013384: b4 0e 80 10 and %i2, %l0, %i2
2013388: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
201338c: c8 17 40 00 lduh [ %i5 ], %g4
2013390: 10 80 00 20 b 2013410 <fat_file_read+0x114>
2013394: 94 10 00 1a mov %i2, %o2
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2013398: 80 8e 20 03 btst 3, %i0 <== NOT EXECUTED
201339c: 22 80 00 27 be,a 2013438 <fat_file_read+0x13c> <== NOT EXECUTED
20133a0: de 0f 60 05 ldub [ %i5 + 5 ], %o7 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
20133a4: d2 07 60 20 ld [ %i5 + 0x20 ], %o1 <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
20133a8: 87 32 80 03 srl %o2, %g3, %g3
byte = ofs & (fs_info->vol.bps - 1);
20133ac: 85 29 20 10 sll %g4, 0x10, %g2
20133b0: 85 30 a0 10 srl %g2, 0x10, %g2
20133b4: 84 00 bf ff add %g2, -1, %g2
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
20133b8: 98 07 00 11 add %i4, %l1, %o4
20133bc: 94 0a 80 02 and %o2, %g2, %o2
20133c0: 92 02 40 03 add %o1, %g3, %o1
20133c4: 96 10 00 10 mov %l0, %o3
20133c8: 40 00 03 25 call 201405c <_fat_block_read>
20133cc: 90 10 00 1d mov %i5, %o0
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
20133d0: 94 07 bf fc add %fp, -4, %o2
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
20133d4: 80 a2 20 00 cmp %o0, 0
20133d8: 06 80 00 3d bl 20134cc <fat_file_read+0x1d0> <== NEVER TAKEN
20133dc: 90 10 00 1d mov %i5, %o0
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
20133e0: e6 07 bf fc ld [ %fp + -4 ], %l3
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
20133e4: b6 26 c0 10 sub %i3, %l0, %i3
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
20133e8: 92 10 00 13 mov %l3, %o1
20133ec: 40 00 1e 81 call 201adf0 <fat_get_fat_cluster>
20133f0: a2 04 40 10 add %l1, %l0, %l1
if ( rc != RC_OK )
20133f4: 80 a2 20 00 cmp %o0, 0
20133f8: 12 80 00 15 bne 201344c <fat_file_read+0x150> <== NEVER TAKEN
20133fc: 80 a6 e0 00 cmp %i3, 0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
2013400: 02 80 00 3a be 20134e8 <fat_file_read+0x1ec>
2013404: 94 10 20 00 clr %o2
2013408: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
201340c: c8 17 40 00 lduh [ %i5 ], %g4
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2013410: e0 17 60 06 lduh [ %i5 + 6 ], %l0
2013414: a0 24 00 0a sub %l0, %o2, %l0
2013418: 80 a4 00 1b cmp %l0, %i3
201341c: 08 80 00 03 bleu 2013428 <fat_file_read+0x12c>
2013420: c4 07 bf fc ld [ %fp + -4 ], %g2
2013424: a0 10 00 1b mov %i3, %l0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2013428: 80 a0 a0 00 cmp %g2, 0
201342c: 22 bf ff db be,a 2013398 <fat_file_read+0x9c> <== NEVER TAKEN
2013430: f0 0f 60 0e ldub [ %i5 + 0xe ], %i0 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2013434: de 0f 60 05 ldub [ %i5 + 5 ], %o7
2013438: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
201343c: 92 00 bf fe add %g2, -2, %o1
2013440: 93 2a 40 0f sll %o1, %o7, %o1
2013444: 10 bf ff d9 b 20133a8 <fat_file_read+0xac>
2013448: 92 02 40 18 add %o1, %i0, %o1
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;
}
201344c: 81 c7 e0 08 ret <== NOT EXECUTED
2013450: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
2013454: 80 a6 80 02 cmp %i2, %g2
2013458: 28 bf ff b7 bleu,a 2013334 <fat_file_read+0x38>
201345c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
2013460: 10 bf ff b4 b 2013330 <fat_file_read+0x34>
2013464: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013468: 80 a0 60 00 cmp %g1, 0
201346c: 32 bf ff b6 bne,a 2013344 <fat_file_read+0x48> <== NEVER TAKEN
2013470: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2013474: c2 0f 60 0e ldub [ %i5 + 0xe ], %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)) &&
2013478: 80 88 60 03 btst 3, %g1
201347c: 22 bf ff b2 be,a 2013344 <fat_file_read+0x48>
2013480: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
2013484: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2013488: 80 a0 60 00 cmp %g1, 0
201348c: 32 80 00 12 bne,a 20134d4 <fat_file_read+0x1d8> <== NEVER TAKEN
2013490: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2013494: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
sec += (start >> fs_info->vol.sec_log2);
2013498: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
byte = start & (fs_info->vol.bps - 1);
201349c: d4 17 40 00 lduh [ %i5 ], %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
20134a0: 83 36 80 01 srl %i2, %g1, %g1
byte = start & (fs_info->vol.bps - 1);
20134a4: 94 02 bf ff add %o2, -1, %o2
ret = _fat_block_read(fs_info, sec, byte, count, buf);
20134a8: 90 10 00 1d mov %i5, %o0
20134ac: 92 02 40 01 add %o1, %g1, %o1
20134b0: 94 0e 80 0a and %i2, %o2, %o2
20134b4: 96 10 00 1b mov %i3, %o3
20134b8: 40 00 02 e9 call 201405c <_fat_block_read>
20134bc: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
20134c0: b0 92 20 00 orcc %o0, 0, %i0
20134c4: 16 80 00 11 bge 2013508 <fat_file_read+0x20c> <== ALWAYS TAKEN
20134c8: 01 00 00 00 nop
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
20134cc: 81 c7 e0 08 ret <== NOT EXECUTED
20134d0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
20134d4: c4 07 60 34 ld [ %i5 + 0x34 ], %g2 <== NOT EXECUTED
20134d8: 92 00 7f fe add %g1, -2, %o1 <== NOT EXECUTED
20134dc: 93 2a 40 03 sll %o1, %g3, %o1 <== NOT EXECUTED
20134e0: 10 bf ff ee b 2013498 <fat_file_read+0x19c> <== NOT EXECUTED
20134e4: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
20134e8: b0 10 00 11 mov %l1, %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);
20134ec: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
20134f0: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
20134f4: e6 26 60 38 st %l3, [ %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);
20134f8: a2 06 80 11 add %i2, %l1, %l1
20134fc: a3 34 40 01 srl %l1, %g1, %l1
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
2013500: a4 04 40 12 add %l1, %l2, %l2
2013504: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
2013508: 81 c7 e0 08 ret
201350c: 81 e8 00 00 restore
02013d04 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
2013d04: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
2013d08: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013d0c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2013d10: 80 a0 60 01 cmp %g1, 1
2013d14: 02 80 00 21 be 2013d98 <fat_file_size+0x94>
2013d18: f8 27 bf fc st %i4, [ %fp + -4 ]
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2013d1c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
2013d20: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2013d24: 84 0f 00 02 and %i4, %g2, %g2
2013d28: 80 a0 80 01 cmp %g2, %g1
2013d2c: 0a 80 00 0e bcs 2013d64 <fat_file_size+0x60> <== ALWAYS TAKEN
2013d30: c0 26 60 18 clr [ %i1 + 0x18 ]
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
2013d34: 10 80 00 15 b 2013d88 <fat_file_size+0x84> <== NOT EXECUTED
2013d38: b8 10 20 00 clr %i4 <== NOT EXECUTED
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
2013d3c: f6 06 60 18 ld [ %i1 + 0x18 ], %i3
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2013d40: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
2013d44: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
2013d48: c2 07 bf fc ld [ %fp + -4 ], %g1
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
2013d4c: 88 06 c0 04 add %i3, %g4, %g4
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2013d50: 86 08 40 03 and %g1, %g3, %g3
2013d54: 80 a0 c0 02 cmp %g3, %g2
2013d58: 1a 80 00 0c bcc 2013d88 <fat_file_size+0x84> <== ALWAYS TAKEN
2013d5c: c8 26 60 18 st %g4, [ %i1 + 0x18 ]
2013d60: b8 10 00 01 mov %g1, %i4 <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2013d64: 92 10 00 1c mov %i4, %o1
2013d68: 90 10 00 18 mov %i0, %o0
2013d6c: 40 00 1c 21 call 201adf0 <fat_get_fat_cluster>
2013d70: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2013d74: 80 a2 20 00 cmp %o0, 0
2013d78: 22 bf ff f1 be,a 2013d3c <fat_file_size+0x38> <== ALWAYS TAKEN
2013d7c: c8 16 20 06 lduh [ %i0 + 6 ], %g4
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
return rc;
}
2013d80: 81 c7 e0 08 ret <== NOT EXECUTED
2013d84: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
2013d88: 90 10 20 00 clr %o0
2013d8c: f8 26 60 3c st %i4, [ %i1 + 0x3c ]
return rc;
}
2013d90: 81 c7 e0 08 ret
2013d94: 91 e8 00 08 restore %g0, %o0, %o0
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013d98: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2013d9c: 80 a0 60 00 cmp %g1, 0
2013da0: 32 bf ff e0 bne,a 2013d20 <fat_file_size+0x1c> <== NEVER TAKEN
2013da4: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2013da8: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2013dac: 80 88 60 03 btst 3, %g1
2013db0: 22 bf ff dc be,a 2013d20 <fat_file_size+0x1c> <== ALWAYS TAKEN
2013db4: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
2013db8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
return rc;
2013dbc: 90 10 20 00 clr %o0 <== NOT EXECUTED
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
2013dc0: 10 bf ff f0 b 2013d80 <fat_file_size+0x7c> <== NOT EXECUTED
2013dc4: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
02013510 <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
2013510: 9d e3 bf 98 save %sp, -104, %sp
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 )
2013514: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
)
{
int rc = RC_OK;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
2013518: 84 10 3f ff mov -1, %g2
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
int rc = RC_OK;
uint32_t cur_cln = 0;
201351c: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
2013520: 80 a0 40 1a cmp %g1, %i2
2013524: 08 80 00 26 bleu 20135bc <fat_file_truncate+0xac>
2013528: c4 27 bf fc st %g2, [ %fp + -4 ]
return rc;
assert(fat_fd->fat_file_size);
201352c: 80 a0 60 00 cmp %g1, 0
2013530: 02 80 00 31 be 20135f4 <fat_file_truncate+0xe4> <== NEVER TAKEN
2013534: 11 00 80 b4 sethi %hi(0x202d000), %o0
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
2013538: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
201353c: c6 16 20 06 lduh [ %i0 + 6 ], %g3
2013540: 86 00 ff ff add %g3, -1, %g3
2013544: b4 00 c0 1a add %g3, %i2, %i2
2013548: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
201354c: 85 2e 80 02 sll %i2, %g2, %g2
2013550: 80 a0 40 02 cmp %g1, %g2
2013554: 08 80 00 1a bleu 20135bc <fat_file_truncate+0xac>
2013558: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
201355c: 02 80 00 09 be 2013580 <fat_file_truncate+0x70>
2013560: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
2013564: 92 10 00 19 mov %i1, %o1
2013568: 94 06 bf ff add %i2, -1, %o2
201356c: 7f ff fe 81 call 2012f70 <fat_file_lseek>
2013570: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2013574: 80 a2 60 00 cmp %o1, 0
2013578: 12 80 00 12 bne 20135c0 <fat_file_truncate+0xb0> <== NEVER TAKEN
201357c: 90 10 00 18 mov %i0, %o0
return rc;
}
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
2013580: 92 10 00 19 mov %i1, %o1
2013584: 94 10 00 1a mov %i2, %o2
2013588: 7f ff fe 7a call 2012f70 <fat_file_lseek>
201358c: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
2013590: 80 a2 60 00 cmp %o1, 0
2013594: 12 80 00 0b bne 20135c0 <fat_file_truncate+0xb0> <== NEVER TAKEN
2013598: 01 00 00 00 nop
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
201359c: d2 07 bf f8 ld [ %fp + -8 ], %o1
20135a0: 40 00 1f 4a call 201b2c8 <fat_free_fat_clusters_chain>
20135a4: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
20135a8: 92 92 20 00 orcc %o0, 0, %o1
20135ac: 12 80 00 05 bne 20135c0 <fat_file_truncate+0xb0> <== NEVER TAKEN
20135b0: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
20135b4: 12 80 00 05 bne 20135c8 <fat_file_truncate+0xb8>
20135b8: d2 07 bf fc ld [ %fp + -4 ], %o1
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
return rc;
20135bc: 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;
}
20135c0: 81 c7 e0 08 ret
20135c4: 91 e8 00 09 restore %g0, %o1, %o0
if (rc != RC_OK)
return rc;
if (cl_start != 0)
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
20135c8: 90 10 00 18 mov %i0, %o0
20135cc: 40 00 1e 8d call 201b000 <fat_set_fat_cluster>
20135d0: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
20135d4: 92 92 20 00 orcc %o0, 0, %o1
20135d8: 12 bf ff fa bne 20135c0 <fat_file_truncate+0xb0> <== NEVER TAKEN
20135dc: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
20135e0: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
20135e4: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
if (cl_start != 0)
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
20135e8: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
20135ec: 10 bf ff f5 b 20135c0 <fat_file_truncate+0xb0>
20135f0: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
20135f4: 15 00 80 b4 sethi %hi(0x202d000), %o2 <== NOT EXECUTED
20135f8: 17 00 80 b4 sethi %hi(0x202d000), %o3 <== NOT EXECUTED
20135fc: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
2013600: 92 10 22 d1 mov 0x2d1, %o1 <== NOT EXECUTED
2013604: 94 12 a2 d8 or %o2, 0x2d8, %o2 <== NOT EXECUTED
2013608: 40 00 08 ea call 20159b0 <__assert_func> <== NOT EXECUTED
201360c: 96 12 e2 c0 or %o3, 0x2c0, %o3 <== NOT EXECUTED
020139f4 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20139f4: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
20139f8: c0 27 bf f8 clr [ %fp + -8 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20139fc: a0 10 00 18 mov %i0, %l0
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
2013a00: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t file_cln_initial = fat_fd->map.file_cln;
2013a04: e4 06 60 34 ld [ %i1 + 0x34 ], %l2
uint32_t cln;
if ( count == 0 )
2013a08: 80 a6 e0 00 cmp %i3, 0
2013a0c: 02 80 00 5d be 2013b80 <fat_file_write+0x18c> <== NEVER TAKEN
2013a10: b0 10 20 00 clr %i0
return cmpltd;
if (start >= fat_fd->size_limit)
2013a14: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
2013a18: 80 a6 80 1d cmp %i2, %i5
2013a1c: 1a 80 00 89 bcc 2013c40 <fat_file_write+0x24c> <== NEVER TAKEN
2013a20: ba 27 40 1a sub %i5, %i2, %i5
2013a24: 80 a7 40 1b cmp %i5, %i3
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
2013a28: 18 80 00 58 bgu 2013b88 <fat_file_write+0x194> <== ALWAYS TAKEN
2013a2c: 80 a0 40 1a cmp %g1, %i2
rtems_set_errno_and_return_minus_one(EFBIG);
if (count > fat_fd->size_limit - start)
count = fat_fd->size_limit - start;
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
2013a30: b6 07 40 1a add %i5, %i2, %i3 <== NOT EXECUTED
2013a34: 94 40 20 00 addx %g0, 0, %o2 <== NOT EXECUTED
2013a38: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2013a3c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2013a40: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
2013a44: 7f ff ff 57 call 20137a0 <fat_file_extend> <== NOT EXECUTED
2013a48: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED
if (RC_OK == rc)
2013a4c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2013a50: 12 80 00 4c bne 2013b80 <fat_file_write+0x18c> <== NOT EXECUTED
2013a54: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
{
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
2013a58: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2013a5c: 32 80 00 02 bne,a 2013a64 <fat_file_write+0x70> <== NEVER TAKEN
2013a60: ba 20 40 1a sub %g1, %i2, %i5 <== NOT EXECUTED
*/
static bool
fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,
const uint8_t volume_type)
{
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
2013a64: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2013a68: 80 a0 60 01 cmp %g1, 1
2013a6c: 02 80 00 5b be 2013bd8 <fat_file_write+0x1e4>
2013a70: c4 0c 20 0e ldub [ %l0 + 0xe ], %g2
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
2013a74: f6 0c 20 08 ldub [ %l0 + 8 ], %i3
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
2013a78: c0 27 bf fc clr [ %fp + -4 ]
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
2013a7c: ab 36 80 1b srl %i2, %i3, %l5
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
2013a80: 90 10 00 10 mov %l0, %o0
2013a84: 92 10 00 19 mov %i1, %o1
2013a88: 94 10 00 15 mov %l5, %o2
2013a8c: 7f ff fd 39 call 2012f70 <fat_file_lseek>
2013a90: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
2013a94: 80 a2 60 00 cmp %o1, 0
2013a98: 12 80 00 38 bne 2013b78 <fat_file_write+0x184> <== NEVER TAKEN
2013a9c: b0 92 60 00 orcc %o1, 0, %i0
{
file_cln_cnt = cur_cln - fat_fd->cln;
2013aa0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2013aa4: ec 07 bf fc ld [ %fp + -4 ], %l6
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
2013aa8: b7 2d 40 1b sll %l5, %i3, %i3
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
2013aac: ac 25 80 01 sub %l6, %g1, %l6
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
2013ab0: b4 26 80 1b sub %i2, %i3, %i2
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
2013ab4: b0 10 20 00 clr %i0
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
2013ab8: a2 10 00 1a mov %i2, %l1
uint32_t ofs_cln_save = ofs_cln;
uint32_t bytes_to_write = count;
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
2013abc: a6 10 20 00 clr %l3
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
2013ac0: a8 10 20 00 clr %l4
const uint32_t count,
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
2013ac4: b6 10 20 00 clr %i3
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
2013ac8: 80 a7 60 00 cmp %i5, 0
2013acc: 22 80 00 21 be,a 2013b50 <fat_file_write+0x15c> <== NEVER TAKEN
2013ad0: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 <== NOT EXECUTED
2013ad4: 80 a6 20 00 cmp %i0, 0
2013ad8: 32 80 00 1e bne,a 2013b50 <fat_file_write+0x15c> <== NEVER TAKEN
2013adc: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 <== NOT EXECUTED
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
2013ae0: d6 14 20 06 lduh [ %l0 + 6 ], %o3
2013ae4: 96 22 c0 11 sub %o3, %l1, %o3
2013ae8: 80 a2 c0 1d cmp %o3, %i5
2013aec: 38 80 00 02 bgu,a 2013af4 <fat_file_write+0x100>
2013af0: 96 10 00 1d mov %i5, %o3
if (file_cln_initial < file_cln_cnt)
2013af4: 80 a4 80 16 cmp %l2, %l6
2013af8: 2a 80 00 02 bcs,a 2013b00 <fat_file_write+0x10c>
2013afc: a6 10 20 01 mov 1, %l3
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
2013b00: d2 07 bf fc ld [ %fp + -4 ], %o1
2013b04: 90 10 00 10 mov %l0, %o0
2013b08: 94 10 00 11 mov %l1, %o2
2013b0c: 98 07 00 1b add %i4, %i3, %o4
2013b10: 9a 0c e0 01 and %l3, 1, %o5
2013b14: 40 00 01 fe call 201430c <fat_cluster_write>
2013b18: b0 10 3f ff mov -1, %i0
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
2013b1c: 80 a2 20 00 cmp %o0, 0
2013b20: 06 bf ff eb bl 2013acc <fat_file_write+0xd8> <== NEVER TAKEN
2013b24: 80 a7 60 00 cmp %i5, 0
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
2013b28: ac 05 a0 01 inc %l6
bytes_to_write -= ret;
cmpltd += ret;
2013b2c: b6 06 c0 08 add %i3, %o0, %i3
save_cln = cur_cln;
if (0 < bytes_to_write)
2013b30: ba a7 40 08 subcc %i5, %o0, %i5
2013b34: 12 80 00 22 bne 2013bbc <fat_file_write+0x1c8>
2013b38: e8 07 bf fc ld [ %fp + -4 ], %l4
2013b3c: b0 10 20 00 clr %i0
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
2013b40: 80 a7 60 00 cmp %i5, 0
2013b44: 12 bf ff e4 bne 2013ad4 <fat_file_write+0xe0> <== NEVER TAKEN
2013b48: a2 10 20 00 clr %l1
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
2013b4c: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
2013b50: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
2013b54: e8 26 60 38 st %l4, [ %i1 + 0x38 ]
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
2013b58: b4 06 80 1b add %i2, %i3, %i2
2013b5c: b5 36 80 01 srl %i2, %g1, %i2
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
2013b60: aa 06 80 15 add %i2, %l5, %l5
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
}
if (RC_OK != rc)
2013b64: 92 96 20 00 orcc %i0, 0, %o1
2013b68: 12 80 00 03 bne 2013b74 <fat_file_write+0x180> <== NEVER TAKEN
2013b6c: ea 26 60 34 st %l5, [ %i1 + 0x34 ]
return rc;
else
return cmpltd;
2013b70: 92 10 00 1b mov %i3, %o1
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
2013b74: b0 92 60 00 orcc %o1, 0, %i0
2013b78: 06 80 00 30 bl 2013c38 <fat_file_write+0x244> <== NEVER TAKEN
2013b7c: 01 00 00 00 nop
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
2013b80: 81 c7 e0 08 ret
2013b84: 81 e8 00 00 restore
2013b88: ba 10 00 1b mov %i3, %i5
rtems_set_errno_and_return_minus_one(EFBIG);
if (count > fat_fd->size_limit - start)
count = fat_fd->size_limit - start;
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
2013b8c: 94 40 20 00 addx %g0, 0, %o2
2013b90: b6 07 40 1a add %i5, %i2, %i3
2013b94: 90 10 00 10 mov %l0, %o0
2013b98: 92 10 00 19 mov %i1, %o1
2013b9c: 96 10 00 1b mov %i3, %o3
2013ba0: 7f ff ff 00 call 20137a0 <fat_file_extend>
2013ba4: 98 07 bf f8 add %fp, -8, %o4
if (RC_OK == rc)
2013ba8: b0 92 20 00 orcc %o0, 0, %i0
2013bac: 12 bf ff f5 bne 2013b80 <fat_file_write+0x18c>
2013bb0: c2 07 bf f8 ld [ %fp + -8 ], %g1
{
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
2013bb4: 10 bf ff aa b 2013a5c <fat_file_write+0x68>
2013bb8: 80 a6 c0 01 cmp %i3, %g1
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
if (0 < bytes_to_write)
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2013bbc: 90 10 00 10 mov %l0, %o0
2013bc0: 92 10 00 14 mov %l4, %o1
2013bc4: 94 07 bf fc add %fp, -4, %o2
2013bc8: 40 00 1c 8a call 201adf0 <fat_get_fat_cluster>
2013bcc: a2 10 20 00 clr %l1
2013bd0: 10 bf ff be b 2013ac8 <fat_file_write+0xd4>
2013bd4: b0 10 00 08 mov %o0, %i0
*/
static bool
fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,
const uint8_t volume_type)
{
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
2013bd8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2013bdc: 80 a0 60 00 cmp %g1, 0
2013be0: 32 bf ff a6 bne,a 2013a78 <fat_file_write+0x84> <== NEVER TAKEN
2013be4: f6 0c 20 08 ldub [ %l0 + 8 ], %i3 <== NOT EXECUTED
2013be8: 80 88 a0 03 btst 3, %g2
2013bec: 22 bf ff a3 be,a 2013a78 <fat_file_write+0x84>
2013bf0: f6 0c 20 08 ldub [ %l0 + 8 ], %i3
count = c - start;
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
{
cln = fat_fd->cln;
2013bf4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
cln += (start >> fs_info->vol.bpc_log2);
2013bf8: d2 0c 20 08 ldub [ %l0 + 8 ], %o1
byte = start & (fs_info->vol.bpc -1);
2013bfc: d4 14 20 06 lduh [ %l0 + 6 ], %o2
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
{
cln = fat_fd->cln;
cln += (start >> fs_info->vol.bpc_log2);
2013c00: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bpc -1);
2013c04: 94 02 bf ff add %o2, -1, %o2
ret = fat_cluster_write(fs_info,
2013c08: 90 10 00 10 mov %l0, %o0
2013c0c: 92 02 40 01 add %o1, %g1, %o1
2013c10: 94 0e 80 0a and %i2, %o2, %o2
2013c14: 96 10 00 1d mov %i5, %o3
2013c18: 98 10 00 1c mov %i4, %o4
2013c1c: 40 00 01 bc call 201430c <fat_cluster_write>
2013c20: 9a 10 20 00 clr %o5
cln,
byte,
count,
buf,
false);
if (0 > ret)
2013c24: 80 a2 20 00 cmp %o0, 0
2013c28: 06 80 00 04 bl 2013c38 <fat_file_write+0x244> <== NEVER TAKEN
2013c2c: 01 00 00 00 nop
rc = -1;
else
cmpltd = ret;
2013c30: 81 c7 e0 08 ret
2013c34: 91 e8 00 08 restore %g0, %o0, %o0
start,
count,
buf,
file_cln_initial);
if (0 > ret)
rc = -1;
2013c38: 81 c7 e0 08 ret <== NOT EXECUTED
2013c3c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
if ( count == 0 )
return cmpltd;
if (start >= fat_fd->size_limit)
rtems_set_errno_and_return_minus_one(EFBIG);
2013c40: 40 00 25 23 call 201d0cc <__errno> <== NOT EXECUTED
2013c44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013c48: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
2013c4c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013c50: 81 c7 e0 08 ret <== NOT EXECUTED
2013c54: 81 e8 00 00 restore <== NOT EXECUTED
0201b2c8 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
201b2c8: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
201b2cc: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
201b2d0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
201b2d4: c0 27 bf fc clr [ %fp + -4 ]
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
201b2d8: 84 0e 40 02 and %i1, %g2, %g2
201b2dc: 80 a0 80 01 cmp %g2, %g1
201b2e0: 1a 80 00 25 bcc 201b374 <fat_free_fat_clusters_chain+0xac><== NEVER TAKEN
201b2e4: ba 10 00 18 mov %i0, %i5
201b2e8: b8 10 00 19 mov %i1, %i4
201b2ec: b6 10 20 00 clr %i3
201b2f0: 10 80 00 0e b 201b328 <fat_free_fat_clusters_chain+0x60>
201b2f4: b4 10 20 00 clr %i2
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
201b2f8: 7f ff ff 42 call 201b000 <fat_set_fat_cluster>
201b2fc: 01 00 00 00 nop
if ( rc != RC_OK )
201b300: 80 a2 20 00 cmp %o0, 0
201b304: 02 80 00 03 be 201b310 <fat_free_fat_clusters_chain+0x48> <== ALWAYS TAKEN
201b308: f8 07 bf fc ld [ %fp + -4 ], %i4
201b30c: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
201b310: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
201b314: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
201b318: 84 0f 00 02 and %i4, %g2, %g2
201b31c: 80 a0 80 01 cmp %g2, %g1
201b320: 1a 80 00 17 bcc 201b37c <fat_free_fat_clusters_chain+0xb4>
201b324: b6 06 e0 01 inc %i3
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
201b328: 92 10 00 1c mov %i4, %o1
201b32c: 94 07 bf fc add %fp, -4, %o2
201b330: 7f ff fe b0 call 201adf0 <fat_get_fat_cluster>
201b334: 90 10 00 1d mov %i5, %o0
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
201b338: 92 10 00 1c mov %i4, %o1
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
201b33c: b0 10 00 08 mov %o0, %i0
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
201b340: 94 10 20 00 clr %o2
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
if ( rc != RC_OK )
201b344: 80 a6 20 00 cmp %i0, 0
201b348: 02 bf ff ec be 201b2f8 <fat_free_fat_clusters_chain+0x30> <== ALWAYS TAKEN
201b34c: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
201b350: c2 07 60 44 ld [ %i5 + 0x44 ], %g1 <== NOT EXECUTED
201b354: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
201b358: 02 80 00 03 be 201b364 <fat_free_fat_clusters_chain+0x9c> <== NOT EXECUTED
201b35c: 82 06 c0 01 add %i3, %g1, %g1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
201b360: c2 27 60 44 st %g1, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
201b364: 7f ff e2 99 call 2013dc8 <fat_buf_release> <== NOT EXECUTED
201b368: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201b36c: 81 c7 e0 08 ret <== NOT EXECUTED
201b370: 81 e8 00 00 restore <== NOT EXECUTED
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
201b374: b6 10 20 00 clr %i3 <== NOT EXECUTED
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
201b378: b4 10 20 00 clr %i2 <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
201b37c: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
201b380: 80 a0 7f ff cmp %g1, -1
201b384: 02 80 00 04 be 201b394 <fat_free_fat_clusters_chain+0xcc> <== ALWAYS TAKEN
201b388: f2 27 60 4c st %i1, [ %i5 + 0x4c ]
fs_info->vol.free_cls += freed_cls_cnt;
201b38c: 82 06 c0 01 add %i3, %g1, %g1 <== NOT EXECUTED
201b390: c2 27 60 44 st %g1, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
201b394: b0 10 00 1a mov %i2, %i0
201b398: 7f ff e2 8c call 2013dc8 <fat_buf_release>
201b39c: 90 10 00 1d mov %i5, %o0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
201b3a0: 81 c7 e0 08 ret
201b3a4: 81 e8 00 00 restore
0201502c <fat_free_unique_ino>:
fat_free_unique_ino(
fat_fs_info_t *fs_info,
uint32_t ino
)
{
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
201502c: c4 02 20 80 ld [ %o0 + 0x80 ], %g2 <== NOT EXECUTED
2015030: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 <== NOT EXECUTED
2015034: 92 22 40 02 sub %o1, %g2, %o1 <== NOT EXECUTED
2015038: 85 32 60 03 srl %o1, 3, %g2 <== NOT EXECUTED
201503c: c6 08 40 02 ldub [ %g1 + %g2 ], %g3 <== NOT EXECUTED
2015040: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
2015044: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
2015048: 93 29 00 09 sll %g4, %o1, %o1 <== NOT EXECUTED
201504c: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
2015050: 81 c3 e0 08 retl <== NOT EXECUTED
2015054: d2 28 40 02 stb %o1, [ %g1 + %g2 ] <== NOT EXECUTED
0201adf0 <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
201adf0: 9d e3 bf 98 save %sp, -104, %sp
uint8_t *sec_buf;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
201adf4: 80 a6 60 01 cmp %i1, 1
201adf8: 08 80 00 27 bleu 201ae94 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
201adfc: ba 10 00 18 mov %i0, %i5
201ae00: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
201ae04: 82 00 60 01 inc %g1
201ae08: 80 a6 40 01 cmp %i1, %g1
201ae0c: 18 80 00 22 bgu 201ae94 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
201ae10: 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) +
201ae14: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
201ae18: 80 88 60 01 btst 1, %g1
201ae1c: 12 80 00 24 bne 201aeac <fat_get_fat_cluster+0xbc>
201ae20: f6 0e 20 02 ldub [ %i0 + 2 ], %i3
201ae24: 82 08 60 02 and %g1, 2, %g1
201ae28: 80 88 60 ff btst 0xff, %g1
201ae2c: 02 80 00 30 be 201aeec <fat_get_fat_cluster+0xfc>
201ae30: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
201ae34: b9 2e 60 01 sll %i1, 1, %i4
201ae38: b7 37 00 1b srl %i4, %i3, %i3
201ae3c: b6 06 c0 01 add %i3, %g1, %i3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
201ae40: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
201ae44: 90 10 00 1d mov %i5, %o0
201ae48: 92 10 00 1b mov %i3, %o1
201ae4c: 94 10 20 01 mov 1, %o2
201ae50: 7f ff e4 55 call 2013fa4 <fat_buf_access>
201ae54: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
201ae58: b0 92 20 00 orcc %o0, 0, %i0
201ae5c: 12 80 00 57 bne 201afb8 <fat_get_fat_cluster+0x1c8> <== NEVER TAKEN
201ae60: 01 00 00 00 nop
return rc;
switch ( fs_info->vol.type )
201ae64: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
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);
201ae68: a1 2c 20 10 sll %l0, 0x10, %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
201ae6c: 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);
201ae70: a1 34 20 10 srl %l0, 0x10, %l0
201ae74: a0 04 3f ff add %l0, -1, %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
201ae78: 02 80 00 21 be 201aefc <fat_get_fat_cluster+0x10c>
201ae7c: b8 0f 00 10 and %i4, %l0, %i4
201ae80: 80 a0 60 04 cmp %g1, 4
201ae84: 02 80 00 3c be 201af74 <fat_get_fat_cluster+0x184>
201ae88: 80 a0 60 01 cmp %g1, 1
201ae8c: 02 80 00 28 be 201af2c <fat_get_fat_cluster+0x13c> <== ALWAYS TAKEN
201ae90: c4 07 bf fc ld [ %fp + -4 ], %g2
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
201ae94: 40 00 08 8e call 201d0cc <__errno> <== NOT EXECUTED
201ae98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201ae9c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201aea0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201aea4: 81 c7 e0 08 ret <== NOT EXECUTED
201aea8: 81 e8 00 00 restore <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
201aeac: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
201aeb0: b9 36 60 01 srl %i1, 1, %i4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
201aeb4: e0 17 40 00 lduh [ %i5 ], %l0
/* 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) +
201aeb8: b8 07 00 19 add %i4, %i1, %i4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
201aebc: 90 10 00 1d mov %i5, %o0
/* 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) +
201aec0: b7 37 00 1b srl %i4, %i3, %i3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
201aec4: 94 10 20 01 mov 1, %o2
/* 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) +
201aec8: b6 06 c0 01 add %i3, %g1, %i3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
201aecc: 96 07 bf fc add %fp, -4, %o3
201aed0: 7f ff e4 35 call 2013fa4 <fat_buf_access>
201aed4: 92 10 00 1b mov %i3, %o1
if (rc != RC_OK)
201aed8: b0 92 20 00 orcc %o0, 0, %i0
201aedc: 22 bf ff e3 be,a 201ae68 <fat_get_fat_cluster+0x78> <== ALWAYS TAKEN
201aee0: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
201aee4: 81 c7 e0 08 ret <== NOT EXECUTED
201aee8: 81 e8 00 00 restore <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
201aeec: b9 2e 60 02 sll %i1, 2, %i4
201aef0: b7 37 00 1b srl %i4, %i3, %i3
201aef4: 10 bf ff d3 b 201ae40 <fat_get_fat_cluster+0x50>
201aef8: b6 06 c0 01 add %i3, %g1, %i3
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
201aefc: c2 07 bf fc ld [ %fp + -4 ], %g1
*ret_val = CF_LE_W(*ret_val);
201af00: 07 00 00 3f sethi %hi(0xfc00), %g3
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
201af04: c2 10 40 1c lduh [ %g1 + %i4 ], %g1
*ret_val = CF_LE_W(*ret_val);
201af08: 86 10 e3 ff or %g3, 0x3ff, %g3
201af0c: 83 28 60 10 sll %g1, 0x10, %g1
201af10: 85 30 60 18 srl %g1, 0x18, %g2
201af14: 83 30 60 08 srl %g1, 8, %g1
201af18: 82 08 40 03 and %g1, %g3, %g1
201af1c: 82 10 80 01 or %g2, %g1, %g1
201af20: c2 26 80 00 st %g1, [ %i2 ]
break;
201af24: 81 c7 e0 08 ret
201af28: 81 e8 00 00 restore
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
201af2c: 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 = (*(sec_buf + ofs));
201af30: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
if ( ofs == (fs_info->vol.bps - 1) )
201af34: 86 00 ff ff add %g3, -1, %g3
201af38: 80 a0 c0 1c cmp %g3, %i4
201af3c: 02 80 00 21 be 201afc0 <fat_get_fat_cluster+0x1d0> <== NEVER TAKEN
201af40: c2 26 80 00 st %g1, [ %i2 ]
*ret_val |= *sec_buf << 8;
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
201af44: b8 00 80 1c add %g2, %i4, %i4
201af48: c4 0f 20 01 ldub [ %i4 + 1 ], %g2
201af4c: 85 28 a0 08 sll %g2, 8, %g2
201af50: 82 10 80 01 or %g2, %g1, %g1
201af54: c2 26 80 00 st %g1, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
201af58: 80 8e 60 01 btst 1, %i1
201af5c: 22 80 00 16 be,a 201afb4 <fat_get_fat_cluster+0x1c4>
201af60: 82 08 6f ff and %g1, 0xfff, %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
201af64: 83 30 60 04 srl %g1, 4, %g1
201af68: c2 26 80 00 st %g1, [ %i2 ]
201af6c: 81 c7 e0 08 ret
201af70: 81 e8 00 00 restore
*ret_val = *((uint16_t *)(sec_buf + ofs));
*ret_val = CF_LE_W(*ret_val);
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(sec_buf + ofs));
201af74: c2 07 bf fc ld [ %fp + -4 ], %g1
201af78: c2 00 40 1c ld [ %g1 + %i4 ], %g1
201af7c: 89 28 60 18 sll %g1, 0x18, %g4
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
201af80: 85 30 60 18 srl %g1, 0x18, %g2
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
201af84: 87 30 60 08 srl %g1, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201af88: 84 11 00 02 or %g4, %g2, %g2
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
201af8c: 86 08 e0 ff and %g3, 0xff, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
201af90: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201af94: 87 28 e0 10 sll %g3, 0x10, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
201af98: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201af9c: 84 10 80 03 or %g2, %g3, %g2
201afa0: 83 28 60 08 sll %g1, 8, %g1
201afa4: 82 10 80 01 or %g2, %g1, %g1
*ret_val = CF_LE_L(*ret_val);
201afa8: c2 26 80 00 st %g1, [ %i2 ]
break;
201afac: 81 c7 e0 08 ret
201afb0: 81 e8 00 00 restore
}
if ( FAT_CLUSTER_IS_ODD(cln) )
*ret_val = (*ret_val) >> FAT12_SHIFT;
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
201afb4: c2 26 80 00 st %g1, [ %i2 ]
201afb8: 81 c7 e0 08 ret
201afbc: 81 e8 00 00 restore
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
201afc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201afc4: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
201afc8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201afcc: 7f ff e3 f6 call 2013fa4 <fat_buf_access> <== NOT EXECUTED
201afd0: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
201afd4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201afd8: 12 80 00 08 bne 201aff8 <fat_get_fat_cluster+0x208> <== NOT EXECUTED
201afdc: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
201afe0: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
201afe4: c4 08 80 00 ldub [ %g2 ], %g2 <== NOT EXECUTED
201afe8: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
201afec: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
201aff0: 10 bf ff da b 201af58 <fat_get_fat_cluster+0x168> <== NOT EXECUTED
201aff4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
201aff8: 81 c7 e0 08 ret <== NOT EXECUTED
201affc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02014f3c <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
2014f3c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
2014f40: fa 06 20 7c ld [ %i0 + 0x7c ], %i5 <== 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))
2014f44: 33 03 ff ff sethi %hi(0xffffc00), %i1 <== NOT EXECUTED
2014f48: b2 16 63 ff or %i1, 0x3ff, %i1 ! fffffff <RAM_END+0xdbfffff><== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
2014f4c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2014f50: 22 80 00 20 be,a 2014fd0 <fat_get_unique_ino+0x94> <== NOT EXECUTED
2014f54: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
2014f58: c6 06 20 74 ld [ %i0 + 0x74 ], %g3 <== NOT EXECUTED
2014f5c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
2014f60: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
2014f64: c8 48 c0 02 ldsb [ %g3 + %g2 ], %g4 <== NOT EXECUTED
2014f68: b8 08 60 07 and %g1, 7, %i4 <== NOT EXECUTED
2014f6c: b4 00 c0 02 add %g3, %g2, %i2 <== NOT EXECUTED
2014f70: 89 39 00 1c sra %g4, %i4, %g4 <== NOT EXECUTED
2014f74: 80 89 20 01 btst 1, %g4 <== NOT EXECUTED
2014f78: 02 80 00 1d be 2014fec <fat_get_unique_ino+0xb0> <== NOT EXECUTED
2014f7c: c4 08 c0 02 ldub [ %g3 + %g2 ], %g2 <== NOT EXECUTED
2014f80: 10 80 00 0a b 2014fa8 <fat_get_unique_ino+0x6c> <== NOT EXECUTED
2014f84: 88 10 20 00 clr %g4 <== NOT EXECUTED
2014f88: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
2014f8c: f6 48 c0 02 ldsb [ %g3 + %g2 ], %i3 <== NOT EXECUTED
2014f90: b8 08 60 07 and %g1, 7, %i4 <== NOT EXECUTED
2014f94: b4 00 c0 02 add %g3, %g2, %i2 <== NOT EXECUTED
2014f98: b7 3e c0 1c sra %i3, %i4, %i3 <== NOT EXECUTED
2014f9c: 80 8e e0 01 btst 1, %i3 <== NOT EXECUTED
2014fa0: 02 80 00 13 be 2014fec <fat_get_unique_ino+0xb0> <== NOT EXECUTED
2014fa4: c4 08 c0 02 ldub [ %g3 + %g2 ], %g2 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
2014fa8: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
2014fac: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
2014fb0: 0a 80 00 03 bcs 2014fbc <fat_get_unique_ino+0x80> <== NOT EXECUTED
2014fb4: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED
fs_info->index = 0;
2014fb8: c0 26 20 78 clr [ %i0 + 0x78 ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
2014fbc: 88 01 20 01 inc %g4 <== NOT EXECUTED
2014fc0: 80 a1 00 1d cmp %g4, %i5 <== NOT EXECUTED
2014fc4: 32 bf ff f1 bne,a 2014f88 <fat_get_unique_ino+0x4c> <== NOT EXECUTED
2014fc8: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== 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))
2014fcc: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2014fd0: 93 2f 60 01 sll %i5, 1, %o1 <== NOT EXECUTED
2014fd4: 82 26 40 01 sub %i1, %g1, %g1 <== NOT EXECUTED
2014fd8: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
2014fdc: 2a 80 00 0c bcs,a 201500c <fat_get_unique_ino+0xd0> <== NOT EXECUTED
2014fe0: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
2014fe4: 81 c7 e0 08 ret <== NOT EXECUTED
2014fe8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
2014fec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2014ff0: b9 28 40 1c sll %g1, %i4, %i4 <== NOT EXECUTED
2014ff4: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
2014ff8: c4 2e 80 00 stb %g2, [ %i2 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
2014ffc: c4 06 20 78 ld [ %i0 + 0x78 ], %g2 <== NOT EXECUTED
2015000: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2015004: 81 c7 e0 08 ret <== NOT EXECUTED
2015008: 91 e8 80 01 restore %g2, %g1, %o0 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
201500c: 7f ff c5 3b call 20064f8 <realloc> <== NOT EXECUTED
2015010: d2 26 20 7c st %o1, [ %i0 + 0x7c ] <== NOT EXECUTED
if (fs_info->uino != NULL)
2015014: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2015018: 02 bf ff f3 be 2014fe4 <fat_get_unique_ino+0xa8> <== NOT EXECUTED
201501c: d0 26 20 74 st %o0, [ %i0 + 0x74 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
2015020: fa 06 20 7c ld [ %i0 + 0x7c ], %i5 <== NOT EXECUTED
2015024: 10 bf ff ca b 2014f4c <fat_get_unique_ino+0x10> <== NOT EXECUTED
2015028: fa 26 20 78 st %i5, [ %i0 + 0x78 ] <== NOT EXECUTED
02014ec0 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
2014ec0: 9d e3 bf 98 save %sp, -104, %sp
2014ec4: f2 27 bf fc st %i1, [ %fp + -4 ]
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2014ec8: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
2014ecc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
2014ed0: 92 10 00 19 mov %i1, %o1
2014ed4: 94 10 20 00 clr %o2
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2014ed8: b2 0e 40 02 and %i1, %g2, %i1
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
2014edc: 98 10 20 00 clr %o4
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2014ee0: 80 a6 40 01 cmp %i1, %g1
2014ee4: 1a 80 00 10 bcc 2014f24 <fat_init_clusters_chain+0x64>
2014ee8: 90 10 00 18 mov %i0, %o0
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
2014eec: 7f ff fc a8 call 201418c <fat_cluster_set>
2014ef0: d6 16 20 06 lduh [ %i0 + 6 ], %o3
if ( ret != fs_info->vol.bpc )
2014ef4: c2 16 20 06 lduh [ %i0 + 6 ], %g1
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2014ef8: 94 07 bf fc add %fp, -4, %o2
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
if ( ret != fs_info->vol.bpc )
2014efc: 80 a0 40 08 cmp %g1, %o0
2014f00: 12 80 00 0c bne 2014f30 <fat_init_clusters_chain+0x70> <== NEVER TAKEN
2014f04: 90 10 00 18 mov %i0, %o0
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2014f08: 40 00 17 ba call 201adf0 <fat_get_fat_cluster>
2014f0c: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
2014f10: 80 a2 20 00 cmp %o0, 0
2014f14: 02 bf ff ed be 2014ec8 <fat_init_clusters_chain+0x8> <== ALWAYS TAKEN
2014f18: f2 07 bf fc ld [ %fp + -4 ], %i1
}
}
return rc;
}
2014f1c: 81 c7 e0 08 ret <== NOT EXECUTED
2014f20: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
return rc;
}
}
return rc;
2014f24: 90 10 20 00 clr %o0
}
2014f28: 81 c7 e0 08 ret
2014f2c: 91 e8 00 08 restore %g0, %o0, %o0
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
if ( ret != fs_info->vol.bpc )
{
return -1;
2014f30: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
}
}
return rc;
}
2014f34: 81 c7 e0 08 ret <== NOT EXECUTED
2014f38: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02014494 <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
2014494: 9d e3 bf 10 save %sp, -240, %sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
2014498: 92 10 20 02 mov 2, %o1
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;
201449c: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
20144a0: 7f ff c7 79 call 2006284 <open>
20144a4: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
20144a8: 80 a2 20 00 cmp %o0, 0
20144ac: 06 80 01 c1 bl 2014bb0 <fat_init_volume_info+0x71c> <== NEVER TAKEN
20144b0: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
20144b4: 7f ff c4 14 call 2005504 <fstat>
20144b8: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
20144bc: 80 a2 20 00 cmp %o0, 0
20144c0: 12 80 01 b9 bne 2014ba4 <fat_init_volume_info+0x710> <== NEVER TAKEN
20144c4: c6 07 bf c4 ld [ %fp + -60 ], %g3
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
20144c8: 05 00 00 3c sethi %hi(0xf000), %g2
20144cc: 86 08 c0 02 and %g3, %g2, %g3
20144d0: 05 00 00 18 sethi %hi(0x6000), %g2
20144d4: 80 a0 c0 02 cmp %g3, %g2
20144d8: 12 80 01 b4 bne 2014ba8 <fat_init_volume_info+0x714> <== NEVER TAKEN
20144dc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
20144e0: 94 06 20 64 add %i0, 0x64, %o2
20144e4: 13 10 01 10 sethi %hi(0x40044000), %o1
20144e8: 40 00 06 09 call 2015d0c <ioctl>
20144ec: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <RAM_END+0x3dc44209>
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) {
20144f0: 80 a2 20 00 cmp %o0, 0
20144f4: 12 80 01 ac bne 2014ba4 <fat_init_volume_info+0x710> <== NEVER TAKEN
20144f8: 92 10 20 00 clr %o1
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);
20144fc: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
2014500: 7f ff f5 c8 call 2011c20 <rtems_bdbuf_read>
2014504: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
2014508: 80 a2 20 00 cmp %o0, 0
201450c: 12 80 01 b5 bne 2014be0 <fat_init_volume_info+0x74c> <== NEVER TAKEN
2014510: d0 07 bf a4 ld [ %fp + -92 ], %o0
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
2014514: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
2014518: c2 08 a0 20 ldub [ %g2 + 0x20 ], %g1
201451c: f8 08 a0 0b ldub [ %g2 + 0xb ], %i4
2014520: c2 2f bf 93 stb %g1, [ %fp + -109 ]
2014524: c2 08 a0 21 ldub [ %g2 + 0x21 ], %g1
2014528: f6 08 a0 0c ldub [ %g2 + 0xc ], %i3
201452c: c2 2f bf 95 stb %g1, [ %fp + -107 ]
2014530: c2 08 a0 22 ldub [ %g2 + 0x22 ], %g1
2014534: ec 08 a0 0d ldub [ %g2 + 0xd ], %l6
2014538: c2 2f bf 94 stb %g1, [ %fp + -108 ]
201453c: c2 08 a0 23 ldub [ %g2 + 0x23 ], %g1
2014540: e8 08 a0 0e ldub [ %g2 + 0xe ], %l4
2014544: c2 2f bf 8f stb %g1, [ %fp + -113 ]
2014548: c2 08 a0 25 ldub [ %g2 + 0x25 ], %g1
201454c: ea 08 a0 0f ldub [ %g2 + 0xf ], %l5
2014550: c2 2f bf 97 stb %g1, [ %fp + -105 ]
2014554: c2 08 a0 26 ldub [ %g2 + 0x26 ], %g1
2014558: fa 08 a0 10 ldub [ %g2 + 0x10 ], %i5
201455c: c2 2f bf 96 stb %g1, [ %fp + -106 ]
2014560: c2 08 a0 27 ldub [ %g2 + 0x27 ], %g1
2014564: f4 08 a0 11 ldub [ %g2 + 0x11 ], %i2
2014568: c2 2f bf 9f stb %g1, [ %fp + -97 ]
201456c: c2 08 a0 28 ldub [ %g2 + 0x28 ], %g1
2014570: f2 08 a0 12 ldub [ %g2 + 0x12 ], %i1
2014574: c2 2f bf 87 stb %g1, [ %fp + -121 ]
2014578: c2 08 a0 2c ldub [ %g2 + 0x2c ], %g1
201457c: e0 08 a0 13 ldub [ %g2 + 0x13 ], %l0
2014580: c2 2f bf 90 stb %g1, [ %fp + -112 ]
2014584: c2 08 a0 2d ldub [ %g2 + 0x2d ], %g1
2014588: e2 08 a0 14 ldub [ %g2 + 0x14 ], %l1
201458c: e4 08 a0 16 ldub [ %g2 + 0x16 ], %l2
2014590: e6 08 a0 17 ldub [ %g2 + 0x17 ], %l3
2014594: ee 08 a0 24 ldub [ %g2 + 0x24 ], %l7
2014598: c2 2f bf 7f stb %g1, [ %fp + -129 ]
201459c: c2 08 a0 2e ldub [ %g2 + 0x2e ], %g1
20145a0: c2 2f bf 7e stb %g1, [ %fp + -130 ]
20145a4: c2 08 a0 2f ldub [ %g2 + 0x2f ], %g1
20145a8: c2 2f bf 77 stb %g1, [ %fp + -137 ]
20145ac: c2 08 a0 30 ldub [ %g2 + 0x30 ], %g1
20145b0: c4 08 a0 31 ldub [ %g2 + 0x31 ], %g2
20145b4: c2 2f bf 92 stb %g1, [ %fp + -110 ]
sc = rtems_bdbuf_release( block);
20145b8: 7f ff f6 1f call 2011e34 <rtems_bdbuf_release>
20145bc: c4 2f bf 91 stb %g2, [ %fp + -111 ]
if (sc != RTEMS_SUCCESSFUL)
20145c0: 80 a2 20 00 cmp %o0, 0
20145c4: 12 80 01 87 bne 2014be0 <fat_init_volume_info+0x74c> <== NEVER TAKEN
20145c8: b6 0e e0 ff and %i3, 0xff, %i3
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
20145cc: b8 0f 20 ff and %i4, 0xff, %i4
20145d0: b7 2e e0 08 sll %i3, 8, %i3
20145d4: b8 16 c0 1c or %i3, %i4, %i4
20145d8: f8 36 00 00 sth %i4, [ %i0 ]
if ( (vol->bps != 512) &&
20145dc: 93 2f 20 10 sll %i4, 0x10, %o1
20145e0: 85 32 60 10 srl %o1, 0x10, %g2
20145e4: 80 a0 a4 00 cmp %g2, 0x400
20145e8: 12 80 00 dc bne 2014958 <fat_init_volume_info+0x4c4> <== ALWAYS TAKEN
20145ec: 9a 10 00 1c mov %i4, %o5
(vol->bps != 4096))
{
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;
20145f0: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
20145f4: 80 88 a0 01 btst 1, %g2
20145f8: 12 80 00 0a bne 2014620 <fat_init_volume_info+0x18c> <== ALWAYS TAKEN
20145fc: c0 2e 20 03 clrb [ %i0 + 3 ]
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
2014600: 10 80 00 03 b 201460c <fat_init_volume_info+0x178> <== NOT EXECUTED
2014604: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
(vol->bps != 4096))
{
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;
2014608: 88 10 00 0f mov %o7, %g4 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
201460c: 85 38 a0 01 sra %g2, 1, %g2 <== NOT EXECUTED
(vol->bps != 4096))
{
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;
2014610: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
2014614: 02 bf ff fd be 2014608 <fat_init_volume_info+0x174> <== NOT EXECUTED
2014618: 9e 01 20 01 add %g4, 1, %o7 <== NOT EXECUTED
201461c: c8 2e 20 03 stb %g4, [ %i0 + 3 ] <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
2014620: c0 2e 20 02 clrb [ %i0 + 2 ]
2014624: 93 32 60 10 srl %o1, 0x10, %o1
2014628: b6 10 20 01 mov 1, %i3
201462c: 80 8f 20 01 btst 1, %i4
2014630: 02 80 00 05 be 2014644 <fat_init_volume_info+0x1b0> <== ALWAYS TAKEN
2014634: 84 10 00 09 mov %o1, %g2
2014638: 10 80 01 66 b 2014bd0 <fat_init_volume_info+0x73c> <== NOT EXECUTED
201463c: b6 10 20 00 clr %i3 <== NOT EXECUTED
2014640: b6 10 00 04 mov %g4, %i3
i >>= 1, vol->sec_log2++);
2014644: 85 38 a0 01 sra %g2, 1, %g2
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;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
2014648: 80 88 a0 01 btst 1, %g2
201464c: 02 bf ff fd be 2014640 <fat_init_volume_info+0x1ac>
2014650: 88 06 e0 01 add %i3, 1, %g4
2014654: f6 2e 20 02 stb %i3, [ %i0 + 2 ]
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
vol->bytes_per_block_log2 = vol->sec_log2;
vol->sectors_per_block = 1;
2014658: 84 10 20 01 mov 1, %g2
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
201465c: da 36 20 0a sth %o5, [ %i0 + 0xa ]
vol->bytes_per_block_log2 = vol->sec_log2;
2014660: f6 2e 20 0c stb %i3, [ %i0 + 0xc ]
vol->sectors_per_block = 1;
2014664: c4 2e 20 09 stb %g2, [ %i0 + 9 ]
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)
2014668: b8 8d a0 ff andcc %l6, 0xff, %i4
201466c: 02 80 01 45 be 2014b80 <fat_init_volume_info+0x6ec> <== NEVER TAKEN
2014670: ec 2e 20 04 stb %l6, [ %i0 + 4 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
2014674: c0 2e 20 05 clrb [ %i0 + 5 ]
2014678: 80 8d a0 01 btst 1, %l6
201467c: 12 80 01 57 bne 2014bd8 <fat_init_volume_info+0x744>
2014680: 84 10 00 1c mov %i4, %g2
2014684: 10 80 00 03 b 2014690 <fat_init_volume_info+0x1fc>
2014688: 86 10 20 01 mov 1, %g3
201468c: 86 10 00 04 mov %g4, %g3
i >>= 1, vol->spc_log2++);
2014690: 85 38 a0 01 sra %g2, 1, %g2
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
2014694: 80 88 a0 01 btst 1, %g2
2014698: 02 bf ff fd be 201468c <fat_init_volume_info+0x1f8>
201469c: 88 00 e0 01 add %g3, 1, %g4
20146a0: c6 2e 20 05 stb %g3, [ %i0 + 5 ]
20146a4: 86 08 e0 ff and %g3, 0xff, %g3
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)
20146a8: 87 2a 40 03 sll %o1, %g3, %g3
20146ac: 89 28 e0 10 sll %g3, 0x10, %g4
20146b0: 05 20 00 00 sethi %hi(0x80000000), %g2
20146b4: 80 a1 00 02 cmp %g4, %g2
20146b8: 18 80 01 32 bgu 2014b80 <fat_init_volume_info+0x6ec> <== NEVER TAKEN
20146bc: c6 36 20 06 sth %g3, [ %i0 + 6 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
20146c0: c0 2e 20 08 clrb [ %i0 + 8 ]
20146c4: 05 00 00 3f sethi %hi(0xfc00), %g2
20146c8: 88 10 20 01 mov 1, %g4
20146cc: 84 10 a3 ff or %g2, 0x3ff, %g2
20146d0: 80 88 e0 01 btst 1, %g3
20146d4: 02 80 00 05 be 20146e8 <fat_init_volume_info+0x254> <== ALWAYS TAKEN
20146d8: 84 08 c0 02 and %g3, %g2, %g2
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);
20146dc: 10 80 00 09 b 2014700 <fat_init_volume_info+0x26c> <== NOT EXECUTED
20146e0: b4 0e a0 ff and %i2, 0xff, %i2 <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
20146e4: 88 10 00 03 mov %g3, %g4
i >>= 1, vol->bpc_log2++);
20146e8: 85 38 a0 01 sra %g2, 1, %g2
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
20146ec: 80 88 a0 01 btst 1, %g2
20146f0: 02 bf ff fd be 20146e4 <fat_init_volume_info+0x250>
20146f4: 86 01 20 01 add %g4, 1, %g3
20146f8: c8 2e 20 08 stb %g4, [ %i0 + 8 ]
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);
20146fc: b4 0e a0 ff and %i2, 0xff, %i2
2014700: b2 0e 60 ff and %i1, 0xff, %i1
2014704: b3 2e 60 08 sll %i1, 8, %i1
2014708: b2 16 40 1a or %i1, %i2, %i1
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
201470c: 87 2e 60 10 sll %i1, 0x10, %g3
2014710: 87 30 e0 0b srl %g3, 0xb, %g3
2014714: 90 02 7f ff add %o1, -1, %o0
}
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);
2014718: fa 2e 20 0d stb %i5, [ %i0 + 0xd ]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
201471c: aa 0d 60 ff and %l5, 0xff, %l5
2014720: a8 0d 20 ff and %l4, 0xff, %l4
2014724: ab 2d 60 08 sll %l5, 8, %l5
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
2014728: f2 36 20 24 sth %i1, [ %i0 + 0x24 ]
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);
201472c: a8 15 40 14 or %l5, %l4, %l4
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)) /
2014730: 90 00 c0 08 add %g3, %o0, %o0
2014734: 7f ff b7 d2 call 200267c <.div>
2014738: e8 36 20 18 sth %l4, [ %i0 + 0x18 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
201473c: b7 2a 00 1b sll %o0, %i3, %i3
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)) /
2014740: d0 26 20 28 st %o0, [ %i0 + 0x28 ]
2014744: b4 10 00 08 mov %o0, %i2
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
2014748: a4 0c a0 ff and %l2, 0xff, %l2
201474c: 90 0c e0 ff and %l3, 0xff, %o0
2014750: 91 2a 20 08 sll %o0, 8, %o0
2014754: 90 12 00 12 or %o0, %l2, %o0
2014758: 91 2a 20 10 sll %o0, 0x10, %o0
201475c: 80 a2 20 00 cmp %o0, 0
2014760: 02 80 00 8a be 2014988 <fat_init_volume_info+0x4f4>
2014764: f6 26 20 2c st %i3, [ %i0 + 0x2c ]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
2014768: 91 32 20 10 srl %o0, 0x10, %o0
201476c: d0 26 20 1c st %o0, [ %i0 + 0x1c ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
2014770: 92 0f 60 ff and %i5, 0xff, %o1
2014774: 7f ff b7 86 call 200258c <.umul>
2014778: a9 2d 20 10 sll %l4, 0x10, %l4
201477c: a9 35 20 10 srl %l4, 0x10, %l4
2014780: 90 02 00 14 add %o0, %l4, %o0
2014784: b4 02 00 1a add %o0, %i2, %i2
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
2014788: d0 26 20 20 st %o0, [ %i0 + 0x20 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
201478c: 90 0c 60 ff and %l1, 0xff, %o0
2014790: a0 0c 20 ff and %l0, 0xff, %l0
2014794: 91 2a 20 08 sll %o0, 8, %o0
2014798: 90 12 00 10 or %o0, %l0, %o0
201479c: 91 2a 20 10 sll %o0, 0x10, %o0
20147a0: 80 a2 20 00 cmp %o0, 0
20147a4: 02 80 00 e3 be 2014b30 <fat_init_volume_info+0x69c>
20147a8: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
20147ac: 91 32 20 10 srl %o0, 0x10, %o0
20147b0: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
20147b4: 90 22 00 1a sub %o0, %i2, %o0
20147b8: 7f ff b7 af call 2002674 <.udiv>
20147bc: 92 10 00 1c mov %i4, %o1
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
20147c0: 80 a2 2f f4 cmp %o0, 0xff4
20147c4: 18 80 00 7d bgu 20149b8 <fat_init_volume_info+0x524>
20147c8: d0 26 20 38 st %o0, [ %i0 + 0x38 ]
{
vol->type = FAT_FAT12;
20147cc: 84 10 20 01 mov 1, %g2
20147d0: c4 2e 20 0e stb %g2, [ %i0 + 0xe ]
vol->mask = FAT_FAT12_MASK;
20147d4: 84 10 2f ff mov 0xfff, %g2
20147d8: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT12_EOC;
20147dc: 84 10 2f f8 mov 0xff8, %g2
20147e0: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = FAT_UNDEFINED_VALUE;
20147e4: 84 10 3f ff mov -1, %g2
}
}
}
else
{
vol->rdir_cl = 0;
20147e8: c0 26 20 3c clr [ %i0 + 0x3c ]
vol->mirror = 0;
20147ec: c0 2e 20 54 clrb [ %i0 + 0x54 ]
vol->afat = 0;
20147f0: c0 2e 20 5c clrb [ %i0 + 0x5c ]
vol->free_cls = FAT_UNDEFINED_VALUE;
20147f4: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
vol->next_cl = FAT_UNDEFINED_VALUE;
20147f8: c4 26 20 4c st %g2, [ %i0 + 0x4c ]
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
20147fc: 7f ff fd 73 call 2013dc8 <fat_buf_release>
2014800: 90 10 00 18 mov %i0, %o0
vol->next_cl = FAT_UNDEFINED_VALUE;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
2014804: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
2014808: 7f ff b7 61 call 200258c <.umul>
201480c: d0 0e 20 5c ldub [ %i0 + 0x5c ], %o0
2014810: c4 16 20 18 lduh [ %i0 + 0x18 ], %g2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
2014814: 92 10 20 0c mov 0xc, %o1
vol->next_cl = FAT_UNDEFINED_VALUE;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
2014818: 84 02 00 02 add %o0, %g2, %g2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
201481c: 90 10 20 02 mov 2, %o0
2014820: 7f ff c2 3e call 2005118 <calloc>
2014824: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
if ( fs_info->vhash == NULL )
2014828: 80 a2 20 00 cmp %o0, 0
201482c: 02 80 01 03 be 2014c38 <fat_init_volume_info+0x7a4> <== NEVER TAKEN
2014830: d0 26 20 6c st %o0, [ %i0 + 0x6c ]
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 );
2014834: 88 02 20 04 add %o0, 4, %g4
2014838: 84 02 20 0c add %o0, 0xc, %g2
201483c: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
2014840: c8 22 00 00 st %g4, [ %o0 ]
head->previous = NULL;
2014844: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
2014848: 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;
201484c: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
2014850: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
2014854: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
2014858: 92 10 20 0c mov 0xc, %o1
201485c: 7f ff c2 2f call 2005118 <calloc>
2014860: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
2014864: 80 a2 20 00 cmp %o0, 0
2014868: 02 80 01 0c be 2014c98 <fat_init_volume_info+0x804> <== NEVER TAKEN
201486c: d0 26 20 70 st %o0, [ %i0 + 0x70 ]
}
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;
2014870: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
2014874: f8 06 20 30 ld [ %i0 + 0x30 ], %i4
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 );
2014878: 86 02 20 0c add %o0, 0xc, %g3
head->next = tail;
head->previous = NULL;
201487c: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
2014880: 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;
2014884: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
2014888: c6 22 20 14 st %g3, [ %o0 + 0x14 ]
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 );
201488c: 88 02 20 10 add %o0, 0x10, %g4
2014890: ba 02 20 04 add %o0, 4, %i5
head->next = tail;
2014894: c8 22 20 0c st %g4, [ %o0 + 0xc ]
2014898: fa 22 00 00 st %i5, [ %o0 ]
201489c: 85 2f 00 02 sll %i4, %g2, %g2
20148a0: 85 28 a0 04 sll %g2, 4, %g2
20148a4: c4 26 20 80 st %g2, [ %i0 + 0x80 ]
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;
20148a8: 84 10 21 00 mov 0x100, %g2
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
20148ac: c0 26 20 78 clr [ %i0 + 0x78 ]
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;
20148b0: c4 26 20 7c st %g2, [ %i0 + 0x7c ]
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));
20148b4: 90 10 21 00 mov 0x100, %o0
20148b8: 7f ff c2 18 call 2005118 <calloc>
20148bc: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
20148c0: 80 a2 20 00 cmp %o0, 0
20148c4: 02 80 00 d0 be 2014c04 <fat_init_volume_info+0x770> <== NEVER TAKEN
20148c8: d0 26 20 74 st %o0, [ %i0 + 0x74 ]
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
20148cc: d0 16 00 00 lduh [ %i0 ], %o0
20148d0: 7f ff c2 12 call 2005118 <calloc>
20148d4: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
20148d8: 80 a2 20 00 cmp %o0, 0
20148dc: 02 80 00 e7 be 2014c78 <fat_init_volume_info+0x7e4> <== NEVER TAKEN
20148e0: d0 26 20 90 st %o0, [ %i0 + 0x90 ]
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
20148e4: c4 0e 20 04 ldub [ %i0 + 4 ], %g2
20148e8: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
20148ec: 84 00 bf ff add %g2, -1, %g2
/*
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
20148f0: 80 88 80 03 btst %g2, %g3
20148f4: 12 80 00 17 bne 2014950 <fat_init_volume_info+0x4bc> <== NEVER TAKEN
20148f8: 01 00 00 00 nop
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
20148fc: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3
2014900: 80 a0 e0 04 cmp %g3, 4
2014904: 22 80 00 07 be,a 2014920 <fat_init_volume_info+0x48c>
2014908: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
201490c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
2014910: 80 88 80 03 btst %g2, %g3
2014914: 12 80 00 0f bne 2014950 <fat_init_volume_info+0x4bc> <== NEVER TAKEN
2014918: 01 00 00 00 nop
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
201491c: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
2014920: d2 16 20 06 lduh [ %i0 + 6 ], %o1
2014924: 7f ff f6 83 call 2012330 <rtems_bdbuf_set_block_size>
2014928: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
201492c: 80 a2 20 00 cmp %o0, 0
2014930: 12 80 00 08 bne 2014950 <fat_init_volume_info+0x4bc> <== NEVER TAKEN
2014934: 01 00 00 00 nop
{
vol->bytes_per_block = vol->bpc;
2014938: c8 16 20 06 lduh [ %i0 + 6 ], %g4
vol->bytes_per_block_log2 = vol->bpc_log2;
201493c: c6 0e 20 08 ldub [ %i0 + 8 ], %g3
vol->sectors_per_block = vol->spc;
2014940: c4 0e 20 04 ldub [ %i0 + 4 ], %g2
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
if (sc == RTEMS_SUCCESSFUL)
{
vol->bytes_per_block = vol->bpc;
2014944: c8 36 20 0a sth %g4, [ %i0 + 0xa ]
vol->bytes_per_block_log2 = vol->bpc_log2;
2014948: c6 2e 20 0c stb %g3, [ %i0 + 0xc ]
vol->sectors_per_block = vol->spc;
201494c: c4 2e 20 09 stb %g2, [ %i0 + 9 ]
}
}
return RC_OK;
2014950: 81 c7 e0 08 ret
2014954: 91 e8 20 00 restore %g0, 0, %o0
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
if ( (vol->bps != 512) &&
2014958: 80 a0 a2 00 cmp %g2, 0x200
201495c: 22 bf ff 26 be,a 20145f4 <fat_init_volume_info+0x160> <== ALWAYS TAKEN
2014960: 85 32 60 19 srl %o1, 0x19, %g2
(vol->bps != 1024) &&
2014964: 80 a0 a8 00 cmp %g2, 0x800 <== NOT EXECUTED
2014968: 22 bf ff 26 be,a 2014600 <fat_init_volume_info+0x16c> <== NOT EXECUTED
201496c: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
(vol->bps != 2048) &&
2014970: 09 00 00 04 sethi %hi(0x1000), %g4 <== NOT EXECUTED
2014974: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
2014978: 12 80 00 82 bne 2014b80 <fat_init_volume_info+0x6ec> <== NOT EXECUTED
201497c: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
2014980: 10 bf ff 23 b 201460c <fat_init_volume_info+0x178> <== NOT EXECUTED
2014984: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
2014988: c4 0f bf 96 ldub [ %fp + -106 ], %g2
201498c: d0 0f bf 97 ldub [ %fp + -105 ], %o0
2014990: c2 0f bf 9f ldub [ %fp + -97 ], %g1
2014994: 85 28 a0 10 sll %g2, 0x10, %g2
2014998: 91 2a 20 08 sll %o0, 8, %o0
201499c: ae 0d e0 ff and %l7, 0xff, %l7
20149a0: 90 12 00 02 or %o0, %g2, %o0
20149a4: 85 28 60 18 sll %g1, 0x18, %g2
20149a8: 90 12 00 17 or %o0, %l7, %o0
20149ac: 90 12 00 02 or %o0, %g2, %o0
20149b0: 10 bf ff 70 b 2014770 <fat_init_volume_info+0x2dc>
20149b4: d0 26 20 1c st %o0, [ %i0 + 0x1c ]
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
20149b8: 05 00 00 3f sethi %hi(0xfc00), %g2
20149bc: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4>
20149c0: 80 a2 00 03 cmp %o0, %g3
20149c4: 08 80 00 67 bleu 2014b60 <fat_init_volume_info+0x6cc>
20149c8: 86 10 a3 ff or %g2, 0x3ff, %g3
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
20149cc: c2 0f bf 87 ldub [ %fp + -121 ], %g1
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
20149d0: f8 0f bf 7f ldub [ %fp + -129 ], %i4
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
20149d4: 84 08 7f 80 and %g1, -128, %g2
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
20149d8: f6 0f bf 90 ldub [ %fp + -112 ], %i3
20149dc: c8 0f bf 7e ldub [ %fp + -130 ], %g4
20149e0: c2 0f bf 77 ldub [ %fp + -137 ], %g1
20149e4: b9 2f 20 08 sll %i4, 8, %i4
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
20149e8: 07 03 ff ff sethi %hi(0xffffc00), %g3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
20149ec: 89 29 20 10 sll %g4, 0x10, %g4
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
20149f0: ba 10 e3 ff or %g3, 0x3ff, %i5
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
20149f4: 88 17 00 04 or %i4, %g4, %g4
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
vol->eoc_val = FAT_FAT32_EOC;
20149f8: 86 10 e3 f8 or %g3, 0x3f8, %g3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
20149fc: 88 11 00 1b or %g4, %i3, %g4
2014a00: b9 28 60 18 sll %g1, 0x18, %i4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
2014a04: b6 10 20 04 mov 4, %i3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
2014a08: 88 11 00 1c or %g4, %i4, %g4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
2014a0c: f6 2e 20 0e stb %i3, [ %i0 + 0xe ]
vol->mask = FAT_FAT32_MASK;
2014a10: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT32_EOC;
2014a14: c6 26 20 14 st %g3, [ %i0 + 0x14 ]
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
2014a18: c8 26 20 3c st %g4, [ %i0 + 0x3c ]
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
2014a1c: 80 88 a0 80 btst 0x80, %g2
2014a20: 02 80 00 6a be 2014bc8 <fat_init_volume_info+0x734> <== ALWAYS TAKEN
2014a24: c4 2e 20 54 stb %g2, [ %i0 + 0x54 ]
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
2014a28: c2 0f bf 87 ldub [ %fp + -121 ], %g1 <== NOT EXECUTED
2014a2c: 84 08 60 0f and %g1, 0xf, %g2 <== NOT EXECUTED
2014a30: c4 2e 20 5c stb %g2, [ %i0 + 0x5c ] <== NOT EXECUTED
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
2014a34: c4 0f bf 91 ldub [ %fp + -111 ], %g2
2014a38: c6 0f bf 92 ldub [ %fp + -110 ], %g3
2014a3c: 85 28 a0 08 sll %g2, 8, %g2
2014a40: 84 10 80 03 or %g2, %g3, %g2
2014a44: c4 36 20 40 sth %g2, [ %i0 + 0x40 ]
if( vol->info_sec == 0 )
2014a48: 85 28 a0 10 sll %g2, 0x10, %g2
2014a4c: 93 30 a0 10 srl %g2, 0x10, %o1
2014a50: 80 a2 60 00 cmp %o1, 0
2014a54: 02 80 00 4b be 2014b80 <fat_init_volume_info+0x6ec> <== NEVER TAKEN
2014a58: 90 10 00 18 mov %i0, %o0
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , 0,
2014a5c: 94 10 20 00 clr %o2
2014a60: 96 10 20 04 mov 4, %o3
2014a64: 7f ff fd 7e call 201405c <_fat_block_read>
2014a68: 98 07 bf a8 add %fp, -88, %o4
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
2014a6c: 80 a2 20 00 cmp %o0, 0
2014a70: 06 80 00 7d bl 2014c64 <fat_init_volume_info+0x7d0> <== NEVER TAKEN
2014a74: c4 0f bf ab ldub [ %fp + -85 ], %g2
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
2014a78: c6 0f bf a9 ldub [ %fp + -87 ], %g3
2014a7c: fa 0f bf aa ldub [ %fp + -86 ], %i5
2014a80: c8 0f bf a8 ldub [ %fp + -88 ], %g4
2014a84: 85 28 a0 18 sll %g2, 0x18, %g2
2014a88: 87 28 e0 08 sll %g3, 8, %g3
2014a8c: bb 2f 60 10 sll %i5, 0x10, %i5
2014a90: 86 10 c0 1d or %g3, %i5, %g3
2014a94: 86 10 c0 04 or %g3, %g4, %g3
2014a98: 86 10 c0 02 or %g3, %g2, %g3
2014a9c: 05 10 58 54 sethi %hi(0x41615000), %g2
2014aa0: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x3f215252>
2014aa4: 80 a0 c0 02 cmp %g3, %g2
2014aa8: 12 80 00 34 bne 2014b78 <fat_init_volume_info+0x6e4> <== NEVER TAKEN
2014aac: 90 10 00 18 mov %i0, %o0
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
2014ab0: d2 16 20 40 lduh [ %i0 + 0x40 ], %o1
2014ab4: 94 10 21 e4 mov 0x1e4, %o2
2014ab8: 96 10 20 0c mov 0xc, %o3
2014abc: 7f ff fd 68 call 201405c <_fat_block_read>
2014ac0: 98 07 bf a8 add %fp, -88, %o4
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
2014ac4: 80 a2 20 00 cmp %o0, 0
2014ac8: 06 80 00 65 bl 2014c5c <fat_init_volume_info+0x7c8> <== NEVER TAKEN
2014acc: c6 0f bf ad ldub [ %fp + -83 ], %g3
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2014ad0: f2 0f bf ae ldub [ %fp + -82 ], %i1
2014ad4: f4 0f bf ac ldub [ %fp + -84 ], %i2
2014ad8: f6 0f bf af ldub [ %fp + -81 ], %i3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2014adc: f8 0f bf b1 ldub [ %fp + -79 ], %i4
2014ae0: c4 0f bf b2 ldub [ %fp + -78 ], %g2
2014ae4: fa 0f bf b0 ldub [ %fp + -80 ], %i5
2014ae8: c8 0f bf b3 ldub [ %fp + -77 ], %g4
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2014aec: 87 28 e0 08 sll %g3, 8, %g3
2014af0: b3 2e 60 10 sll %i1, 0x10, %i1
2014af4: b7 2e e0 18 sll %i3, 0x18, %i3
2014af8: 86 10 c0 19 or %g3, %i1, %g3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2014afc: b9 2f 20 08 sll %i4, 8, %i4
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2014b00: 86 10 c0 1a or %g3, %i2, %g3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2014b04: 85 28 a0 10 sll %g2, 0x10, %g2
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2014b08: 86 10 c0 1b or %g3, %i3, %g3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2014b0c: 84 17 00 02 or %i4, %g2, %g2
2014b10: 89 29 20 18 sll %g4, 0x18, %g4
2014b14: 84 10 80 1d or %g2, %i5, %g2
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
2014b18: c6 26 20 48 st %g3, [ %i0 + 0x48 ]
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2014b1c: 84 10 80 04 or %g2, %g4, %g2
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
2014b20: c6 26 20 44 st %g3, [ %i0 + 0x44 ]
vol->next_cl_in_fs_info =
2014b24: c4 26 20 50 st %g2, [ %i0 + 0x50 ]
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
vol->next_cl = vol->next_cl_in_fs_info;
2014b28: 10 bf ff 35 b 20147fc <fat_init_volume_info+0x368>
2014b2c: c4 26 20 4c st %g2, [ %i0 + 0x4c ]
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
2014b30: c4 0f bf 94 ldub [ %fp + -108 ], %g2
2014b34: d0 0f bf 95 ldub [ %fp + -107 ], %o0
2014b38: 85 28 a0 10 sll %g2, 0x10, %g2
2014b3c: 91 2a 20 08 sll %o0, 8, %o0
2014b40: c2 0f bf 93 ldub [ %fp + -109 ], %g1
2014b44: 90 12 00 02 or %o0, %g2, %o0
2014b48: c4 0f bf 8f ldub [ %fp + -113 ], %g2
2014b4c: 90 12 00 01 or %o0, %g1, %o0
2014b50: ad 28 a0 18 sll %g2, 0x18, %l6
2014b54: 90 12 00 16 or %o0, %l6, %o0
2014b58: 10 bf ff 17 b 20147b4 <fat_init_volume_info+0x320>
2014b5c: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
2014b60: 88 10 20 02 mov 2, %g4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
2014b64: 84 10 a3 f8 or %g2, 0x3f8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
2014b68: c8 2e 20 0e stb %g4, [ %i0 + 0xe ]
vol->mask = FAT_FAT16_MASK;
2014b6c: c6 26 20 10 st %g3, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT16_EOC;
2014b70: 10 bf ff 1d b 20147e4 <fat_init_volume_info+0x350>
2014b74: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
2014b78: 7f ff fc 94 call 2013dc8 <fat_buf_release> <== NOT EXECUTED
2014b7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(fs_info);
close(vol->fd);
2014b80: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
2014b84: 7f ff c1 7a call 200516c <close> <== NOT EXECUTED
2014b88: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
2014b8c: 40 00 21 50 call 201d0cc <__errno> <== NOT EXECUTED
2014b90: 01 00 00 00 nop <== NOT EXECUTED
2014b94: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2014b98: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014b9c: 81 c7 e0 08 ret <== NOT EXECUTED
2014ba0: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = fstat(vol->fd, &stat_buf);
if (rc != 0)
{
close(vol->fd);
2014ba4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
2014ba8: 7f ff c1 71 call 200516c <close> <== NOT EXECUTED
2014bac: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
2014bb0: 40 00 21 47 call 201d0cc <__errno> <== NOT EXECUTED
2014bb4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2014bb8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
2014bbc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014bc0: 81 c7 e0 08 ret <== NOT EXECUTED
2014bc4: 81 e8 00 00 restore <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
2014bc8: 10 bf ff 9b b 2014a34 <fat_init_volume_info+0x5a0>
2014bcc: c0 2e 20 5c clrb [ %i0 + 0x5c ]
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
vol->bytes_per_block_log2 = vol->sec_log2;
vol->sectors_per_block = 1;
2014bd0: 10 bf fe a3 b 201465c <fat_init_volume_info+0x1c8> <== NOT EXECUTED
2014bd4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
2014bd8: 10 bf fe b4 b 20146a8 <fat_init_volume_info+0x214>
2014bdc: 86 10 20 00 clr %g3
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
sc = rtems_bdbuf_release( block);
if (sc != RTEMS_SUCCESSFUL)
{
close(vol->fd);
2014be0: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
2014be4: 7f ff c1 62 call 200516c <close> <== NOT EXECUTED
2014be8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
2014bec: 40 00 21 38 call 201d0cc <__errno> <== NOT EXECUTED
2014bf0: 01 00 00 00 nop <== NOT EXECUTED
2014bf4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2014bf8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014bfc: 81 c7 e0 08 ret <== NOT EXECUTED
2014c00: 81 e8 00 00 restore <== 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);
2014c04: 7f ff c1 5a call 200516c <close> <== NOT EXECUTED
2014c08: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2014c0c: 7f ff c2 14 call 200545c <free> <== NOT EXECUTED
2014c10: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2014c14: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 <== NOT EXECUTED
if (fs_info->sec_buf == NULL)
{
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
2014c18: 7f ff c2 11 call 200545c <free> <== NOT EXECUTED
2014c1c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
2014c20: 40 00 21 2b call 201d0cc <__errno> <== NOT EXECUTED
2014c24: 01 00 00 00 nop <== NOT EXECUTED
2014c28: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2014c2c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014c30: 81 c7 e0 08 ret <== NOT EXECUTED
2014c34: 81 e8 00 00 restore <== 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);
2014c38: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
2014c3c: 7f ff c1 4c call 200516c <close> <== NOT EXECUTED
2014c40: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
2014c44: 40 00 21 22 call 201d0cc <__errno> <== NOT EXECUTED
2014c48: 01 00 00 00 nop <== NOT EXECUTED
2014c4c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2014c50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014c54: 81 c7 e0 08 ret <== NOT EXECUTED
2014c58: 81 e8 00 00 restore <== NOT EXECUTED
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
2014c5c: 7f ff fc 5b call 2013dc8 <fat_buf_release> <== NOT EXECUTED
2014c60: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(fs_info);
close(vol->fd);
2014c64: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
2014c68: 7f ff c1 41 call 200516c <close> <== NOT EXECUTED
2014c6c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2014c70: 81 c7 e0 08 ret <== NOT EXECUTED
2014c74: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
close(vol->fd);
2014c78: 7f ff c1 3d call 200516c <close> <== NOT EXECUTED
2014c7c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2014c80: 7f ff c1 f7 call 200545c <free> <== NOT EXECUTED
2014c84: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2014c88: 7f ff c1 f5 call 200545c <free> <== NOT EXECUTED
2014c8c: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
2014c90: 10 bf ff e2 b 2014c18 <fat_init_volume_info+0x784> <== NOT EXECUTED
2014c94: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== 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);
2014c98: 7f ff c1 35 call 200516c <close> <== NOT EXECUTED
2014c9c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2014ca0: 10 bf ff de b 2014c18 <fat_init_volume_info+0x784> <== NOT EXECUTED
2014ca4: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
0201b3a8 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
201b3a8: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
201b3ac: e6 06 20 38 ld [ %i0 + 0x38 ], %l3
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
201b3b0: c0 27 bf fc clr [ %fp + -4 ]
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
201b3b4: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
201b3b8: 80 a6 a0 00 cmp %i2, 0
201b3bc: 02 80 00 49 be 201b4e0 <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
201b3c0: a4 10 20 00 clr %l2
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
201b3c4: e0 06 20 4c ld [ %i0 + 0x4c ], %l0
201b3c8: 80 a4 3f ff cmp %l0, -1
201b3cc: 22 80 00 02 be,a 201b3d4 <fat_scan_fat_for_free_clusters+0x2c>
201b3d0: a0 10 20 02 mov 2, %l0
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
201b3d4: a6 04 e0 02 add %l3, 2, %l3
/*
* 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)
201b3d8: 80 a4 e0 02 cmp %l3, 2
201b3dc: 08 80 00 4e bleu 201b514 <fat_scan_fat_for_free_clusters+0x16c><== NEVER TAKEN
201b3e0: a2 10 20 02 mov 2, %l1
201b3e4: 10 80 00 1a b 201b44c <fat_scan_fat_for_free_clusters+0xa4>
201b3e8: a8 10 20 00 clr %l4
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
201b3ec: 90 10 00 18 mov %i0, %o0
201b3f0: 92 10 00 10 mov %l0, %o1
201b3f4: 7f ff ff 03 call 201b000 <fat_set_fat_cluster>
201b3f8: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
201b3fc: 80 a2 20 00 cmp %o0, 0
201b400: 32 80 00 38 bne,a 201b4e0 <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
201b404: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
if ( rc != RC_OK )
goto cleanup;
}
if (zero_fill)
201b408: 80 a7 60 00 cmp %i5, 0
201b40c: 32 80 00 37 bne,a 201b4e8 <fat_scan_fat_for_free_clusters+0x140>
201b410: d6 16 20 06 lduh [ %i0 + 6 ], %o3
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
201b414: c2 06 c0 00 ld [ %i3 ], %g1
201b418: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
201b41c: 80 a6 80 01 cmp %i2, %g1
201b420: 02 80 00 53 be 201b56c <fat_scan_fat_for_free_clusters+0x1c4>
201b424: c2 26 c0 00 st %g1, [ %i3 ]
201b428: a8 10 00 10 mov %l0, %l4
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
201b42c: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
201b430: 80 a4 c0 10 cmp %l3, %l0
201b434: 18 80 00 03 bgu 201b440 <fat_scan_fat_for_free_clusters+0x98><== ALWAYS TAKEN
201b438: a2 04 60 01 inc %l1
cl4find = 2;
201b43c: 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)
201b440: 80 a4 c0 11 cmp %l3, %l1
201b444: 22 80 00 36 be,a 201b51c <fat_scan_fat_for_free_clusters+0x174><== NEVER TAKEN
201b448: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
201b44c: 90 10 00 18 mov %i0, %o0
201b450: 92 10 00 10 mov %l0, %o1
201b454: 7f ff fe 67 call 201adf0 <fat_get_fat_cluster>
201b458: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
201b45c: a4 92 20 00 orcc %o0, 0, %l2
201b460: 12 80 00 3b bne 201b54c <fat_scan_fat_for_free_clusters+0x1a4><== NEVER TAKEN
201b464: c2 07 bf fc ld [ %fp + -4 ], %g1
if (*cls_added != 0)
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
201b468: 80 a0 60 00 cmp %g1, 0
201b46c: 32 bf ff f1 bne,a 201b430 <fat_scan_fat_for_free_clusters+0x88>
201b470: 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)
201b474: c2 06 c0 00 ld [ %i3 ], %g1
201b478: 80 a0 60 00 cmp %g1, 0
201b47c: 22 bf ff dc be,a 201b3ec <fat_scan_fat_for_free_clusters+0x44>
201b480: e0 26 40 00 st %l0, [ %i1 ]
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
201b484: 90 10 00 18 mov %i0, %o0
201b488: 92 10 00 10 mov %l0, %o1
201b48c: 7f ff fe dd call 201b000 <fat_set_fat_cluster>
201b490: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
201b494: 82 92 20 00 orcc %o0, 0, %g1
201b498: 12 80 00 40 bne 201b598 <fat_scan_fat_for_free_clusters+0x1f0><== NEVER TAKEN
201b49c: 92 10 00 14 mov %l4, %o1
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
201b4a0: 90 10 00 18 mov %i0, %o0
201b4a4: 7f ff fe d7 call 201b000 <fat_set_fat_cluster>
201b4a8: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
201b4ac: a8 92 20 00 orcc %o0, 0, %l4
201b4b0: 02 bf ff d7 be 201b40c <fat_scan_fat_for_free_clusters+0x64><== ALWAYS TAKEN
201b4b4: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
201b4b8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201b4bc: 7f ff ff 83 call 201b2c8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
201b4c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
201b4c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b4c8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201b4cc: 7f ff fe cd call 201b000 <fat_set_fat_cluster> <== NOT EXECUTED
201b4d0: 94 10 20 00 clr %o2 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
201b4d4: a4 10 00 14 mov %l4, %l2 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
201b4d8: 7f ff e2 3c call 2013dc8 <fat_buf_release> <== NOT EXECUTED
201b4dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
201b4e0: 81 c7 e0 08 ret
201b4e4: 91 e8 00 12 restore %g0, %l2, %o0
goto cleanup;
}
if (zero_fill)
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
201b4e8: 90 10 00 18 mov %i0, %o0
201b4ec: 92 10 00 10 mov %l0, %o1
201b4f0: 94 10 20 00 clr %o2
201b4f4: 7f ff e3 26 call 201418c <fat_cluster_set>
201b4f8: 98 10 20 00 clr %o4
if (fs_info->vol.bpc != bytes_written)
201b4fc: c2 16 20 06 lduh [ %i0 + 6 ], %g1
201b500: 80 a0 40 08 cmp %g1, %o0
201b504: 22 bf ff c5 be,a 201b418 <fat_scan_fat_for_free_clusters+0x70><== ALWAYS TAKEN
201b508: c2 06 c0 00 ld [ %i3 ], %g1
{
rc = -1;
201b50c: 10 bf ff eb b 201b4b8 <fat_scan_fat_for_free_clusters+0x110><== NOT EXECUTED
201b510: a8 10 3f ff mov -1, %l4 <== 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)
201b514: a8 10 20 00 clr %l4 <== NOT EXECUTED
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
201b518: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
201b51c: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
201b520: 02 80 00 05 be 201b534 <fat_scan_fat_for_free_clusters+0x18c><== NOT EXECUTED
201b524: e8 26 20 4c st %l4, [ %i0 + 0x4c ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
201b528: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
201b52c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
201b530: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
201b534: e8 27 00 00 st %l4, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
201b538: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b53c: 7f ff e2 23 call 2013dc8 <fat_buf_release> <== NOT EXECUTED
201b540: a4 10 20 00 clr %l2 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
201b544: 81 c7 e0 08 ret <== NOT EXECUTED
201b548: 91 e8 00 12 restore %g0, %l2, %o0 <== NOT EXECUTED
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
if ( rc != RC_OK )
{
if (*cls_added != 0)
201b54c: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
201b550: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201b554: 02 bf ff e3 be 201b4e0 <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
201b558: 01 00 00 00 nop <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
201b55c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201b560: 7f ff ff 5a call 201b2c8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
201b564: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b568: 30 bf ff de b,a 201b4e0 <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
201b56c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
201b570: 80 a0 7f ff cmp %g1, -1
201b574: 02 80 00 05 be 201b588 <fat_scan_fat_for_free_clusters+0x1e0><== ALWAYS TAKEN
201b578: e0 26 20 4c st %l0, [ %i0 + 0x4c ]
fs_info->vol.free_cls -= (*cls_added);
201b57c: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
201b580: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
201b584: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
201b588: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
201b58c: 7f ff e2 0f call 2013dc8 <fat_buf_release>
201b590: 90 10 00 18 mov %i0, %o0
201b594: 30 bf ff d3 b,a 201b4e0 <fat_scan_fat_for_free_clusters+0x138>
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
201b598: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201b59c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b5a0: 7f ff ff 4a call 201b2c8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
201b5a4: a4 10 00 01 mov %g1, %l2 <== NOT EXECUTED
201b5a8: 30 bf ff ce b,a 201b4e0 <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
020140dc <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
20140dc: 9d e3 bf 98 save %sp, -104, %sp
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
20140e0: 80 a6 e0 00 cmp %i3, 0
20140e4: 02 80 00 28 be 2014184 <fat_sector_write+0xa8> <== NEVER TAKEN
20140e8: a0 10 20 00 clr %l0
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
20140ec: 10 80 00 12 b 2014134 <fat_sector_write+0x58>
20140f0: a2 10 20 01 mov 1, %l1
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
20140f4: 96 07 bf fc add %fp, -4, %o3
20140f8: 7f ff ff ab call 2013fa4 <fat_buf_access>
20140fc: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
2014100: 92 07 00 10 add %i4, %l0, %o1
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
2014104: 80 a2 20 00 cmp %o0, 0
2014108: 12 80 00 1e bne 2014180 <fat_sector_write+0xa4> <== NEVER TAKEN
201410c: 94 10 00 1d mov %i5, %o2
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
2014110: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
2014114: a0 07 40 10 add %i5, %l0, %l0
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
2014118: 40 00 26 ac call 201dbc8 <memcpy>
201411c: 90 02 00 1a add %o0, %i2, %o0
2014120: e2 2e 20 88 stb %l1, [ %i0 + 0x88 ]
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
sec_num++;
2014124: b2 06 60 01 inc %i1
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
2014128: b6 a6 c0 1d subcc %i3, %i5, %i3
201412c: 02 80 00 16 be 2014184 <fat_sector_write+0xa8> <== ALWAYS TAKEN
2014130: b4 10 20 00 clr %i2
{
c = MIN(count, (fs_info->vol.bps - ofs));
2014134: fa 16 00 00 lduh [ %i0 ], %i5
2014138: ba 27 40 1a sub %i5, %i2, %i5
201413c: 80 a7 40 1b cmp %i5, %i3
2014140: 08 80 00 03 bleu 201414c <fat_sector_write+0x70>
2014144: 92 10 00 19 mov %i1, %o1
2014148: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bytes_per_block)
201414c: c2 16 20 0a lduh [ %i0 + 0xa ], %g1
2014150: 80 a0 40 1d cmp %g1, %i5
2014154: 12 bf ff e8 bne 20140f4 <fat_sector_write+0x18> <== ALWAYS TAKEN
2014158: 94 10 20 01 mov 1, %o2
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
201415c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2014160: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED
2014164: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2014168: 7f ff ff 8f call 2013fa4 <fat_buf_access> <== NOT EXECUTED
201416c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
2014170: 92 07 00 10 add %i4, %l0, %o1 <== NOT EXECUTED
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
2014174: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014178: 02 bf ff e6 be 2014110 <fat_sector_write+0x34> <== NOT EXECUTED
201417c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return -1;
2014180: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
2014184: 81 c7 e0 08 ret
2014188: 91 e8 00 10 restore %g0, %l0, %o0
0201b000 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
201b000: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
uint8_t *sec_buf = NULL;
201b004: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
201b008: 80 a6 60 01 cmp %i1, 1
201b00c: 08 80 00 26 bleu 201b0a4 <fat_set_fat_cluster+0xa4> <== NEVER TAKEN
201b010: ba 10 00 18 mov %i0, %i5
201b014: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
201b018: 82 00 60 01 inc %g1
201b01c: 80 a6 40 01 cmp %i1, %g1
201b020: 18 80 00 21 bgu 201b0a4 <fat_set_fat_cluster+0xa4> <== NEVER TAKEN
201b024: 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) +
201b028: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
201b02c: 80 88 60 01 btst 1, %g1
201b030: 12 80 00 23 bne 201b0bc <fat_set_fat_cluster+0xbc>
201b034: e0 0e 20 02 ldub [ %i0 + 2 ], %l0
201b038: 82 08 60 02 and %g1, 2, %g1
201b03c: 80 88 60 ff btst 0xff, %g1
201b040: 02 80 00 25 be 201b0d4 <fat_set_fat_cluster+0xd4>
201b044: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
201b048: b9 2e 60 01 sll %i1, 1, %i4
201b04c: a1 37 00 10 srl %i4, %l0, %l0
201b050: a0 04 00 01 add %l0, %g1, %l0
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
201b054: e2 17 40 00 lduh [ %i5 ], %l1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
201b058: 90 10 00 1d mov %i5, %o0
201b05c: 92 10 00 10 mov %l0, %o1
201b060: 94 10 20 01 mov 1, %o2
201b064: 7f ff e3 d0 call 2013fa4 <fat_buf_access>
201b068: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
201b06c: b0 92 20 00 orcc %o0, 0, %i0
201b070: 12 80 00 11 bne 201b0b4 <fat_set_fat_cluster+0xb4> <== NEVER TAKEN
201b074: a3 2c 60 10 sll %l1, 0x10, %l1
return rc;
switch ( fs_info->vol.type )
201b078: f6 0f 60 0e ldub [ %i5 + 0xe ], %i3
201b07c: 80 a6 e0 02 cmp %i3, 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);
201b080: a3 34 60 10 srl %l1, 0x10, %l1
201b084: a2 04 7f ff add %l1, -1, %l1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
201b088: 02 80 00 17 be 201b0e4 <fat_set_fat_cluster+0xe4>
201b08c: b8 0f 00 11 and %i4, %l1, %i4
201b090: 80 a6 e0 04 cmp %i3, 4
201b094: 02 80 00 3b be 201b180 <fat_set_fat_cluster+0x180>
201b098: 80 a6 e0 01 cmp %i3, 1
201b09c: 02 80 00 1f be 201b118 <fat_set_fat_cluster+0x118> <== ALWAYS TAKEN
201b0a0: 80 8e 60 01 btst 1, %i1
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
201b0a4: 40 00 08 0a call 201d0cc <__errno> <== NOT EXECUTED
201b0a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201b0ac: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201b0b0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
201b0b4: 81 c7 e0 08 ret <== NOT EXECUTED
201b0b8: 81 e8 00 00 restore <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
201b0bc: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
201b0c0: b9 36 60 01 srl %i1, 1, %i4
201b0c4: b8 07 00 19 add %i4, %i1, %i4
201b0c8: a1 37 00 10 srl %i4, %l0, %l0
201b0cc: 10 bf ff e2 b 201b054 <fat_set_fat_cluster+0x54>
201b0d0: a0 04 00 01 add %l0, %g1, %l0
201b0d4: b9 2e 60 02 sll %i1, 2, %i4
201b0d8: a1 37 00 10 srl %i4, %l0, %l0
201b0dc: 10 bf ff de b 201b054 <fat_set_fat_cluster+0x54>
201b0e0: a0 04 00 01 add %l0, %g1, %l0
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
201b0e4: 83 2e a0 10 sll %i2, 0x10, %g1
201b0e8: 83 30 60 18 srl %g1, 0x18, %g1
break;
}
return RC_OK;
}
201b0ec: 05 00 00 3f sethi %hi(0xfc00), %g2
201b0f0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
201b0f4: b4 0e 80 02 and %i2, %g2, %i2
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
201b0f8: b5 2e a0 08 sll %i2, 8, %i2
201b0fc: b4 16 80 01 or %i2, %g1, %i2
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
201b100: c2 07 bf fc ld [ %fp + -4 ], %g1
201b104: f4 30 40 1c sth %i2, [ %g1 + %i4 ]
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
201b108: 82 10 20 01 mov 1, %g1
201b10c: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
201b110: 81 c7 e0 08 ret
201b114: 81 e8 00 00 restore
return rc;
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
201b118: 02 80 00 30 be 201b1d8 <fat_set_fat_cluster+0x1d8>
201b11c: c2 07 bf fc ld [ %fp + -4 ], %g1
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
201b120: 85 2e a0 04 sll %i2, 4, %g2
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
201b124: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
201b128: 86 08 e0 0f and %g3, 0xf, %g3
201b12c: c6 28 40 1c stb %g3, [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
201b130: c2 07 bf fc ld [ %fp + -4 ], %g1
201b134: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
201b138: 84 10 c0 02 or %g3, %g2, %g2
201b13c: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
201b140: c2 17 40 00 lduh [ %i5 ], %g1
201b144: 82 00 7f ff add %g1, -1, %g1
201b148: 80 a0 40 1c cmp %g1, %i4
201b14c: 02 80 00 3a be 201b234 <fat_set_fat_cluster+0x234> <== NEVER TAKEN
201b150: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
201b154: c2 07 bf fc ld [ %fp + -4 ], %g1
201b158: b8 07 20 01 inc %i4
201b15c: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
201b160: c2 07 bf fc ld [ %fp + -4 ], %g1
201b164: b5 2e a0 14 sll %i2, 0x14, %i2
201b168: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
201b16c: b5 36 a0 18 srl %i2, 0x18, %i2
201b170: 84 10 80 1a or %g2, %i2, %g2
201b174: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
201b178: 81 c7 e0 08 ret
201b17c: 81 e8 00 00 restore
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
201b180: c4 07 bf fc ld [ %fp + -4 ], %g2
(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));
201b184: 03 3c 00 00 sethi %hi(0xf0000000), %g1
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
201b188: c6 00 80 1c ld [ %g2 + %i4 ], %g3
(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));
201b18c: 82 2e 80 01 andn %i2, %g1, %g1
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
201b190: 89 30 60 18 srl %g1, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
201b194: b7 30 60 08 srl %g1, 8, %i3
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
201b198: 86 08 e0 f0 and %g3, 0xf0, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201b19c: b5 2e a0 18 sll %i2, 0x18, %i2
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
201b1a0: b6 0e e0 ff and %i3, 0xff, %i3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201b1a4: b4 16 80 04 or %i2, %g4, %i2
201b1a8: b7 2e e0 10 sll %i3, 0x10, %i3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
201b1ac: 89 30 60 10 srl %g1, 0x10, %g4
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201b1b0: 82 16 80 1b or %i2, %i3, %g1
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
201b1b4: 88 09 20 ff and %g4, 0xff, %g4
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201b1b8: 89 29 20 08 sll %g4, 8, %g4
201b1bc: 82 10 40 04 or %g1, %g4, %g1
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
201b1c0: 82 10 40 03 or %g1, %g3, %g1
201b1c4: c2 20 80 1c st %g1, [ %g2 + %i4 ]
201b1c8: 82 10 20 01 mov 1, %g1
201b1cc: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
201b1d0: 81 c7 e0 08 ret
201b1d4: 81 e8 00 00 restore
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
201b1d8: b4 0e af ff and %i2, 0xfff, %i2
*(sec_buf + ofs) &= 0x00;
201b1dc: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
201b1e0: c2 07 bf fc ld [ %fp + -4 ], %g1
201b1e4: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
201b1e8: 84 10 80 1a or %g2, %i2, %g2
201b1ec: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
201b1f0: c2 17 40 00 lduh [ %i5 ], %g1
201b1f4: 82 00 7f ff add %g1, -1, %g1
201b1f8: 80 a0 40 1c cmp %g1, %i4
201b1fc: 02 80 00 20 be 201b27c <fat_set_fat_cluster+0x27c> <== NEVER TAKEN
201b200: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
201b204: c2 07 bf fc ld [ %fp + -4 ], %g1
201b208: b8 07 20 01 inc %i4
201b20c: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
201b210: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
201b214: 84 08 bf f0 and %g2, -16, %g2
201b218: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
201b21c: c2 07 bf fc ld [ %fp + -4 ], %g1
201b220: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
201b224: b4 10 80 1a or %g2, %i2, %i2
201b228: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
201b22c: 81 c7 e0 08 ret
201b230: 81 e8 00 00 restore
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
201b234: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201b238: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
201b23c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201b240: 7f ff e3 59 call 2013fa4 <fat_buf_access> <== NOT EXECUTED
201b244: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
201b248: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201b24c: 12 bf ff 9a bne 201b0b4 <fat_set_fat_cluster+0xb4> <== NOT EXECUTED
201b250: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
201b254: 87 2e a0 14 sll %i2, 0x14, %g3 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
return rc;
*sec_buf &= 0x00;
201b258: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
201b25c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
201b260: 87 30 e0 18 srl %g3, 0x18, %g3 <== NOT EXECUTED
201b264: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
201b268: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
201b26c: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
201b270: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
201b274: 81 c7 e0 08 ret <== NOT EXECUTED
201b278: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
201b27c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201b280: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
201b284: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201b288: 7f ff e3 47 call 2013fa4 <fat_buf_access> <== NOT EXECUTED
201b28c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
201b290: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201b294: 12 bf ff 88 bne 201b0b4 <fat_set_fat_cluster+0xb4> <== NOT EXECUTED
201b298: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
201b29c: b5 36 a0 08 srl %i2, 8, %i2 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
return rc;
*sec_buf &= 0xF0;
201b2a0: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
201b2a4: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
201b2a8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
201b2ac: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
201b2b0: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
201b2b4: 84 16 80 02 or %i2, %g2, %g2 <== NOT EXECUTED
201b2b8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
201b2bc: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
201b2c0: 81 c7 e0 08 ret <== NOT EXECUTED
201b2c4: 81 e8 00 00 restore <== NOT EXECUTED
02014dd0 <fat_shutdown_drive>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(fat_fs_info_t *fs_info)
{
2014dd0: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
2014dd4: 90 10 00 18 mov %i0, %o0
2014dd8: 7f ff ff b4 call 2014ca8 <fat_sync>
2014ddc: b8 10 00 18 mov %i0, %i4
if ( rc != RC_OK )
2014de0: b0 92 20 00 orcc %o0, 0, %i0
2014de4: 32 80 00 35 bne,a 2014eb8 <fat_shutdown_drive+0xe8> <== NEVER TAKEN
2014de8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
2014dec: 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;
2014df0: fa 07 20 6c ld [ %i4 + 0x6c ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
2014df4: 10 80 00 04 b 2014e04 <fat_shutdown_drive+0x34>
2014df8: ba 07 40 1b add %i5, %i3, %i5
free(node);
2014dfc: 7f ff c1 98 call 200545c <free> <== NOT EXECUTED
2014e00: 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 );
2014e04: 7f ff d6 c9 call 200a928 <_Chain_Get>
2014e08: 90 10 00 1d mov %i5, %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 )
2014e0c: 80 a2 20 00 cmp %o0, 0
2014e10: 12 bf ff fb bne 2014dfc <fat_shutdown_drive+0x2c> <== NEVER TAKEN
2014e14: 01 00 00 00 nop
2014e18: b6 06 e0 0c add %i3, 0xc, %i3
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
2014e1c: 80 a6 e0 18 cmp %i3, 0x18
2014e20: 32 bf ff f5 bne,a 2014df4 <fat_shutdown_drive+0x24>
2014e24: fa 07 20 6c ld [ %i4 + 0x6c ], %i5
2014e28: 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;
2014e2c: fa 07 20 70 ld [ %i4 + 0x70 ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
2014e30: 10 80 00 04 b 2014e40 <fat_shutdown_drive+0x70>
2014e34: ba 07 40 1b add %i5, %i3, %i5
free(node);
2014e38: 7f ff c1 89 call 200545c <free> <== NOT EXECUTED
2014e3c: 01 00 00 00 nop <== NOT EXECUTED
2014e40: 7f ff d6 ba call 200a928 <_Chain_Get>
2014e44: 90 10 00 1d mov %i5, %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 )
2014e48: 80 a2 20 00 cmp %o0, 0
2014e4c: 12 bf ff fb bne 2014e38 <fat_shutdown_drive+0x68> <== NEVER TAKEN
2014e50: 01 00 00 00 nop
2014e54: 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++)
2014e58: 80 a6 e0 18 cmp %i3, 0x18
2014e5c: 32 bf ff f5 bne,a 2014e30 <fat_shutdown_drive+0x60>
2014e60: fa 07 20 70 ld [ %i4 + 0x70 ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
2014e64: 7f ff c1 7e call 200545c <free>
2014e68: d0 07 20 6c ld [ %i4 + 0x6c ], %o0
free(fs_info->rhash);
2014e6c: 7f ff c1 7c call 200545c <free>
2014e70: d0 07 20 70 ld [ %i4 + 0x70 ], %o0
free(fs_info->uino);
2014e74: 7f ff c1 7a call 200545c <free>
2014e78: d0 07 20 74 ld [ %i4 + 0x74 ], %o0
free(fs_info->sec_buf);
2014e7c: 7f ff c1 78 call 200545c <free>
2014e80: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
close(fs_info->vol.fd);
2014e84: 7f ff c0 ba call 200516c <close>
2014e88: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
if (rc)
2014e8c: 80 a6 20 00 cmp %i0, 0
2014e90: 12 80 00 04 bne 2014ea0 <fat_shutdown_drive+0xd0> <== NEVER TAKEN
2014e94: 01 00 00 00 nop
errno = EIO;
return rc;
}
2014e98: 81 c7 e0 08 ret
2014e9c: 81 e8 00 00 restore
free(fs_info->uino);
free(fs_info->sec_buf);
close(fs_info->vol.fd);
if (rc)
errno = EIO;
2014ea0: 40 00 20 8b call 201d0cc <__errno> <== NOT EXECUTED
2014ea4: 01 00 00 00 nop <== NOT EXECUTED
2014ea8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2014eac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
2014eb0: 81 c7 e0 08 ret <== NOT EXECUTED
2014eb4: 81 e8 00 00 restore <== NOT EXECUTED
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
2014eb8: 10 bf ff ce b 2014df0 <fat_shutdown_drive+0x20> <== NOT EXECUTED
2014ebc: b6 10 20 00 clr %i3 <== NOT EXECUTED
02014ca8 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
2014ca8: 9d e3 bf 98 save %sp, -104, %sp
static int
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)
{
ssize_t ret1 = 0, ret2 = 0;
if (fs_info->vol.type == FAT_FAT32)
2014cac: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
2014cb0: 80 a0 60 04 cmp %g1, 4
2014cb4: 02 80 00 0c be 2014ce4 <fat_sync+0x3c>
2014cb8: ba 10 00 18 mov %i0, %i5
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
2014cbc: b0 10 20 00 clr %i0
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
fat_buf_release(fs_info);
2014cc0: 7f ff fc 42 call 2013dc8 <fat_buf_release>
2014cc4: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
2014cc8: 7f ff f5 05 call 20120dc <rtems_bdbuf_syncdev>
2014ccc: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
2014cd0: 80 a2 20 00 cmp %o0, 0
2014cd4: 12 80 00 3d bne 2014dc8 <fat_sync+0x120> <== NEVER TAKEN
2014cd8: 01 00 00 00 nop
rc = -1;
return rc;
}
2014cdc: 81 c7 e0 08 ret
2014ce0: 81 e8 00 00 restore
{
ssize_t ret1 = 0, ret2 = 0;
if (fs_info->vol.type == FAT_FAT32)
{
uint32_t free_count = fs_info->vol.free_cls;
2014ce4: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
2014ce8: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
ssize_t ret1 = 0, ret2 = 0;
if (fs_info->vol.type == FAT_FAT32)
{
uint32_t free_count = fs_info->vol.free_cls;
uint32_t next_free = fs_info->vol.next_cl;
2014cec: f8 06 20 4c ld [ %i0 + 0x4c ], %i4
if (free_count != fs_info->vol.free_cls_in_fs_info)
2014cf0: 80 a0 40 02 cmp %g1, %g2
2014cf4: 02 80 00 16 be 2014d4c <fat_sync+0xa4> <== ALWAYS TAKEN
2014cf8: b6 10 20 00 clr %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
2014cfc: 85 30 60 18 srl %g1, 0x18, %g2 <== NOT EXECUTED
{
uint32_t le_free_count = CT_LE_L(free_count);
fs_info->vol.free_cls_in_fs_info = free_count;
ret1 = fat_sector_write(fs_info,
2014d00: d2 16 20 40 lduh [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2014d04: 87 28 60 18 sll %g1, 0x18, %g3 <== NOT EXECUTED
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
2014d08: 89 30 60 08 srl %g1, 8, %g4 <== NOT EXECUTED
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2014d0c: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
if (free_count != fs_info->vol.free_cls_in_fs_info)
{
uint32_t le_free_count = CT_LE_L(free_count);
fs_info->vol.free_cls_in_fs_info = free_count;
2014d10: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2014d14: 85 30 60 10 srl %g1, 0x10, %g2 <== NOT EXECUTED
byte2 = (value >> 8) & 0xff;
2014d18: 88 09 20 ff and %g4, 0xff, %g4 <== NOT EXECUTED
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2014d1c: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2014d20: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
2014d24: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
2014d28: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
2014d2c: 82 10 c0 02 or %g3, %g2, %g1 <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
2014d30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
uint32_t free_count = fs_info->vol.free_cls;
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
{
uint32_t le_free_count = CT_LE_L(free_count);
2014d34: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
ret1 = fat_sector_write(fs_info,
2014d38: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
2014d3c: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2014d40: 7f ff fc e7 call 20140dc <fat_sector_write> <== NOT EXECUTED
2014d44: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
2014d48: b7 32 20 1f srl %o0, 0x1f, %i3 <== NOT EXECUTED
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
2014d4c: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
2014d50: 80 a7 00 02 cmp %i4, %g2
2014d54: 02 80 00 16 be 2014dac <fat_sync+0x104> <== NEVER TAKEN
2014d58: 90 10 20 00 clr %o0
2014d5c: 85 2f 20 18 sll %i4, 0x18, %g2
{
uint32_t le_next_free = CT_LE_L(next_free);
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
2014d60: d2 17 60 40 lduh [ %i5 + 0x40 ], %o1
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
2014d64: 83 37 20 18 srl %i4, 0x18, %g1
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
2014d68: 87 37 20 08 srl %i4, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2014d6c: 82 10 80 01 or %g2, %g1, %g1
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
2014d70: 86 08 e0 ff and %g3, 0xff, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2014d74: 85 37 20 10 srl %i4, 0x10, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2014d78: 87 28 e0 10 sll %g3, 0x10, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2014d7c: 84 08 a0 ff and %g2, 0xff, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2014d80: 82 10 40 03 or %g1, %g3, %g1
2014d84: 85 28 a0 08 sll %g2, 8, %g2
2014d88: 82 10 40 02 or %g1, %g2, %g1
if (next_free != fs_info->vol.next_cl_in_fs_info)
{
uint32_t le_next_free = CT_LE_L(next_free);
fs_info->vol.next_cl_in_fs_info = next_free;
2014d8c: f8 27 60 50 st %i4, [ %i5 + 0x50 ]
ret2 = fat_sector_write(fs_info,
2014d90: 90 10 00 1d mov %i5, %o0
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
{
uint32_t le_next_free = CT_LE_L(next_free);
2014d94: c2 27 bf fc st %g1, [ %fp + -4 ]
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
2014d98: 94 10 21 ec mov 0x1ec, %o2
2014d9c: 96 10 20 04 mov 4, %o3
2014da0: 7f ff fc cf call 20140dc <fat_sector_write>
2014da4: 98 07 bf fc add %fp, -4, %o4
2014da8: 91 32 20 1f srl %o0, 0x1f, %o0
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
2014dac: 80 8a 20 ff btst 0xff, %o0
2014db0: 12 80 00 04 bne 2014dc0 <fat_sync+0x118> <== NEVER TAKEN
2014db4: 80 8e e0 ff btst 0xff, %i3
2014db8: 22 bf ff c2 be,a 2014cc0 <fat_sync+0x18> <== ALWAYS TAKEN
2014dbc: b0 10 20 00 clr %i0
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
2014dc0: 10 bf ff c0 b 2014cc0 <fat_sync+0x18> <== NOT EXECUTED
2014dc4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
rc = -1;
2014dc8: 81 c7 e0 08 ret <== NOT EXECUTED
2014dcc: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02037768 <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
2037768: 9d e3 bf 40 save %sp, -192, %sp
st.st_mode = 0;
st.st_uid = 0;
st.st_gid = 0;
rtems_libio_check_fd( fd );
203776c: 03 00 81 8c sethi %hi(0x2063000), %g1
2037770: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 ! 2063030 <rtems_libio_number_iops>
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
2037774: c0 27 bf c4 clr [ %fp + -60 ]
st.st_uid = 0;
2037778: c0 37 bf ca clrh [ %fp + -54 ]
st.st_gid = 0;
rtems_libio_check_fd( fd );
203777c: 80 a6 00 01 cmp %i0, %g1
2037780: 1a 80 00 3d bcc 2037874 <fchdir+0x10c>
2037784: c0 37 bf cc clrh [ %fp + -52 ]
iop = rtems_libio_iop( fd );
2037788: 03 00 81 9c sethi %hi(0x2067000), %g1
203778c: fa 00 61 d4 ld [ %g1 + 0x1d4 ], %i5 ! 20671d4 <rtems_libio_iops>
2037790: 83 2e 20 03 sll %i0, 3, %g1
2037794: b1 2e 20 06 sll %i0, 6, %i0
2037798: b0 26 00 01 sub %i0, %g1, %i0
203779c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open( iop );
20377a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20377a4: 80 88 61 00 btst 0x100, %g1
20377a8: 02 80 00 33 be 2037874 <fchdir+0x10c>
20377ac: 01 00 00 00 nop
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
20377b0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
20377b4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
20377b8: c2 00 40 00 ld [ %g1 ], %g1
20377bc: 9f c0 40 00 call %g1
20377c0: b8 07 60 14 add %i5, 0x14, %i4
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
20377c4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20377c8: 90 10 00 1c mov %i4, %o0
20377cc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
20377d0: 9f c0 40 00 call %g1
20377d4: 92 07 bf b8 add %fp, -72, %o1
if ( rv == 0 ) {
20377d8: b0 92 20 00 orcc %o0, 0, %i0
20377dc: 02 80 00 09 be 2037800 <fchdir+0x98> <== ALWAYS TAKEN
20377e0: d2 07 bf c4 ld [ %fp + -60 ], %o1
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
20377e4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
20377e8: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20377ec: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
20377f0: 9f c0 40 00 call %g1 <== NOT EXECUTED
20377f4: 01 00 00 00 nop <== NOT EXECUTED
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
20377f8: 81 c7 e0 08 ret <== NOT EXECUTED
20377fc: 81 e8 00 00 restore <== NOT EXECUTED
rtems_libio_check_is_open( iop );
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
if ( rv == 0 ) {
bool access_ok = rtems_filesystem_check_access(
2037800: d4 17 bf ca lduh [ %fp + -54 ], %o2
2037804: d6 17 bf cc lduh [ %fp + -52 ], %o3
2037808: 7f ff 5e 31 call 200f0cc <rtems_filesystem_check_access>
203780c: 90 10 20 01 mov 1, %o0
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
2037810: 80 8a 20 ff btst 0xff, %o0
2037814: 02 80 00 0d be 2037848 <fchdir+0xe0>
2037818: 92 10 00 1c mov %i4, %o1
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
203781c: 7f ff 5c da call 200eb84 <rtems_filesystem_location_clone>
2037820: 90 07 bf a0 add %fp, -96, %o0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2037824: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2037828: c2 02 20 0c ld [ %o0 + 0xc ], %g1
203782c: c2 00 60 04 ld [ %g1 + 4 ], %g1
2037830: 9f c0 40 00 call %g1
2037834: 01 00 00 00 nop
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
2037838: 7f ff be 9e call 20272b0 <rtems_filesystem_chdir>
203783c: 90 07 bf a0 add %fp, -96, %o0
2037840: 81 c7 e0 08 ret
2037844: 91 e8 00 08 restore %g0, %o0, %o0
);
if ( access_ok ) {
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
} else {
errno = EACCES;
2037848: 40 00 11 88 call 203be68 <__errno>
203784c: b0 10 3f ff mov -1, %i0
2037850: 82 10 20 0d mov 0xd, %g1
2037854: c2 22 00 00 st %g1, [ %o0 ]
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2037858: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
203785c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2037860: c2 00 60 04 ld [ %g1 + 4 ], %g1
2037864: 9f c0 40 00 call %g1
2037868: 01 00 00 00 nop
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
203786c: 81 c7 e0 08 ret
2037870: 81 e8 00 00 restore
st.st_uid = 0;
st.st_gid = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
2037874: 40 00 11 7d call 203be68 <__errno>
2037878: b0 10 3f ff mov -1, %i0
203787c: 82 10 20 09 mov 9, %g1
2037880: c2 22 00 00 st %g1, [ %o0 ]
2037884: 81 c7 e0 08 ret
2037888: 81 e8 00 00 restore
02027590 <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
2027590: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2027594: 03 00 81 8c sethi %hi(0x2063000), %g1
2027598: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 ! 2063030 <rtems_libio_number_iops>
202759c: 80 a6 00 01 cmp %i0, %g1
20275a0: 1a 80 00 28 bcc 2027640 <fchmod+0xb0>
20275a4: 03 00 81 9c sethi %hi(0x2067000), %g1
iop = rtems_libio_iop( fd );
20275a8: fa 00 61 d4 ld [ %g1 + 0x1d4 ], %i5 ! 20671d4 <rtems_libio_iops>
20275ac: 83 2e 20 03 sll %i0, 3, %g1
20275b0: b1 2e 20 06 sll %i0, 6, %i0
20275b4: b0 26 00 01 sub %i0, %g1, %i0
20275b8: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
20275bc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20275c0: 80 88 61 00 btst 0x100, %g1
20275c4: 02 80 00 1f be 2027640 <fchmod+0xb0>
20275c8: 01 00 00 00 nop
if (iop->pathinfo.mt_entry->writeable) {
20275cc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
20275d0: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
20275d4: 80 a0 60 00 cmp %g1, 0
20275d8: 02 80 00 14 be 2027628 <fchmod+0x98> <== NEVER TAKEN
20275dc: 01 00 00 00 nop
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
20275e0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
20275e4: c2 00 40 00 ld [ %g1 ], %g1
20275e8: 9f c0 40 00 call %g1
20275ec: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
20275f0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
20275f4: 90 07 60 14 add %i5, 0x14, %o0
20275f8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20275fc: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
2027600: 9f c0 40 00 call %g1
2027604: 92 10 00 19 mov %i1, %o1
2027608: b0 10 00 08 mov %o0, %i0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
202760c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2027610: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2027614: c2 00 60 04 ld [ %g1 + 4 ], %g1
2027618: 9f c0 40 00 call %g1
202761c: 01 00 00 00 nop
2027620: 81 c7 e0 08 ret
2027624: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2027628: 40 00 52 10 call 203be68 <__errno> <== NOT EXECUTED
202762c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2027630: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
2027634: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2027638: 81 c7 e0 08 ret <== NOT EXECUTED
202763c: 81 e8 00 00 restore <== NOT EXECUTED
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
2027640: 40 00 52 0a call 203be68 <__errno>
2027644: b0 10 3f ff mov -1, %i0
2027648: 82 10 20 09 mov 9, %g1
202764c: c2 22 00 00 st %g1, [ %o0 ]
2027650: 81 c7 e0 08 ret
2027654: 81 e8 00 00 restore
02027658 <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
2027658: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
202765c: 03 00 81 8c sethi %hi(0x2063000), %g1
2027660: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 ! 2063030 <rtems_libio_number_iops>
2027664: 80 a6 00 01 cmp %i0, %g1
2027668: 1a 80 00 29 bcc 202770c <fchown+0xb4>
202766c: 03 00 81 9c sethi %hi(0x2067000), %g1
iop = rtems_libio_iop( fd );
2027670: fa 00 61 d4 ld [ %g1 + 0x1d4 ], %i5 ! 20671d4 <rtems_libio_iops>
2027674: 83 2e 20 03 sll %i0, 3, %g1
2027678: b1 2e 20 06 sll %i0, 6, %i0
202767c: b0 26 00 01 sub %i0, %g1, %i0
2027680: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2027684: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2027688: 80 88 61 00 btst 0x100, %g1
202768c: 02 80 00 20 be 202770c <fchown+0xb4>
2027690: 01 00 00 00 nop
if (iop->pathinfo.mt_entry->writeable) {
2027694: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2027698: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
202769c: 80 a0 60 00 cmp %g1, 0
20276a0: 02 80 00 15 be 20276f4 <fchown+0x9c> <== NEVER TAKEN
20276a4: 01 00 00 00 nop
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
20276a8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
20276ac: c2 00 40 00 ld [ %g1 ], %g1
20276b0: 9f c0 40 00 call %g1
20276b4: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
20276b8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
20276bc: 90 07 60 14 add %i5, 0x14, %o0
20276c0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20276c4: 92 10 00 19 mov %i1, %o1
20276c8: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
20276cc: 9f c0 40 00 call %g1
20276d0: 94 10 00 1a mov %i2, %o2
20276d4: b0 10 00 08 mov %o0, %i0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
20276d8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
20276dc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
20276e0: c2 00 60 04 ld [ %g1 + 4 ], %g1
20276e4: 9f c0 40 00 call %g1
20276e8: 01 00 00 00 nop
20276ec: 81 c7 e0 08 ret
20276f0: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
20276f4: 40 00 51 dd call 203be68 <__errno> <== NOT EXECUTED
20276f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20276fc: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
2027700: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2027704: 81 c7 e0 08 ret <== NOT EXECUTED
2027708: 81 e8 00 00 restore <== NOT EXECUTED
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
202770c: 40 00 51 d7 call 203be68 <__errno>
2027710: b0 10 3f ff mov -1, %i0
2027714: 82 10 20 09 mov 9, %g1
2027718: c2 22 00 00 st %g1, [ %o0 ]
202771c: 81 c7 e0 08 ret
2027720: 81 e8 00 00 restore
02031f78 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
2031f78: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2031f7c: 03 00 80 e1 sethi %hi(0x2038400), %g1
2031f80: c4 00 60 bc ld [ %g1 + 0xbc ], %g2 ! 20384bc <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
2031f84: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2031f88: 82 07 a0 4c add %fp, 0x4c, %g1
2031f8c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2031f90: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2031f94: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2031f98: 80 a6 00 02 cmp %i0, %g2
2031f9c: 1a 80 00 7c bcc 203218c <fcntl+0x214>
2031fa0: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
2031fa4: 39 00 81 24 sethi %hi(0x2049000), %i4
2031fa8: fa 07 20 68 ld [ %i4 + 0x68 ], %i5 ! 2049068 <rtems_libio_iops>
2031fac: 85 2e 20 03 sll %i0, 3, %g2
2031fb0: b1 2e 20 06 sll %i0, 6, %i0
2031fb4: b0 26 00 02 sub %i0, %g2, %i0
2031fb8: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2031fbc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2031fc0: 80 8a 21 00 btst 0x100, %o0
2031fc4: 02 80 00 72 be 203218c <fcntl+0x214>
2031fc8: 80 a6 60 09 cmp %i1, 9
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
2031fcc: 08 80 00 08 bleu 2031fec <fcntl+0x74>
2031fd0: 85 2e 60 02 sll %i1, 2, %g2
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
2031fd4: 7f ff c4 a5 call 2023268 <__errno>
2031fd8: b0 10 3f ff mov -1, %i0
2031fdc: 82 10 20 16 mov 0x16, %g1
2031fe0: c2 22 00 00 st %g1, [ %o0 ]
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
2031fe4: 81 c7 e0 08 ret
2031fe8: 81 e8 00 00 restore
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
2031fec: 07 00 80 c7 sethi %hi(0x2031c00), %g3
2031ff0: 86 10 e3 50 or %g3, 0x350, %g3 ! 2031f50 <_calloc_r+0x14>
2031ff4: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2031ff8: 81 c0 80 00 jmp %g2
2031ffc: 01 00 00 00 nop
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
2032000: 7f ff c4 9a call 2023268 <__errno>
2032004: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff>
2032008: 82 10 20 86 mov 0x86, %g1
203200c: c2 22 00 00 st %g1, [ %o0 ]
2032010: 81 c7 e0 08 ret
2032014: 81 e8 00 00 restore
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
2032018: d0 00 40 00 ld [ %g1 ], %o0
203201c: 7f ff 5a d1 call 2008b60 <rtems_libio_fcntl_flags>
2032020: b0 10 20 00 clr %i0
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
2032024: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2032028: 90 0a 22 01 and %o0, 0x201, %o0
203202c: 82 08 7d fe and %g1, -514, %g1
2032030: 82 12 00 01 or %o0, %g1, %g1
2032034: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
2032038: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
203203c: 90 10 00 1d mov %i5, %o0
2032040: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
2032044: 9f c0 40 00 call %g1
2032048: 92 10 00 19 mov %i1, %o1
if (err) {
203204c: ba 92 20 00 orcc %o0, 0, %i5
2032050: 02 80 00 53 be 203219c <fcntl+0x224> <== ALWAYS TAKEN
2032054: 01 00 00 00 nop
errno = err;
2032058: 7f ff c4 84 call 2023268 <__errno> <== NOT EXECUTED
203205c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2032060: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
2032064: 81 c7 e0 08 ret <== NOT EXECUTED
2032068: 81 e8 00 00 restore <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
203206c: 7f ff 5a ca call 2008b94 <rtems_libio_to_fcntl_flags>
2032070: 01 00 00 00 nop
2032074: b0 10 00 08 mov %o0, %i0
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
2032078: 80 a6 20 00 cmp %i0, 0
203207c: 36 bf ff f0 bge,a 203203c <fcntl+0xc4> <== ALWAYS TAKEN
2032080: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
2032084: 81 c7 e0 08 ret <== NOT EXECUTED
2032088: 81 e8 00 00 restore <== NOT EXECUTED
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
203208c: c2 00 40 00 ld [ %g1 ], %g1
2032090: 80 a0 60 00 cmp %g1, 0
2032094: 22 80 00 3b be,a 2032180 <fcntl+0x208>
2032098: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
203209c: 90 12 28 00 or %o0, 0x800, %o0
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
20320a0: b0 10 20 00 clr %i0
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
20320a4: 10 bf ff e5 b 2032038 <fcntl+0xc0>
20320a8: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
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);
20320ac: b1 32 20 0b srl %o0, 0xb, %i0
20320b0: 10 bf ff e2 b 2032038 <fcntl+0xc0>
20320b4: b0 0e 20 01 and %i0, 1, %i0
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
20320b8: 7f ff 5a ce call 2008bf0 <rtems_libio_allocate>
20320bc: 01 00 00 00 nop
if (diop != NULL) {
20320c0: b6 92 20 00 orcc %o0, 0, %i3
20320c4: 02 bf ff c8 be 2031fe4 <fcntl+0x6c>
20320c8: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
20320cc: 7f ff 5a b2 call 2008b94 <rtems_libio_to_fcntl_flags>
20320d0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
20320d4: f0 06 e0 10 ld [ %i3 + 0x10 ], %i0
rtems_libio_t *diop = rtems_libio_allocate();
if (diop != NULL) {
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
oflag &= ~O_CREAT;
20320d8: b4 0a 3d ff and %o0, -513, %i2
diop->flags |= rtems_libio_fcntl_flags( oflag );
20320dc: 7f ff 5a a1 call 2008b60 <rtems_libio_fcntl_flags>
20320e0: 90 10 00 1a mov %i2, %o0
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
20320e4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
20320e8: b0 12 00 18 or %o0, %i0, %i0
(*mt_entry->ops->lock_h)( mt_entry );
20320ec: c4 00 60 0c ld [ %g1 + 0xc ], %g2
20320f0: 90 10 00 01 mov %g1, %o0
20320f4: c2 00 80 00 ld [ %g2 ], %g1
20320f8: 9f c0 40 00 call %g1
20320fc: f0 26 e0 10 st %i0, [ %i3 + 0x10 ]
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
2032100: 92 07 60 14 add %i5, 0x14, %o1
2032104: 7f ff 98 c5 call 2018418 <rtems_filesystem_location_clone>
2032108: 90 06 e0 14 add %i3, 0x14, %o0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
203210c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2032110: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2032114: c2 00 60 04 ld [ %g1 + 4 ], %g1
2032118: 9f c0 40 00 call %g1
203211c: 01 00 00 00 nop
/*
* XXX: We call the open handler here to have a proper open and close pair.
*
* FIXME: What to do with the path?
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
2032120: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
2032124: 90 10 00 1b mov %i3, %o0
2032128: c2 00 40 00 ld [ %g1 ], %g1
203212c: 92 10 20 00 clr %o1
2032130: 94 10 00 1a mov %i2, %o2
2032134: 9f c0 40 00 call %g1
2032138: 96 10 20 00 clr %o3
if ( rv == 0 ) {
203213c: b0 92 20 00 orcc %o0, 0, %i0
2032140: 12 80 00 19 bne 20321a4 <fcntl+0x22c> <== NEVER TAKEN
2032144: c2 07 20 68 ld [ %i4 + 0x68 ], %g1
rv = diop - rtems_libio_iops;
2032148: b6 26 c0 01 sub %i3, %g1, %i3
203214c: b7 3e e0 03 sra %i3, 3, %i3
2032150: 85 2e e0 03 sll %i3, 3, %g2
2032154: 83 2e e0 06 sll %i3, 6, %g1
2032158: 82 00 80 01 add %g2, %g1, %g1
203215c: 85 28 60 06 sll %g1, 6, %g2
2032160: 82 00 40 02 add %g1, %g2, %g1
2032164: 82 00 40 1b add %g1, %i3, %g1
2032168: 85 28 60 0f sll %g1, 0xf, %g2
203216c: 82 00 40 02 add %g1, %g2, %g1
2032170: 83 28 60 03 sll %g1, 3, %g1
2032174: b6 00 40 1b add %g1, %i3, %i3
2032178: 10 bf ff c0 b 2032078 <fcntl+0x100>
203217c: b0 20 00 1b neg %i3, %i0
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
2032180: b0 10 20 00 clr %i0
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
2032184: 10 bf ff ad b 2032038 <fcntl+0xc0>
2032188: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
203218c: 7f ff c4 37 call 2023268 <__errno>
2032190: b0 10 3f ff mov -1, %i0
2032194: 82 10 20 09 mov 9, %g1
2032198: c2 22 00 00 st %g1, [ %o0 ]
203219c: 81 c7 e0 08 ret
20321a0: 81 e8 00 00 restore
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
if ( rv == 0 ) {
rv = diop - rtems_libio_iops;
} else {
rtems_libio_free( diop );
20321a4: 7f ff 5a a9 call 2008c48 <rtems_libio_free> <== NOT EXECUTED
20321a8: 90 10 00 1b mov %i3, %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) {
20321ac: 10 bf ff b4 b 203207c <fcntl+0x104> <== NOT EXECUTED
20321b0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
0200e84c <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200e84c: 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) {
200e850: 3b 00 80 90 sethi %hi(0x2024000), %i5
200e854: d0 07 61 10 ld [ %i5 + 0x110 ], %o0 ! 2024110 <pipe_semaphore>
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200e858: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
200e85c: 80 a2 20 00 cmp %o0, 0
200e860: 02 80 00 18 be 200e8c0 <fifo_open+0x74>
200e864: b8 17 61 10 or %i5, 0x110, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200e868: 92 10 20 00 clr %o1
200e86c: 7f ff eb 37 call 2009548 <rtems_semaphore_obtain>
200e870: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
200e874: 80 a2 20 00 cmp %o0, 0
200e878: 12 80 00 7a bne 200ea60 <fifo_open+0x214> <== NEVER TAKEN
200e87c: 01 00 00 00 nop
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
200e880: f8 06 c0 00 ld [ %i3 ], %i4
if (pipe == NULL) {
200e884: 80 a7 20 00 cmp %i4, 0
200e888: 02 80 00 1b be 200e8f4 <fifo_open+0xa8>
200e88c: 01 00 00 00 nop
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200e890: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
200e894: 92 10 20 00 clr %o1
200e898: 7f ff eb 2c call 2009548 <rtems_semaphore_obtain>
200e89c: 94 10 20 00 clr %o2
200e8a0: 80 a2 20 00 cmp %o0, 0
200e8a4: 02 80 00 8c be 200ead4 <fifo_open+0x288> <== ALWAYS TAKEN
200e8a8: c2 06 c0 00 ld [ %i3 ], %g1
err = -EINTR;
if (*pipep == NULL) {
200e8ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e8b0: 22 80 00 6e be,a 200ea68 <fifo_open+0x21c> <== NOT EXECUTED
200e8b4: d0 07 20 2c ld [ %i4 + 0x2c ], %o0 <== NOT EXECUTED
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200e8b8: 10 80 00 76 b 200ea90 <fifo_open+0x244> <== NOT EXECUTED
200e8bc: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200e8c0: 35 00 80 90 sethi %hi(0x2024000), %i2
200e8c4: d0 06 a2 90 ld [ %i2 + 0x290 ], %o0 ! 2024290 <rtems_libio_semaphore>
200e8c8: 92 10 20 00 clr %o1
200e8cc: 7f ff eb 1f call 2009548 <rtems_semaphore_obtain>
200e8d0: 94 10 20 00 clr %o2
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
200e8d4: c2 07 61 10 ld [ %i5 + 0x110 ], %g1
200e8d8: 80 a0 60 00 cmp %g1, 0
200e8dc: 02 80 00 55 be 200ea30 <fifo_open+0x1e4> <== ALWAYS TAKEN
200e8e0: 98 10 00 1c mov %i4, %o4
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200e8e4: 7f ff eb 68 call 2009684 <rtems_semaphore_release> <== NOT EXECUTED
200e8e8: d0 06 a2 90 ld [ %i2 + 0x290 ], %o0 <== NOT EXECUTED
200e8ec: 10 bf ff df b 200e868 <fifo_open+0x1c> <== NOT EXECUTED
200e8f0: d0 07 61 10 ld [ %i5 + 0x110 ], %o0 <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
200e8f4: 7f ff d9 4a call 2004e1c <malloc>
200e8f8: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
200e8fc: b8 92 20 00 orcc %o0, 0, %i4
200e900: 02 80 00 73 be 200eacc <fifo_open+0x280> <== NEVER TAKEN
200e904: 82 10 22 00 mov 0x200, %g1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
200e908: c0 27 00 00 clr [ %i4 ]
200e90c: c0 27 20 08 clr [ %i4 + 8 ]
200e910: c0 27 20 0c clr [ %i4 + 0xc ]
200e914: c0 27 20 10 clr [ %i4 + 0x10 ]
200e918: c0 27 20 14 clr [ %i4 + 0x14 ]
200e91c: c0 27 20 18 clr [ %i4 + 0x18 ]
200e920: c0 27 20 1c clr [ %i4 + 0x1c ]
200e924: c0 27 20 20 clr [ %i4 + 0x20 ]
200e928: c0 27 20 24 clr [ %i4 + 0x24 ]
200e92c: c0 27 20 28 clr [ %i4 + 0x28 ]
200e930: c0 27 20 2c clr [ %i4 + 0x2c ]
200e934: c0 27 20 30 clr [ %i4 + 0x30 ]
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
200e938: 90 10 22 00 mov 0x200, %o0
200e93c: 7f ff d9 38 call 2004e1c <malloc>
200e940: c2 27 20 04 st %g1, [ %i4 + 4 ]
if (! pipe->Buffer)
200e944: 80 a2 20 00 cmp %o0, 0
200e948: 02 80 00 5f be 200eac4 <fifo_open+0x278> <== NEVER TAKEN
200e94c: d0 27 00 00 st %o0, [ %i4 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
200e950: 35 00 80 8e sethi %hi(0x2023800), %i2
200e954: d0 4e a1 c8 ldsb [ %i2 + 0x1c8 ], %o0 ! 20239c8 <c.7185>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
200e958: 31 14 12 5c sethi %hi(0x50497000), %i0
200e95c: 82 16 22 00 or %i0, 0x200, %g1 ! 50497200 <RAM_END+0x4e097200>
200e960: 92 10 20 00 clr %o1
200e964: 94 10 20 00 clr %o2
200e968: 90 12 00 01 or %o0, %g1, %o0
200e96c: 40 00 06 5f call 20102e8 <rtems_barrier_create>
200e970: 96 07 20 2c add %i4, 0x2c, %o3
200e974: 80 a2 20 00 cmp %o0, 0
200e978: 12 80 00 51 bne 200eabc <fifo_open+0x270>
200e97c: d0 4e a1 c8 ldsb [ %i2 + 0x1c8 ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
200e980: 03 14 12 5d sethi %hi(0x50497400), %g1
200e984: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x4e097700>
200e988: 92 10 20 00 clr %o1
200e98c: 94 10 20 00 clr %o2
200e990: 90 12 00 01 or %o0, %g1, %o0
200e994: 40 00 06 55 call 20102e8 <rtems_barrier_create>
200e998: 96 07 20 30 add %i4, 0x30, %o3
200e99c: 80 a2 20 00 cmp %o0, 0
200e9a0: 12 80 00 45 bne 200eab4 <fifo_open+0x268>
200e9a4: d0 4e a1 c8 ldsb [ %i2 + 0x1c8 ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
200e9a8: b0 16 23 00 or %i0, 0x300, %i0
200e9ac: 92 10 20 01 mov 1, %o1
200e9b0: 90 12 00 18 or %o0, %i0, %o0
200e9b4: 94 10 20 10 mov 0x10, %o2
200e9b8: 96 10 20 00 clr %o3
200e9bc: 7f ff ea 3b call 20092a8 <rtems_semaphore_create>
200e9c0: 98 07 20 28 add %i4, 0x28, %o4
200e9c4: 80 a2 20 00 cmp %o0, 0
200e9c8: 12 80 00 39 bne 200eaac <fifo_open+0x260>
200e9cc: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
200e9d0: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
200e9d4: 21 00 80 93 sethi %hi(0x2024c00), %l0
200e9d8: 7f ff f1 f5 call 200b1ac <_Objects_Get>
200e9dc: 90 14 21 40 or %l0, 0x140, %o0 ! 2024d40 <_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;
200e9e0: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200e9e4: 31 04 00 00 sethi %hi(0x10000000), %i0
200e9e8: 82 10 40 18 or %g1, %i0, %g1
_Thread_Enable_dispatch();
200e9ec: 7f ff f5 de call 200c164 <_Thread_Enable_dispatch>
200e9f0: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
200e9f4: d2 07 20 30 ld [ %i4 + 0x30 ], %o1
200e9f8: 94 07 bf fc add %fp, -4, %o2
200e9fc: 7f ff f1 ec call 200b1ac <_Objects_Get>
200ea00: 90 14 21 40 or %l0, 0x140, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
200ea04: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200ea08: b0 10 40 18 or %g1, %i0, %i0
_Thread_Enable_dispatch();
200ea0c: 7f ff f5 d6 call 200c164 <_Thread_Enable_dispatch>
200ea10: f0 22 20 4c st %i0, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200ea14: c2 4e a1 c8 ldsb [ %i2 + 0x1c8 ], %g1
200ea18: 80 a0 60 7a cmp %g1, 0x7a
200ea1c: 02 80 00 21 be 200eaa0 <fifo_open+0x254>
200ea20: c4 0e a1 c8 ldub [ %i2 + 0x1c8 ], %g2
200ea24: 84 00 a0 01 inc %g2
200ea28: 10 bf ff 9a b 200e890 <fifo_open+0x44>
200ea2c: c4 2e a1 c8 stb %g2, [ %i2 + 0x1c8 ]
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
200ea30: 92 10 20 01 mov 1, %o1
200ea34: 94 10 20 54 mov 0x54, %o2
200ea38: 96 10 20 00 clr %o3
200ea3c: 11 14 12 54 sethi %hi(0x50495000), %o0
200ea40: 7f ff ea 1a call 20092a8 <rtems_semaphore_create>
200ea44: 90 12 20 45 or %o0, 0x45, %o0 ! 50495045 <RAM_END+0x4e095045>
200ea48: b8 10 00 08 mov %o0, %i4
200ea4c: 7f ff eb 0e call 2009684 <rtems_semaphore_release>
200ea50: d0 06 a2 90 ld [ %i2 + 0x290 ], %o0
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
200ea54: 80 a7 20 00 cmp %i4, 0
200ea58: 02 bf ff 84 be 200e868 <fifo_open+0x1c>
200ea5c: d0 07 61 10 ld [ %i5 + 0x110 ], %o0
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
err = -ENXIO;
200ea60: 81 c7 e0 08 ret
200ea64: 91 e8 3f f4 restore %g0, -12, %o0
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
200ea68: 40 00 06 51 call 20103ac <rtems_barrier_delete> <== NOT EXECUTED
200ea6c: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
200ea70: 40 00 06 4f call 20103ac <rtems_barrier_delete> <== NOT EXECUTED
200ea74: d0 07 20 30 ld [ %i4 + 0x30 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
200ea78: 7f ff ea 7d call 200946c <rtems_semaphore_delete> <== NOT EXECUTED
200ea7c: d0 07 20 28 ld [ %i4 + 0x28 ], %o0 <== NOT EXECUTED
free(pipe->Buffer);
200ea80: 7f ff d7 cc call 20049b0 <free> <== NOT EXECUTED
200ea84: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free(pipe);
200ea88: 7f ff d7 ca call 20049b0 <free> <== NOT EXECUTED
200ea8c: 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);
200ea90: 7f ff ea fd call 2009684 <rtems_semaphore_release>
200ea94: d0 07 61 10 ld [ %i5 + 0x110 ], %o0
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
200ea98: 81 c7 e0 08 ret
200ea9c: 81 e8 00 00 restore
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
c = 'a';
200eaa0: 82 10 20 61 mov 0x61, %g1
200eaa4: 10 bf ff 7b b 200e890 <fifo_open+0x44>
200eaa8: c2 2e a1 c8 stb %g1, [ %i2 + 0x1c8 ]
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
200eaac: 40 00 06 40 call 20103ac <rtems_barrier_delete>
200eab0: d0 07 20 30 ld [ %i4 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
200eab4: 40 00 06 3e call 20103ac <rtems_barrier_delete>
200eab8: d0 07 20 2c ld [ %i4 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
200eabc: 7f ff d7 bd call 20049b0 <free>
200eac0: d0 07 00 00 ld [ %i4 ], %o0
err_buf:
free(pipe);
200eac4: 7f ff d7 bb call 20049b0 <free>
200eac8: 90 10 00 1c mov %i4, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200eacc: 10 bf ff f1 b 200ea90 <fifo_open+0x244>
200ead0: b0 10 3f f4 mov -12, %i0
if (*pipep == NULL) {
200ead4: 80 a0 60 00 cmp %g1, 0
200ead8: 22 80 00 02 be,a 200eae0 <fifo_open+0x294>
200eadc: f8 26 c0 00 st %i4, [ %i3 ]
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200eae0: 7f ff ea e9 call 2009684 <rtems_semaphore_release>
200eae4: d0 07 61 10 ld [ %i5 + 0x110 ], %o0
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
200eae8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200eaec: 82 08 60 06 and %g1, 6, %g1
200eaf0: 80 a0 60 04 cmp %g1, 4
200eaf4: 02 80 00 0c be 200eb24 <fifo_open+0x2d8>
200eaf8: fa 06 c0 00 ld [ %i3 ], %i5
200eafc: 80 a0 60 06 cmp %g1, 6
200eb00: 02 80 00 58 be 200ec60 <fifo_open+0x414>
200eb04: 80 a0 60 02 cmp %g1, 2
200eb08: 22 80 00 31 be,a 200ebcc <fifo_open+0x380> <== ALWAYS TAKEN
200eb0c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
200eb10: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
200eb14: 7f ff ea dc call 2009684 <rtems_semaphore_release>
200eb18: b0 10 20 00 clr %i0
return 0;
200eb1c: 81 c7 e0 08 ret
200eb20: 81 e8 00 00 restore
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
200eb24: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
200eb28: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
if (pipe->Writers ++ == 0)
200eb2c: 86 00 60 01 add %g1, 1, %g3
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
200eb30: 84 00 a0 01 inc %g2
if (pipe->Writers ++ == 0)
200eb34: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
200eb38: 80 a0 60 00 cmp %g1, 0
200eb3c: 02 80 00 68 be 200ecdc <fifo_open+0x490> <== ALWAYS TAKEN
200eb40: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
200eb44: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
200eb48: 80 a0 60 00 cmp %g1, 0
200eb4c: 32 bf ff f2 bne,a 200eb14 <fifo_open+0x2c8>
200eb50: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200eb54: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200eb58: 80 88 60 01 btst 1, %g1
200eb5c: 32 80 00 65 bne,a 200ecf0 <fifo_open+0x4a4>
200eb60: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
200eb64: 10 80 00 0c b 200eb94 <fifo_open+0x348>
200eb68: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
200eb6c: 92 10 20 00 clr %o1
200eb70: 7f ff ea 76 call 2009548 <rtems_semaphore_obtain>
200eb74: 94 10 20 00 clr %o2
200eb78: 80 a2 20 00 cmp %o0, 0
200eb7c: 12 80 00 0f bne 200ebb8 <fifo_open+0x36c> <== NEVER TAKEN
200eb80: b0 10 3f fc mov -4, %i0
goto out_error;
} while (prevCounter == pipe->readerCounter);
200eb84: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200eb88: 80 a0 40 1c cmp %g1, %i4
200eb8c: 32 bf ff e2 bne,a 200eb14 <fifo_open+0x2c8> <== ALWAYS TAKEN
200eb90: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
200eb94: 7f ff ea bc call 2009684 <rtems_semaphore_release>
200eb98: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
200eb9c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200eba0: 40 00 06 44 call 20104b0 <rtems_barrier_wait>
200eba4: 92 10 20 00 clr %o1
200eba8: 80 a2 20 00 cmp %o0, 0
200ebac: 22 bf ff f0 be,a 200eb6c <fifo_open+0x320> <== ALWAYS TAKEN
200ebb0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
200ebb4: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
200ebb8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
200ebbc: 7f ff fe e5 call 200e750 <pipe_release>
200ebc0: 92 10 00 19 mov %i1, %o1
return err;
200ebc4: 81 c7 e0 08 ret
200ebc8: 81 e8 00 00 restore
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
200ebcc: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
if (pipe->Readers ++ == 0)
200ebd0: 86 00 60 01 add %g1, 1, %g3
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
200ebd4: 84 00 a0 01 inc %g2
if (pipe->Readers ++ == 0)
200ebd8: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
200ebdc: 80 a0 60 00 cmp %g1, 0
200ebe0: 02 80 00 35 be 200ecb4 <fifo_open+0x468> <== ALWAYS TAKEN
200ebe4: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
200ebe8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
200ebec: 80 a0 60 00 cmp %g1, 0
200ebf0: 32 bf ff c9 bne,a 200eb14 <fifo_open+0x2c8>
200ebf4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
200ebf8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200ebfc: 80 88 60 01 btst 1, %g1
200ec00: 32 bf ff c5 bne,a 200eb14 <fifo_open+0x2c8>
200ec04: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
break;
prevCounter = pipe->writerCounter;
200ec08: 10 80 00 0c b 200ec38 <fifo_open+0x3ec>
200ec0c: f8 07 60 24 ld [ %i5 + 0x24 ], %i4
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
200ec10: 92 10 20 00 clr %o1
200ec14: 7f ff ea 4d call 2009548 <rtems_semaphore_obtain>
200ec18: 94 10 20 00 clr %o2
200ec1c: 80 a2 20 00 cmp %o0, 0
200ec20: 12 bf ff e6 bne 200ebb8 <fifo_open+0x36c> <== NEVER TAKEN
200ec24: b0 10 3f fc mov -4, %i0
goto out_error;
} while (prevCounter == pipe->writerCounter);
200ec28: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200ec2c: 80 a0 40 1c cmp %g1, %i4
200ec30: 32 bf ff b9 bne,a 200eb14 <fifo_open+0x2c8> <== ALWAYS TAKEN
200ec34: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
200ec38: 7f ff ea 93 call 2009684 <rtems_semaphore_release>
200ec3c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
200ec40: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200ec44: 40 00 06 1b call 20104b0 <rtems_barrier_wait>
200ec48: 92 10 20 00 clr %o1
200ec4c: 80 a2 20 00 cmp %o0, 0
200ec50: 22 bf ff f0 be,a 200ec10 <fifo_open+0x3c4> <== ALWAYS TAKEN
200ec54: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
200ec58: 10 bf ff d8 b 200ebb8 <fifo_open+0x36c> <== NOT EXECUTED
200ec5c: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
200ec60: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
200ec64: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
if (pipe->Readers ++ == 0)
200ec68: 86 00 60 01 add %g1, 1, %g3
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
200ec6c: 84 00 a0 01 inc %g2
if (pipe->Readers ++ == 0)
200ec70: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
200ec74: 80 a0 60 00 cmp %g1, 0
200ec78: 02 80 00 14 be 200ecc8 <fifo_open+0x47c> <== ALWAYS TAKEN
200ec7c: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
200ec80: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
200ec84: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
if (pipe->Writers ++ == 0)
200ec88: 86 00 60 01 add %g1, 1, %g3
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
200ec8c: 84 00 a0 01 inc %g2
if (pipe->Writers ++ == 0)
200ec90: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
200ec94: 80 a0 60 00 cmp %g1, 0
200ec98: 12 bf ff 9e bne 200eb10 <fifo_open+0x2c4> <== NEVER TAKEN
200ec9c: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
PIPE_WAKEUPREADERS(pipe);
200eca0: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200eca4: 40 00 05 eb call 2010450 <rtems_barrier_release>
200eca8: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
200ecac: 10 bf ff 9a b 200eb14 <fifo_open+0x2c8>
200ecb0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
200ecb4: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200ecb8: 40 00 05 e6 call 2010450 <rtems_barrier_release>
200ecbc: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
200ecc0: 10 bf ff cb b 200ebec <fifo_open+0x3a0>
200ecc4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
200ecc8: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200eccc: 40 00 05 e1 call 2010450 <rtems_barrier_release>
200ecd0: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
200ecd4: 10 bf ff ec b 200ec84 <fifo_open+0x438>
200ecd8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
200ecdc: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200ece0: 40 00 05 dc call 2010450 <rtems_barrier_release>
200ece4: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
200ece8: 10 bf ff 98 b 200eb48 <fifo_open+0x2fc>
200ecec: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
PIPE_UNLOCK(pipe);
200ecf0: 7f ff ea 65 call 2009684 <rtems_semaphore_release>
200ecf4: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
200ecf8: 10 bf ff b1 b 200ebbc <fifo_open+0x370>
200ecfc: 90 10 00 1b mov %i3, %o0
02009cc4 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
2009cc4: 9d e3 bf a0 save %sp, -96, %sp
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
2009cc8: 03 00 80 4a sethi %hi(0x2012800), %g1
2009ccc: c2 00 63 58 ld [ %g1 + 0x358 ], %g1 ! 2012b58 <rtems_libio_number_iops>
2009cd0: 80 a6 00 01 cmp %i0, %g1
2009cd4: 1a 80 00 3e bcc 2009dcc <fpathconf+0x108>
2009cd8: 03 00 80 4c sethi %hi(0x2013000), %g1
iop = rtems_libio_iop(fd);
2009cdc: c2 00 63 80 ld [ %g1 + 0x380 ], %g1 ! 2013380 <rtems_libio_iops>
2009ce0: 85 2e 20 03 sll %i0, 3, %g2
2009ce4: b1 2e 20 06 sll %i0, 6, %i0
2009ce8: b0 26 00 02 sub %i0, %g2, %i0
2009cec: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_is_open(iop);
2009cf0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
2009cf4: 80 88 61 00 btst 0x100, %g1
2009cf8: 02 80 00 35 be 2009dcc <fpathconf+0x108> <== NEVER TAKEN
2009cfc: 80 a6 60 0b cmp %i1, 0xb
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
2009d00: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
switch ( name ) {
2009d04: 08 80 00 08 bleu 2009d24 <fpathconf+0x60>
2009d08: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2009d0c: 40 00 09 9f call 200c388 <__errno>
2009d10: b0 10 3f ff mov -1, %i0
2009d14: 82 10 20 16 mov 0x16, %g1
2009d18: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
2009d1c: 81 c7 e0 08 ret
2009d20: 81 e8 00 00 restore
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
2009d24: b3 2e 60 02 sll %i1, 2, %i1
2009d28: 05 00 80 27 sethi %hi(0x2009c00), %g2
2009d2c: 84 10 a0 94 or %g2, 0x94, %g2 ! 2009c94 <_close_r+0x10>
2009d30: c4 00 80 19 ld [ %g2 + %i1 ], %g2
2009d34: 81 c0 80 00 jmp %g2
2009d38: 01 00 00 00 nop
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
2009d3c: f0 00 60 24 ld [ %g1 + 0x24 ], %i0
break;
2009d40: 81 c7 e0 08 ret
2009d44: 81 e8 00 00 restore
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
2009d48: f0 00 60 18 ld [ %g1 + 0x18 ], %i0
break;
2009d4c: 81 c7 e0 08 ret
2009d50: 81 e8 00 00 restore
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
2009d54: f0 00 60 2c ld [ %g1 + 0x2c ], %i0
break;
2009d58: 81 c7 e0 08 ret
2009d5c: 81 e8 00 00 restore
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
2009d60: f0 00 60 20 ld [ %g1 + 0x20 ], %i0
break;
2009d64: 81 c7 e0 08 ret
2009d68: 81 e8 00 00 restore
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
2009d6c: f0 00 60 1c ld [ %g1 + 0x1c ], %i0
break;
2009d70: 81 c7 e0 08 ret
2009d74: 81 e8 00 00 restore
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
2009d78: f0 00 60 14 ld [ %g1 + 0x14 ], %i0
break;
2009d7c: 81 c7 e0 08 ret
2009d80: 81 e8 00 00 restore
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
2009d84: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
break;
2009d88: 81 c7 e0 08 ret
2009d8c: 81 e8 00 00 restore
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
2009d90: f0 00 60 0c ld [ %g1 + 0xc ], %i0
break;
2009d94: 81 c7 e0 08 ret
2009d98: 81 e8 00 00 restore
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2009d9c: f0 00 60 08 ld [ %g1 + 8 ], %i0
break;
2009da0: 81 c7 e0 08 ret
2009da4: 81 e8 00 00 restore
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2009da8: f0 00 60 04 ld [ %g1 + 4 ], %i0
break;
2009dac: 81 c7 e0 08 ret
2009db0: 81 e8 00 00 restore
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
2009db4: f0 00 40 00 ld [ %g1 ], %i0
break;
2009db8: 81 c7 e0 08 ret
2009dbc: 81 e8 00 00 restore
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
2009dc0: f0 00 60 28 ld [ %g1 + 0x28 ], %i0
break;
2009dc4: 81 c7 e0 08 ret
2009dc8: 81 e8 00 00 restore
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
2009dcc: 40 00 09 6f call 200c388 <__errno>
2009dd0: b0 10 3f ff mov -1, %i0
2009dd4: 82 10 20 09 mov 9, %g1
2009dd8: c2 22 00 00 st %g1, [ %o0 ]
2009ddc: 81 c7 e0 08 ret
2009de0: 81 e8 00 00 restore
02003670 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
2003670: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
2003674: 03 00 80 78 sethi %hi(0x201e000), %g1
2003678: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 201e1a0 <rtems_malloc_statistics>
200367c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
2003680: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
2003684: 84 00 a0 01 inc %g2
if ( !ptr )
2003688: 80 a6 20 00 cmp %i0, 0
200368c: 02 80 00 15 be 20036e0 <free+0x70>
2003690: 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()) &&
2003694: 03 00 80 7a sethi %hi(0x201e800), %g1
2003698: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 201e838 <_System_state_Current>
200369c: 80 a0 60 03 cmp %g1, 3
20036a0: 02 80 00 17 be 20036fc <free+0x8c> <== ALWAYS TAKEN
20036a4: 03 00 80 77 sethi %hi(0x201dc00), %g1
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
20036a8: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 ! 201dee0 <rtems_malloc_statistics_helpers>
20036ac: 80 a0 60 00 cmp %g1, 0
20036b0: 02 80 00 06 be 20036c8 <free+0x58>
20036b4: 3b 00 80 75 sethi %hi(0x201d400), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
20036b8: c2 00 60 08 ld [ %g1 + 8 ], %g1
20036bc: 9f c0 40 00 call %g1
20036c0: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
20036c4: 3b 00 80 75 sethi %hi(0x201d400), %i5
20036c8: d0 07 63 00 ld [ %i5 + 0x300 ], %o0 ! 201d700 <RTEMS_Malloc_Heap>
20036cc: 40 00 18 e9 call 2009a70 <_Protected_heap_Free>
20036d0: 92 10 00 19 mov %i1, %o1
20036d4: 80 8a 20 ff btst 0xff, %o0
20036d8: 02 80 00 04 be 20036e8 <free+0x78>
20036dc: c2 07 63 00 ld [ %i5 + 0x300 ], %g1
20036e0: 81 c7 e0 08 ret
20036e4: 81 e8 00 00 restore
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
20036e8: 31 00 80 70 sethi %hi(0x201c000), %i0
20036ec: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
20036f0: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
20036f4: 40 00 03 81 call 20044f8 <printk>
20036f8: 91 ee 20 58 restore %i0, 0x58, %o0
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
20036fc: 40 00 00 67 call 2003898 <malloc_is_system_state_OK>
2003700: 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()) &&
2003704: 80 8a 20 ff btst 0xff, %o0
2003708: 12 bf ff e8 bne 20036a8 <free+0x38>
200370c: 03 00 80 77 sethi %hi(0x201dc00), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
2003710: 40 00 00 7c call 2003900 <malloc_deferred_free>
2003714: 81 e8 00 00 restore
0201a974 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
201a974: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
201a978: 80 a6 60 00 cmp %i1, 0
201a97c: 02 80 00 1f be 201a9f8 <fstat+0x84> <== NEVER TAKEN
201a980: 03 00 80 75 sethi %hi(0x201d400), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
201a984: c2 00 63 44 ld [ %g1 + 0x344 ], %g1 ! 201d744 <rtems_libio_number_iops>
201a988: 80 a6 00 01 cmp %i0, %g1
201a98c: 1a 80 00 15 bcc 201a9e0 <fstat+0x6c>
201a990: 03 00 80 78 sethi %hi(0x201e000), %g1
201a994: c2 00 61 94 ld [ %g1 + 0x194 ], %g1 ! 201e194 <rtems_libio_iops>
201a998: 85 2e 20 03 sll %i0, 3, %g2
201a99c: b1 2e 20 06 sll %i0, 6, %i0
201a9a0: b0 26 00 02 sub %i0, %g2, %i0
201a9a4: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
201a9a8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201a9ac: 80 88 61 00 btst 0x100, %g1
201a9b0: 02 80 00 0c be 201a9e0 <fstat+0x6c>
201a9b4: 94 10 20 48 mov 0x48, %o2
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
201a9b8: 92 10 20 00 clr %o1
201a9bc: 7f ff d9 15 call 2010e10 <memset>
201a9c0: 90 10 00 19 mov %i1, %o0
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
201a9c4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
201a9c8: 90 06 20 14 add %i0, 0x14, %o0
201a9cc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
201a9d0: 9f c0 40 00 call %g1
201a9d4: 92 10 00 19 mov %i1, %o1
}
201a9d8: 81 c7 e0 08 ret
201a9dc: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
201a9e0: 7f ff d6 7e call 20103d8 <__errno>
201a9e4: b0 10 3f ff mov -1, %i0
201a9e8: 82 10 20 09 mov 9, %g1
201a9ec: c2 22 00 00 st %g1, [ %o0 ]
201a9f0: 81 c7 e0 08 ret
201a9f4: 81 e8 00 00 restore
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
201a9f8: 7f ff d6 78 call 20103d8 <__errno> <== NOT EXECUTED
201a9fc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201aa00: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED
201aa04: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201aa08: 81 c7 e0 08 ret <== NOT EXECUTED
201aa0c: 81 e8 00 00 restore <== NOT EXECUTED
0200340c <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) {
200340c: 03 00 80 89 sethi %hi(0x2022400), %g1
2003410: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20225f0 <disktab_size>
2003414: 80 a0 40 08 cmp %g1, %o0
2003418: 08 80 00 20 bleu 2003498 <get_disk_entry+0x8c> <== NEVER TAKEN
200341c: 03 00 80 89 sethi %hi(0x2022400), %g1
2003420: c2 00 61 f4 ld [ %g1 + 0x1f4 ], %g1 ! 20225f4 <disktab>
2003424: 80 a0 60 00 cmp %g1, 0
2003428: 02 80 00 1c be 2003498 <get_disk_entry+0x8c> <== NEVER TAKEN
200342c: 01 00 00 00 nop
rtems_disk_device_table *dtab = disktab + major;
2003430: 91 2a 20 03 sll %o0, 3, %o0
2003434: 84 00 40 08 add %g1, %o0, %g2
if (minor < dtab->size && dtab->minor != NULL) {
2003438: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200343c: 80 a0 80 09 cmp %g2, %o1
2003440: 08 80 00 16 bleu 2003498 <get_disk_entry+0x8c> <== NEVER TAKEN
2003444: 01 00 00 00 nop
2003448: c2 00 40 08 ld [ %g1 + %o0 ], %g1
200344c: 80 a0 60 00 cmp %g1, 0
2003450: 02 80 00 12 be 2003498 <get_disk_entry+0x8c> <== NEVER TAKEN
2003454: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
2003458: 80 a2 a0 01 cmp %o2, 1
200345c: 12 80 00 04 bne 200346c <get_disk_entry+0x60>
2003460: d0 00 40 09 ld [ %g1 + %o1 ], %o0
return dd;
}
}
return NULL;
}
2003464: 81 c3 e0 08 retl
2003468: 01 00 00 00 nop
rtems_disk_device_table *dtab = disktab + major;
if (minor < dtab->size && dtab->minor != NULL) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
200346c: 80 a2 20 00 cmp %o0, 0
2003470: 02 bf ff fd be 2003464 <get_disk_entry+0x58> <== NEVER TAKEN
2003474: 01 00 00 00 nop
if (!dd->deleted) {
2003478: c2 0a 20 40 ldub [ %o0 + 0x40 ], %g1
200347c: 80 a0 60 00 cmp %g1, 0
2003480: 12 80 00 06 bne 2003498 <get_disk_entry+0x8c>
2003484: 01 00 00 00 nop
++dd->uses;
2003488: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200348c: 82 00 60 01 inc %g1
2003490: 81 c3 e0 08 retl
2003494: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
return dd;
}
}
return NULL;
}
2003498: 81 c3 e0 08 retl
200349c: 90 10 20 00 clr %o0
02004b78 <get_sector.part.0>:
* NOTES:
* get_sector() operates with device via bdbuf library,
* and does not support devices with sector size other than 512 bytes
*/
static rtems_status_code
get_sector(int fd,
2004b78: 9d e3 bf a0 save %sp, -96, %sp
new_off = lseek(fd, off, SEEK_SET);
if (new_off != off) {
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
2004b7c: 40 00 05 c8 call 200629c <malloc>
2004b80: 90 10 22 04 mov 0x204, %o0
if (s == NULL)
{
return RTEMS_NO_MEMORY;
2004b84: 82 10 20 1a mov 0x1a, %g1
if (new_off != off) {
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
if (s == NULL)
2004b88: 80 a2 20 00 cmp %o0, 0
2004b8c: 02 80 00 0c be 2004bbc <get_sector.part.0+0x44> <== NEVER TAKEN
2004b90: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
2004b94: 90 10 00 18 mov %i0, %o0
2004b98: 92 07 60 04 add %i5, 4, %o1
2004b9c: 40 00 08 94 call 2006dec <read>
2004ba0: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
2004ba4: 80 a2 22 00 cmp %o0, 0x200
2004ba8: 02 80 00 07 be 2004bc4 <get_sector.part.0+0x4c> <== ALWAYS TAKEN
2004bac: 82 10 20 00 clr %g1
{
free(s);
2004bb0: 40 00 04 1e call 2005c28 <free> <== NOT EXECUTED
2004bb4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
2004bb8: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
s->sector_num = sector_num;
*sector = s;
return RTEMS_SUCCESSFUL;
}
2004bbc: 81 c7 e0 08 ret <== NOT EXECUTED
2004bc0: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
{
free(s);
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
2004bc4: f2 27 40 00 st %i1, [ %i5 ]
*sector = s;
2004bc8: fa 26 80 00 st %i5, [ %i2 ]
return RTEMS_SUCCESSFUL;
}
2004bcc: 81 c7 e0 08 ret
2004bd0: 91 e8 00 01 restore %g0, %g1, %o0
020321dc <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
20321dc: 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 );
20321e0: 03 00 80 e1 sethi %hi(0x2038400), %g1
20321e4: c2 00 60 bc ld [ %g1 + 0xbc ], %g1 ! 20384bc <rtems_libio_number_iops>
20321e8: 80 a6 00 01 cmp %i0, %g1
20321ec: 1a 80 00 08 bcc 203220c <getdents+0x30> <== NEVER TAKEN
20321f0: ba 10 20 00 clr %i5
20321f4: 03 00 81 24 sethi %hi(0x2049000), %g1
20321f8: fa 00 60 68 ld [ %g1 + 0x68 ], %i5 ! 2049068 <rtems_libio_iops>
20321fc: 83 2e 20 03 sll %i0, 3, %g1
2032200: b1 2e 20 06 sll %i0, 6, %i0
2032204: b0 26 00 01 sub %i0, %g1, %i0
2032208: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
203220c: 7f ff 61 b7 call 200a8e8 <rtems_filesystem_node_type>
2032210: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
2032214: 80 a2 20 00 cmp %o0, 0
2032218: 12 80 00 09 bne 203223c <getdents+0x60>
203221c: 90 10 00 1d mov %i5, %o0
/*
* 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 );
2032220: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
2032224: c2 00 60 08 ld [ %g1 + 8 ], %g1
2032228: 92 10 00 19 mov %i1, %o1
203222c: 9f c0 40 00 call %g1
2032230: 94 10 00 1a mov %i2, %o2
}
2032234: 81 c7 e0 08 ret
2032238: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
203223c: 7f ff c4 0b call 2023268 <__errno>
2032240: b0 10 3f ff mov -1, %i0
2032244: 82 10 20 14 mov 0x14, %g1
2032248: c2 22 00 00 st %g1, [ %o0 ]
203224c: 81 c7 e0 08 ret
2032250: 81 e8 00 00 restore
0200f720 <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
200f720: 9d e3 be 88 save %sp, -376, %sp
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
200f724: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
200f728: c4 02 20 0c ld [ %o0 + 0xc ], %g2
200f72c: c2 00 80 00 ld [ %g2 ], %g1
200f730: 9f c0 40 00 call %g1
200f734: 01 00 00 00 nop
int last_entry;
struct dirent tmp_dirent;
rtems_filesystem_instance_lock( &iop->pathinfo );
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
200f738: e4 06 20 1c ld [ %i0 + 0x1c ], %l2
the_chain = &the_jnode->info.directory.Entries;
/* Move to the first of the desired directory entries */
bytes_transferred = 0;
first_entry = iop->offset;
200f73c: e0 06 20 0c ld [ %i0 + 0xc ], %l0
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry
+ (count / sizeof( struct dirent )) * sizeof( struct dirent );
200f740: 90 10 00 1a mov %i2, %o0
200f744: 40 00 26 a2 call 20191cc <.udiv>
200f748: 92 10 21 18 mov 0x118, %o1
200f74c: 83 2a 20 03 sll %o0, 3, %g1
200f750: 91 2a 20 05 sll %o0, 5, %o0
200f754: 82 00 40 08 add %g1, %o0, %g1
200f758: a3 28 60 03 sll %g1, 3, %l1
200f75c: a2 24 40 01 sub %l1, %g1, %l1
200f760: a2 04 40 10 add %l1, %l0, %l1
/* The directory was not empty so try to move to the desired entry in chain*/
for (
200f764: 80 a4 60 00 cmp %l1, 0
200f768: 04 80 00 34 ble 200f838 <imfs_dir_read+0x118> <== NEVER TAKEN
200f76c: f4 04 a0 50 ld [ %l2 + 0x50 ], %i2
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 ));
200f770: a4 04 a0 54 add %l2, 0x54, %l2
current_entry = 0,
the_node = rtems_chain_first( the_chain );
current_entry < last_entry
&& !rtems_chain_is_tail( the_chain, the_node );
200f774: 80 a6 80 12 cmp %i2, %l2
200f778: 02 80 00 29 be 200f81c <imfs_dir_read+0xfc>
200f77c: a6 10 20 00 clr %l3
200f780: b6 10 20 00 clr %i3
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
200f784: 10 80 00 08 b 200f7a4 <imfs_dir_read+0x84>
200f788: a8 10 21 18 mov 0x118, %l4
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry
+ (count / sizeof( struct dirent )) * sizeof( struct dirent );
/* The directory was not empty so try to move to the desired entry in chain*/
for (
200f78c: 80 a4 40 1b cmp %l1, %i3
200f790: 04 80 00 23 ble 200f81c <imfs_dir_read+0xfc> <== NEVER TAKEN
200f794: f4 06 80 00 ld [ %i2 ], %i2
current_entry = 0,
the_node = rtems_chain_first( the_chain );
current_entry < last_entry
&& !rtems_chain_is_tail( the_chain, the_node );
200f798: 80 a6 80 12 cmp %i2, %l2
200f79c: 22 80 00 21 be,a 200f820 <imfs_dir_read+0x100>
200f7a0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
200f7a4: 80 a4 00 1b cmp %l0, %i3
200f7a8: 34 bf ff f9 bg,a 200f78c <imfs_dir_read+0x6c>
200f7ac: b6 06 e1 18 add %i3, 0x118, %i3
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
200f7b0: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
200f7b4: 85 3e e0 1f sra %i3, 0x1f, %g2
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
200f7b8: ba 06 a0 0c add %i2, 0xc, %i5
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
200f7bc: c4 27 be f0 st %g2, [ %fp + -272 ]
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
200f7c0: c2 27 be e8 st %g1, [ %fp + -280 ]
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
200f7c4: f6 27 be f4 st %i3, [ %fp + -268 ]
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
200f7c8: 90 10 00 1d mov %i5, %o0
200f7cc: 40 00 08 68 call 201196c <strlen>
200f7d0: e8 37 be f8 sth %l4, [ %fp + -264 ]
strcpy( tmp_dirent.d_name, the_jnode->name );
200f7d4: 92 10 00 1d mov %i5, %o1
200f7d8: 94 02 20 01 add %o0, 1, %o2
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
200f7dc: d0 37 be fa sth %o0, [ %fp + -262 ]
strcpy( tmp_dirent.d_name, the_jnode->name );
200f7e0: 40 00 05 4f call 2010d1c <memcpy>
200f7e4: 90 07 be fc add %fp, -260, %o0
memcpy(
200f7e8: 90 06 40 13 add %i1, %l3, %o0
200f7ec: 92 07 be e8 add %fp, -280, %o1
200f7f0: 40 00 05 4b call 2010d1c <memcpy>
200f7f4: 94 10 21 18 mov 0x118, %o2
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset += sizeof( struct dirent );
200f7f8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
#include "imfs.h"
#include <string.h>
#include <dirent.h>
ssize_t imfs_dir_read(
200f7fc: b6 06 e1 18 add %i3, 0x118, %i3
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset += sizeof( struct dirent );
200f800: ba 80 e1 18 addcc %g3, 0x118, %i5
200f804: b8 40 a0 00 addx %g2, 0, %i4
200f808: f8 3e 20 08 std %i4, [ %i0 + 8 ]
bytes_transferred += sizeof( struct dirent );
200f80c: a6 04 e1 18 add %l3, 0x118, %l3
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry
+ (count / sizeof( struct dirent )) * sizeof( struct dirent );
/* The directory was not empty so try to move to the desired entry in chain*/
for (
200f810: 80 a4 40 1b cmp %l1, %i3
200f814: 14 bf ff e1 bg 200f798 <imfs_dir_read+0x78> <== NEVER TAKEN
200f818: f4 06 80 00 ld [ %i2 ], %i2
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
200f81c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
200f820: c2 02 20 0c ld [ %o0 + 0xc ], %g1
200f824: c2 00 60 04 ld [ %g1 + 4 ], %g1
200f828: 9f c0 40 00 call %g1
200f82c: b0 10 00 13 mov %l3, %i0
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
return bytes_transferred;
}
200f830: 81 c7 e0 08 ret
200f834: 81 e8 00 00 restore
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
/* Move to the first of the desired directory entries */
bytes_transferred = 0;
200f838: 10 bf ff f9 b 200f81c <imfs_dir_read+0xfc> <== NOT EXECUTED
200f83c: a6 10 20 00 clr %l3 <== NOT EXECUTED
02027cf4 <init_etc_passwd_group>:
/**
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
2027cf4: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
2027cf8: 03 00 81 9a sethi %hi(0x2066800), %g1
2027cfc: c4 48 63 e0 ldsb [ %g1 + 0x3e0 ], %g2 ! 2066be0 <etc_passwd_initted.7073>
2027d00: 80 a0 a0 00 cmp %g2, 0
2027d04: 02 80 00 04 be 2027d14 <init_etc_passwd_group+0x20>
2027d08: 84 10 20 01 mov 1, %g2
2027d0c: 81 c7 e0 08 ret
2027d10: 81 e8 00 00 restore
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
2027d14: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
2027d18: c4 28 63 e0 stb %g2, [ %g1 + 0x3e0 ]
mkdir("/etc", 0777);
2027d1c: 11 00 81 77 sethi %hi(0x205dc00), %o0
2027d20: 7f ff 6e df call 200389c <mkdir>
2027d24: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 205dfc8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x6f8>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
2027d28: 39 00 81 77 sethi %hi(0x205dc00), %i4
2027d2c: 3b 00 81 8a sethi %hi(0x2062800), %i5
2027d30: 90 17 23 d0 or %i4, 0x3d0, %o0
2027d34: 40 00 52 fd call 203c928 <fopen>
2027d38: 92 17 60 58 or %i5, 0x58, %o1
2027d3c: 80 a2 20 00 cmp %o0, 0
2027d40: 22 80 00 0d be,a 2027d74 <init_etc_passwd_group+0x80>
2027d44: 90 17 23 d0 or %i4, 0x3d0, %o0
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
2027d48: 40 00 50 9a call 203bfb0 <fclose>
2027d4c: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
2027d50: 39 00 81 78 sethi %hi(0x205e000), %i4
2027d54: 92 17 60 58 or %i5, 0x58, %o1
2027d58: 40 00 52 f4 call 203c928 <fopen>
2027d5c: 90 17 20 48 or %i4, 0x48, %o0
2027d60: 80 a2 20 00 cmp %o0, 0
2027d64: 22 80 00 11 be,a 2027da8 <init_etc_passwd_group+0xb4>
2027d68: 90 17 20 48 or %i4, 0x48, %o0
fclose(fp);
2027d6c: 40 00 50 91 call 203bfb0 <fclose>
2027d70: 91 e8 00 08 restore %g0, %o0, %o0
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
2027d74: 13 00 81 6f sethi %hi(0x205bc00), %o1
2027d78: 40 00 52 ec call 203c928 <fopen>
2027d7c: 92 12 63 90 or %o1, 0x390, %o1 ! 205bf90 <rtems_rtc_shell_usage+0x4e8>
2027d80: b8 92 20 00 orcc %o0, 0, %i4
2027d84: 02 bf ff f3 be 2027d50 <init_etc_passwd_group+0x5c> <== NEVER TAKEN
2027d88: 92 10 20 01 mov 1, %o1
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
2027d8c: 94 10 20 66 mov 0x66, %o2
2027d90: 96 10 00 1c mov %i4, %o3
2027d94: 11 00 81 77 sethi %hi(0x205dc00), %o0
2027d98: 40 00 57 b3 call 203dc64 <fwrite>
2027d9c: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 205dfe0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x710>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
2027da0: 10 bf ff ea b 2027d48 <init_etc_passwd_group+0x54>
2027da4: 90 10 00 1c mov %i4, %o0
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
2027da8: 13 00 81 6f sethi %hi(0x205bc00), %o1
2027dac: 40 00 52 df call 203c928 <fopen>
2027db0: 92 12 63 90 or %o1, 0x390, %o1 ! 205bf90 <rtems_rtc_shell_usage+0x4e8>
2027db4: b0 92 20 00 orcc %o0, 0, %i0
2027db8: 02 bf ff d5 be 2027d0c <init_etc_passwd_group+0x18> <== NEVER TAKEN
2027dbc: 92 10 20 01 mov 1, %o1
fprintf( fp, "root:x:0:root\n"
2027dc0: 11 00 81 78 sethi %hi(0x205e000), %o0
2027dc4: 94 10 20 2a mov 0x2a, %o2
2027dc8: 96 10 00 18 mov %i0, %o3
2027dcc: 40 00 57 a6 call 203dc64 <fwrite>
2027dd0: 90 12 20 58 or %o0, 0x58, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
2027dd4: 40 00 50 77 call 203bfb0 <fclose>
2027dd8: 81 e8 00 00 restore
020063d8 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
20063d8: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
20063dc: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
20063e0: 80 88 60 20 btst 0x20, %g1
20063e4: 32 80 00 02 bne,a 20063ec <iproc+0x14> <== NEVER TAKEN
20063e8: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
20063ec: 80 88 62 00 btst 0x200, %g1
20063f0: 02 80 00 0d be 2006424 <iproc+0x4c>
20063f4: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
20063f8: 05 00 80 76 sethi %hi(0x201d800), %g2
20063fc: c6 00 a1 a8 ld [ %g2 + 0x1a8 ], %g3 ! 201d9a8 <__ctype_ptr__>
2006400: 84 10 00 18 mov %i0, %g2
2006404: b0 00 c0 18 add %g3, %i0, %i0
2006408: c6 0e 20 01 ldub [ %i0 + 1 ], %g3
200640c: 86 08 e0 03 and %g3, 3, %g3
2006410: 80 a0 e0 01 cmp %g3, 1
2006414: 22 80 00 02 be,a 200641c <iproc+0x44>
2006418: 84 00 a0 20 add %g2, 0x20, %g2
200641c: b0 08 a0 ff and %g2, 0xff, %i0
if (c == '\r') {
2006420: 80 a6 20 0d cmp %i0, 0xd
2006424: 02 80 00 1d be 2006498 <iproc+0xc0>
2006428: 80 a6 20 0a cmp %i0, 0xa
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)) {
200642c: 02 80 00 44 be 200653c <iproc+0x164>
2006430: 80 a6 20 00 cmp %i0, 0
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
2006434: 32 80 00 1f bne,a 20064b0 <iproc+0xd8> <== ALWAYS TAKEN
2006438: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
200643c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
2006440: 05 00 80 76 sethi %hi(0x201d800), %g2
2006444: c4 00 a0 30 ld [ %g2 + 0x30 ], %g2 ! 201d830 <rtems_termios_cbufsize>
2006448: 84 00 bf ff add %g2, -1, %g2
200644c: 80 a0 40 02 cmp %g1, %g2
2006450: 1a 80 00 10 bcc 2006490 <iproc+0xb8> <== NEVER TAKEN
2006454: 01 00 00 00 nop
if (tty->termios.c_lflag & ECHO)
2006458: c4 06 60 3c ld [ %i1 + 0x3c ], %g2
200645c: 80 88 a0 08 btst 8, %g2
2006460: 12 80 00 3c bne 2006550 <iproc+0x178> <== ALWAYS TAKEN
2006464: 84 00 60 01 add %g1, 1, %g2
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
2006468: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
200646c: f0 28 c0 01 stb %i0, [ %g3 + %g1 ] <== NOT EXECUTED
2006470: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
}
return 0;
2006474: 81 c7 e0 08 ret <== NOT EXECUTED
2006478: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
200647c: 80 a0 60 00 cmp %g1, 0
2006480: 02 80 00 04 be 2006490 <iproc+0xb8>
2006484: 90 10 00 19 mov %i1, %o0
2006488: 7f ff ff 5f call 2006204 <erase.part.2>
200648c: 92 10 20 00 clr %o1
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
2006490: 81 c7 e0 08 ret
2006494: 91 e8 20 00 restore %g0, 0, %o0
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
2006498: 80 88 60 80 btst 0x80, %g1
200649c: 12 bf ff fd bne 2006490 <iproc+0xb8> <== NEVER TAKEN
20064a0: 80 88 61 00 btst 0x100, %g1
return 0;
if (tty->termios.c_iflag & ICRNL)
20064a4: 32 80 00 02 bne,a 20064ac <iproc+0xd4> <== ALWAYS TAKEN
20064a8: 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)) {
20064ac: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
20064b0: 80 88 60 02 btst 2, %g1
20064b4: 22 bf ff e3 be,a 2006440 <iproc+0x68>
20064b8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
if (c == tty->termios.c_cc[VERASE]) {
20064bc: c4 0e 60 43 ldub [ %i1 + 0x43 ], %g2
20064c0: 80 a0 80 18 cmp %g2, %i0
20064c4: 22 bf ff ee be,a 200647c <iproc+0xa4>
20064c8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
20064cc: c4 0e 60 44 ldub [ %i1 + 0x44 ], %g2
20064d0: 80 a0 80 18 cmp %g2, %i0
20064d4: 22 80 00 2d be,a 2006588 <iproc+0x1b0>
20064d8: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
20064dc: c4 0e 60 45 ldub [ %i1 + 0x45 ], %g2
20064e0: 80 a0 80 18 cmp %g2, %i0
20064e4: 02 80 00 42 be 20065ec <iproc+0x214> <== NEVER TAKEN
20064e8: 80 a6 20 0a cmp %i0, 0xa
return 1;
} else if (c == '\n') {
20064ec: 02 80 00 33 be 20065b8 <iproc+0x1e0>
20064f0: 80 88 60 48 btst 0x48, %g1
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
20064f4: c4 0e 60 4c ldub [ %i1 + 0x4c ], %g2
20064f8: 80 a0 80 18 cmp %g2, %i0
20064fc: 02 80 00 07 be 2006518 <iproc+0x140> <== NEVER TAKEN
2006500: 80 88 60 08 btst 8, %g1
2006504: c4 0e 60 51 ldub [ %i1 + 0x51 ], %g2
2006508: 80 a0 80 18 cmp %g2, %i0
200650c: 32 bf ff cd bne,a 2006440 <iproc+0x68> <== ALWAYS TAKEN
2006510: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
2006514: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
2006518: 12 80 00 18 bne 2006578 <iproc+0x1a0> <== NOT EXECUTED
200651c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
2006520: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
2006524: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
2006528: 84 00 60 01 add %g1, 1, %g2 <== NOT EXECUTED
200652c: f0 28 c0 01 stb %i0, [ %g3 + %g1 ] <== NOT EXECUTED
2006530: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
return 1;
2006534: 81 c7 e0 08 ret <== NOT EXECUTED
2006538: 91 e8 20 01 restore %g0, 1, %o0 <== 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)) {
200653c: 80 88 60 40 btst 0x40, %g1
2006540: 32 bf ff db bne,a 20064ac <iproc+0xd4> <== NEVER TAKEN
2006544: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
2006548: 10 bf ff da b 20064b0 <iproc+0xd8>
200654c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
2006550: 90 10 00 18 mov %i0, %o0
2006554: 7f ff ff 0b call 2006180 <echo>
2006558: 92 10 00 19 mov %i1, %o1
200655c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
tty->cbuf[tty->ccount++] = c;
2006560: c6 06 60 1c ld [ %i1 + 0x1c ], %g3
2006564: 84 00 60 01 add %g1, 1, %g2
2006568: f0 28 c0 01 stb %i0, [ %g3 + %g1 ]
200656c: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
}
return 0;
2006570: 81 c7 e0 08 ret
2006574: 91 e8 20 00 restore %g0, 0, %o0
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
2006578: 7f ff ff 02 call 2006180 <echo> <== NOT EXECUTED
200657c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
2006580: 10 bf ff e9 b 2006524 <iproc+0x14c> <== NOT EXECUTED
2006584: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
2006588: 80 a0 a0 00 cmp %g2, 0
200658c: 02 bf ff c1 be 2006490 <iproc+0xb8> <== NEVER TAKEN
2006590: 80 88 60 08 btst 8, %g1
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
2006594: 02 80 00 18 be 20065f4 <iproc+0x21c> <== NEVER TAKEN
2006598: 80 88 60 10 btst 0x10, %g1
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
200659c: 02 80 00 19 be 2006600 <iproc+0x228> <== NEVER TAKEN
20065a0: 90 10 00 19 mov %i1, %o0
20065a4: 92 10 20 01 mov 1, %o1
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
20065a8: 7f ff ff 17 call 2006204 <erase.part.2>
20065ac: b0 10 20 00 clr %i0
20065b0: 81 c7 e0 08 ret
20065b4: 81 e8 00 00 restore
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
20065b8: 22 80 00 06 be,a 20065d0 <iproc+0x1f8> <== NEVER TAKEN
20065bc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
20065c0: 90 10 20 0a mov 0xa, %o0
20065c4: 7f ff fe ef call 2006180 <echo>
20065c8: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
20065cc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20065d0: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
20065d4: 86 10 20 0a mov 0xa, %g3
20065d8: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
20065dc: 82 00 60 01 inc %g1
20065e0: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
return 1;
20065e4: 81 c7 e0 08 ret
20065e8: 91 e8 20 01 restore %g0, 1, %o0
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
20065ec: 81 c7 e0 08 ret <== NOT EXECUTED
20065f0: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
20065f4: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
20065f8: 81 c7 e0 08 ret <== NOT EXECUTED
20065fc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
2006600: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
2006604: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2006608: 7f ff fe de call 2006180 <echo> <== NOT EXECUTED
200660c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
2006610: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
2006614: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006618: 02 bf ff 9e be 2006490 <iproc+0xb8> <== NOT EXECUTED
200661c: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
echo ('\n', tty);
2006620: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2006624: 7f ff fe d7 call 2006180 <echo> <== NOT EXECUTED
2006628: b0 10 20 00 clr %i0 <== NOT EXECUTED
200662c: 81 c7 e0 08 ret <== NOT EXECUTED
2006630: 81 e8 00 00 restore <== NOT EXECUTED
0201ac94 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
201ac94: 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() )
201ac98: 7f ff ff 63 call 201aa24 <getpid>
201ac9c: 01 00 00 00 nop
201aca0: 80 a2 00 18 cmp %o0, %i0
201aca4: 12 80 00 af bne 201af60 <killinfo+0x2cc>
201aca8: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
201acac: 02 80 00 b3 be 201af78 <killinfo+0x2e4>
201acb0: 82 06 7f ff add %i1, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201acb4: 80 a0 60 1f cmp %g1, 0x1f
201acb8: 18 80 00 b0 bgu 201af78 <killinfo+0x2e4>
201acbc: a1 2e 60 02 sll %i1, 2, %l0
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
201acc0: 31 00 80 7a sethi %hi(0x201e800), %i0
201acc4: a3 2e 60 04 sll %i1, 4, %l1
201acc8: b0 16 20 a0 or %i0, 0xa0, %i0
201accc: 84 24 40 10 sub %l1, %l0, %g2
201acd0: 84 06 00 02 add %i0, %g2, %g2
201acd4: c4 00 a0 08 ld [ %g2 + 8 ], %g2
201acd8: 80 a0 a0 01 cmp %g2, 1
201acdc: 02 80 00 9f be 201af58 <killinfo+0x2c4>
201ace0: 80 a6 60 04 cmp %i1, 4
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
201ace4: 02 80 00 41 be 201ade8 <killinfo+0x154>
201ace8: 80 a6 60 08 cmp %i1, 8
201acec: 02 80 00 3f be 201ade8 <killinfo+0x154>
201acf0: 80 a6 60 0b cmp %i1, 0xb
201acf4: 02 80 00 3d be 201ade8 <killinfo+0x154>
201acf8: ba 10 20 01 mov 1, %i5
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
201acfc: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
201ad00: fa 27 bf f8 st %i5, [ %fp + -8 ]
if ( !value ) {
201ad04: 80 a6 a0 00 cmp %i2, 0
201ad08: 02 80 00 3e be 201ae00 <killinfo+0x16c>
201ad0c: bb 2f 40 01 sll %i5, %g1, %i5
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
201ad10: c2 06 80 00 ld [ %i2 ], %g1
201ad14: 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)
{
uint32_t level = _Thread_Dispatch_disable_level;
201ad18: 03 00 80 78 sethi %hi(0x201e000), %g1
201ad1c: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 201e320 <_Thread_Dispatch_disable_level>
++level;
201ad20: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
201ad24: c4 20 63 20 st %g2, [ %g1 + 0x320 ]
*/
void _POSIX_signals_Manager_Initialization(void);
static inline void _POSIX_signals_Add_post_switch_extension(void)
{
_API_extensions_Add_post_switch( &_POSIX_signals_Post_switch );
201ad28: 11 00 80 76 sethi %hi(0x201d800), %o0
201ad2c: 7f ff b6 08 call 200854c <_API_extensions_Add_post_switch>
201ad30: 90 12 20 f4 or %o0, 0xf4, %o0 ! 201d8f4 <_POSIX_signals_Post_switch>
/*
* 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;
201ad34: 03 00 80 7a sethi %hi(0x201e800), %g1
201ad38: d0 00 60 50 ld [ %g1 + 0x50 ], %o0 ! 201e850 <_Per_CPU_Information+0x10>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
201ad3c: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
201ad40: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1
201ad44: 80 af 40 01 andncc %i5, %g1, %g0
201ad48: 12 80 00 17 bne 201ada4 <killinfo+0x110>
201ad4c: 09 00 80 7a sethi %hi(0x201e800), %g4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
201ad50: c2 01 22 2c ld [ %g4 + 0x22c ], %g1 ! 201ea2c <_POSIX_signals_Wait_queue>
201ad54: 88 11 22 2c or %g4, 0x22c, %g4
/* 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 );
201ad58: 88 01 20 04 add %g4, 4, %g4
201ad5c: 80 a0 40 04 cmp %g1, %g4
201ad60: 32 80 00 0d bne,a 201ad94 <killinfo+0x100>
201ad64: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201ad68: 10 80 00 28 b 201ae08 <killinfo+0x174>
201ad6c: 03 00 80 75 sethi %hi(0x201d400), %g1
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
201ad70: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2
201ad74: 80 af 40 02 andncc %i5, %g2, %g0
201ad78: 12 80 00 0b bne 201ada4 <killinfo+0x110>
201ad7c: 90 10 00 01 mov %g1, %o0
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
201ad80: c2 00 40 00 ld [ %g1 ], %g1
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
201ad84: 80 a0 40 04 cmp %g1, %g4
201ad88: 22 80 00 20 be,a 201ae08 <killinfo+0x174> <== ALWAYS TAKEN
201ad8c: 03 00 80 75 sethi %hi(0x201d400), %g1
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
201ad90: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201d430 <__mprec_tens><== NOT EXECUTED
201ad94: 80 8f 40 02 btst %i5, %g2
201ad98: 02 bf ff f6 be 201ad70 <killinfo+0xdc>
201ad9c: c6 00 61 5c ld [ %g1 + 0x15c ], %g3
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 ) {
201ada0: 90 10 00 01 mov %g1, %o0
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
201ada4: 92 10 00 19 mov %i1, %o1
201ada8: 40 00 00 8b call 201afd4 <_POSIX_signals_Unblock_thread>
201adac: 94 07 bf f4 add %fp, -12, %o2
201adb0: 80 8a 20 ff btst 0xff, %o0
201adb4: 12 80 00 09 bne 201add8 <killinfo+0x144>
201adb8: 01 00 00 00 nop
/*
* 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 );
201adbc: 40 00 00 7d call 201afb0 <_POSIX_signals_Set_process_signals>
201adc0: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
201adc4: a0 24 40 10 sub %l1, %l0, %l0
201adc8: c2 06 00 10 ld [ %i0 + %l0 ], %g1
201adcc: 80 a0 60 02 cmp %g1, 2
201add0: 02 80 00 4f be 201af0c <killinfo+0x278>
201add4: 11 00 80 7a sethi %hi(0x201e800), %o0
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
_Thread_Enable_dispatch();
201add8: 7f ff be 68 call 200a778 <_Thread_Enable_dispatch>
201addc: b0 10 20 00 clr %i0
201ade0: 81 c7 e0 08 ret
201ade4: 81 e8 00 00 restore
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
return pthread_kill( pthread_self(), sig );
201ade8: 40 00 01 13 call 201b234 <pthread_self>
201adec: 01 00 00 00 nop
201adf0: 40 00 00 d2 call 201b138 <pthread_kill>
201adf4: 92 10 00 19 mov %i1, %o1
201adf8: 81 c7 e0 08 ret
201adfc: 91 e8 00 08 restore %g0, %o0, %o0
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
201ae00: 10 bf ff c6 b 201ad18 <killinfo+0x84>
201ae04: c0 27 bf fc clr [ %fp + -4 ]
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201ae08: f8 08 62 7c ldub [ %g1 + 0x27c ], %i4
201ae0c: 1b 00 80 78 sethi %hi(0x201e000), %o5
201ae10: b8 07 20 01 inc %i4
201ae14: 9a 13 62 8c or %o5, 0x28c, %o5
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
201ae18: 90 10 20 00 clr %o0
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
201ae1c: 98 03 60 08 add %o5, 8, %o4
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
201ae20: 17 04 00 00 sethi %hi(0x10000000), %o3
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 ] )
201ae24: c2 03 40 00 ld [ %o5 ], %g1
201ae28: 80 a0 60 00 cmp %g1, 0
201ae2c: 22 80 00 31 be,a 201aef0 <killinfo+0x25c> <== NEVER TAKEN
201ae30: 9a 03 60 04 add %o5, 4, %o5 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
201ae34: c2 00 60 04 ld [ %g1 + 4 ], %g1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
201ae38: f6 10 60 10 lduh [ %g1 + 0x10 ], %i3
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201ae3c: 80 a6 e0 00 cmp %i3, 0
201ae40: 02 80 00 2b be 201aeec <killinfo+0x258>
201ae44: f4 00 60 1c ld [ %g1 + 0x1c ], %i2
201ae48: 84 10 20 01 mov 1, %g2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
201ae4c: 87 28 a0 02 sll %g2, 2, %g3
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
the_thread = (Thread_Control *) object_table[ index ];
201ae50: c6 06 80 03 ld [ %i2 + %g3 ], %g3
if ( !the_thread )
201ae54: 80 a0 e0 00 cmp %g3, 0
201ae58: 22 80 00 22 be,a 201aee0 <killinfo+0x24c>
201ae5c: 84 00 a0 01 inc %g2
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
201ae60: c8 00 e0 14 ld [ %g3 + 0x14 ], %g4
201ae64: 80 a1 00 1c cmp %g4, %i4
201ae68: 38 80 00 1e bgu,a 201aee0 <killinfo+0x24c>
201ae6c: 84 00 a0 01 inc %g2
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
201ae70: de 00 e1 5c ld [ %g3 + 0x15c ], %o7
201ae74: de 03 e0 d0 ld [ %o7 + 0xd0 ], %o7
201ae78: 80 af 40 0f andncc %i5, %o7, %g0
201ae7c: 22 80 00 19 be,a 201aee0 <killinfo+0x24c>
201ae80: 84 00 a0 01 inc %g2
*
* 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 ) {
201ae84: 80 a1 00 1c cmp %g4, %i4
201ae88: 2a 80 00 14 bcs,a 201aed8 <killinfo+0x244>
201ae8c: b8 10 00 04 mov %g4, %i4
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
201ae90: 80 a2 20 00 cmp %o0, 0
201ae94: 22 80 00 13 be,a 201aee0 <killinfo+0x24c> <== NEVER TAKEN
201ae98: 84 00 a0 01 inc %g2 <== NOT EXECUTED
201ae9c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
201aea0: 80 a0 60 00 cmp %g1, 0
201aea4: 22 80 00 0f be,a 201aee0 <killinfo+0x24c> <== NEVER TAKEN
201aea8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201aeac: de 00 e0 10 ld [ %g3 + 0x10 ], %o7
201aeb0: 80 a3 e0 00 cmp %o7, 0
201aeb4: 22 80 00 09 be,a 201aed8 <killinfo+0x244>
201aeb8: b8 10 00 04 mov %g4, %i4
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
201aebc: 80 88 40 0b btst %g1, %o3
201aec0: 32 80 00 08 bne,a 201aee0 <killinfo+0x24c>
201aec4: 84 00 a0 01 inc %g2
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
201aec8: 80 8b c0 0b btst %o7, %o3
201aecc: 22 80 00 05 be,a 201aee0 <killinfo+0x24c>
201aed0: 84 00 a0 01 inc %g2
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201aed4: b8 10 00 04 mov %g4, %i4
201aed8: 90 10 00 03 mov %g3, %o0
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201aedc: 84 00 a0 01 inc %g2
201aee0: 80 a6 c0 02 cmp %i3, %g2
201aee4: 1a bf ff db bcc 201ae50 <killinfo+0x1bc>
201aee8: 87 28 a0 02 sll %g2, 2, %g3
201aeec: 9a 03 60 04 add %o5, 4, %o5
* + 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++) {
201aef0: 80 a3 40 0c cmp %o5, %o4
201aef4: 32 bf ff cd bne,a 201ae28 <killinfo+0x194>
201aef8: c2 03 40 00 ld [ %o5 ], %g1
}
}
}
}
if ( interested ) {
201aefc: 80 a2 20 00 cmp %o0, 0
201af00: 12 bf ff aa bne 201ada8 <killinfo+0x114>
201af04: 92 10 00 19 mov %i1, %o1
201af08: 30 bf ff ad b,a 201adbc <killinfo+0x128>
*/
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
201af0c: 7f ff b5 f5 call 20086e0 <_Chain_Get>
201af10: 90 12 22 20 or %o0, 0x220, %o0
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
201af14: 92 92 20 00 orcc %o0, 0, %o1
201af18: 02 80 00 1e be 201af90 <killinfo+0x2fc>
201af1c: c2 07 bf f4 ld [ %fp + -12 ], %g1
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201af20: 11 00 80 7a sethi %hi(0x201e800), %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
201af24: c2 22 60 08 st %g1, [ %o1 + 8 ]
201af28: c2 07 bf f8 ld [ %fp + -8 ], %g1
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201af2c: 90 12 22 98 or %o0, 0x298, %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
201af30: c2 22 60 0c st %g1, [ %o1 + 0xc ]
201af34: c2 07 bf fc ld [ %fp + -4 ], %g1
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201af38: 90 02 00 10 add %o0, %l0, %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
201af3c: c2 22 60 10 st %g1, [ %o1 + 0x10 ]
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201af40: 7f ff b5 dd call 20086b4 <_Chain_Append>
201af44: b0 10 20 00 clr %i0
/*
* 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 ) ) {
_Thread_Enable_dispatch();
201af48: 7f ff be 0c call 200a778 <_Thread_Enable_dispatch>
201af4c: 01 00 00 00 nop
201af50: 81 c7 e0 08 ret
201af54: 81 e8 00 00 restore
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
201af58: 81 c7 e0 08 ret
201af5c: 91 e8 20 00 restore %g0, 0, %o0
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
201af60: 7f ff d5 1e call 20103d8 <__errno>
201af64: b0 10 3f ff mov -1, %i0
201af68: 82 10 20 03 mov 3, %g1
201af6c: c2 22 00 00 st %g1, [ %o0 ]
201af70: 81 c7 e0 08 ret
201af74: 81 e8 00 00 restore
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
201af78: 7f ff d5 18 call 20103d8 <__errno>
201af7c: b0 10 3f ff mov -1, %i0
201af80: 82 10 20 16 mov 0x16, %g1
201af84: c2 22 00 00 st %g1, [ %o0 ]
201af88: 81 c7 e0 08 ret
201af8c: 81 e8 00 00 restore
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
201af90: 7f ff bd fa call 200a778 <_Thread_Enable_dispatch>
201af94: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EAGAIN );
201af98: 7f ff d5 10 call 20103d8 <__errno>
201af9c: 01 00 00 00 nop
201afa0: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
201afa4: c2 22 00 00 st %g1, [ %o0 ]
201afa8: 81 c7 e0 08 ret
201afac: 81 e8 00 00 restore
02003f3c <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
2003f3c: 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()))
2003f40: 03 00 80 7a sethi %hi(0x201e800), %g1
2003f44: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 201e838 <_System_state_Current>
2003f48: 80 a0 60 03 cmp %g1, 3
2003f4c: 02 80 00 04 be 2003f5c <libc_wrapup+0x20> <== ALWAYS TAKEN
2003f50: 3b 00 80 76 sethi %hi(0x201d800), %i5
2003f54: 81 c7 e0 08 ret <== NOT EXECUTED
2003f58: 81 e8 00 00 restore <== NOT EXECUTED
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
2003f5c: 05 00 80 72 sethi %hi(0x201c800), %g2
2003f60: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
2003f64: f8 00 a3 f8 ld [ %g2 + 0x3f8 ], %i4
2003f68: 80 a0 40 1c cmp %g1, %i4
2003f6c: 02 80 00 05 be 2003f80 <libc_wrapup+0x44>
2003f70: 01 00 00 00 nop
_wrapup_reent(_global_impure_ptr);
2003f74: 40 00 34 48 call 2011094 <_wrapup_reent>
2003f78: 90 10 00 1c mov %i4, %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;
2003f7c: f8 27 61 b0 st %i4, [ %i5 + 0x1b0 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
2003f80: 40 00 31 68 call 2010520 <fclose>
2003f84: d0 07 20 04 ld [ %i4 + 4 ], %o0
fclose (stdout);
2003f88: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
2003f8c: 40 00 31 65 call 2010520 <fclose>
2003f90: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
2003f94: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
2003f98: f0 00 60 0c ld [ %g1 + 0xc ], %i0
2003f9c: 40 00 31 61 call 2010520 <fclose>
2003fa0: 81 e8 00 00 restore
020039d8 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
20039d8: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
20039dc: 03 00 80 78 sethi %hi(0x201e000), %g1
20039e0: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 201e1a0 <rtems_malloc_statistics>
20039e4: c4 00 60 04 ld [ %g1 + 4 ], %g2
20039e8: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
20039ec: 7f ff ff b8 call 20038cc <malloc_deferred_frees_process>
20039f0: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
20039f4: 80 a6 20 00 cmp %i0, 0
20039f8: 02 80 00 25 be 2003a8c <malloc+0xb4>
20039fc: 03 00 80 7a sethi %hi(0x201e800), %g1
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2003a00: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 201e838 <_System_state_Current>
2003a04: 80 a0 60 03 cmp %g1, 3
2003a08: 02 80 00 1c be 2003a78 <malloc+0xa0>
2003a0c: 39 00 80 75 sethi %hi(0x201d400), %i4
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
2003a10: d0 07 23 00 ld [ %i4 + 0x300 ], %o0 ! 201d700 <RTEMS_Malloc_Heap>
2003a14: 92 10 00 18 mov %i0, %o1
2003a18: 94 10 20 00 clr %o2
2003a1c: 40 00 18 07 call 2009a38 <_Protected_heap_Allocate_aligned_with_boundary>
2003a20: 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 ) {
2003a24: ba 92 20 00 orcc %o0, 0, %i5
2003a28: 02 80 00 1c be 2003a98 <malloc+0xc0>
2003a2c: d0 07 23 00 ld [ %i4 + 0x300 ], %o0
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
2003a30: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003a34: c2 00 62 dc ld [ %g1 + 0x2dc ], %g1 ! 201dedc <rtems_malloc_dirty_helper>
2003a38: 80 a0 60 00 cmp %g1, 0
2003a3c: 02 80 00 04 be 2003a4c <malloc+0x74>
2003a40: 90 10 00 1d mov %i5, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
2003a44: 9f c0 40 00 call %g1
2003a48: 92 10 00 18 mov %i0, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
2003a4c: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003a50: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 ! 201dee0 <rtems_malloc_statistics_helpers>
2003a54: 80 a0 60 00 cmp %g1, 0
2003a58: 22 80 00 06 be,a 2003a70 <malloc+0x98>
2003a5c: b0 10 00 1d mov %i5, %i0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
2003a60: c2 00 60 04 ld [ %g1 + 4 ], %g1
2003a64: 9f c0 40 00 call %g1
2003a68: 90 10 00 1d mov %i5, %o0
return return_this;
}
2003a6c: b0 10 00 1d mov %i5, %i0
2003a70: 81 c7 e0 08 ret
2003a74: 81 e8 00 00 restore
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
2003a78: 7f ff ff 88 call 2003898 <malloc_is_system_state_OK>
2003a7c: 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()) &&
2003a80: 80 8a 20 ff btst 0xff, %o0
2003a84: 12 bf ff e3 bne 2003a10 <malloc+0x38> <== ALWAYS TAKEN
2003a88: 01 00 00 00 nop
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
2003a8c: ba 10 20 00 clr %i5 ! 0 <PROM_START>
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
2003a90: 81 c7 e0 08 ret
2003a94: 91 e8 00 1d restore %g0, %i5, %o0
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
2003a98: 03 00 80 6d sethi %hi(0x201b400), %g1
2003a9c: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 201b510 <rtems_malloc_extend_handler>
2003aa0: 9f c0 40 00 call %g1
2003aa4: 92 10 00 18 mov %i0, %o1
if ( !return_this ) {
2003aa8: ba 92 20 00 orcc %o0, 0, %i5
2003aac: 12 bf ff e2 bne 2003a34 <malloc+0x5c> <== NEVER TAKEN
2003ab0: 03 00 80 77 sethi %hi(0x201dc00), %g1
errno = ENOMEM;
2003ab4: 40 00 32 49 call 20103d8 <__errno>
2003ab8: b0 10 00 1d mov %i5, %i0
2003abc: 82 10 20 0c mov 0xc, %g1
2003ac0: c2 22 00 00 st %g1, [ %o0 ]
2003ac4: 81 c7 e0 08 ret
2003ac8: 81 e8 00 00 restore
0200e840 <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
200e840: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
200e844: 03 00 80 77 sethi %hi(0x201dc00), %g1
200e848: d2 00 63 08 ld [ %g1 + 0x308 ], %o1 ! 201df08 <imfs_memfile_bytes_per_block>
200e84c: 7f ff d2 da call 20033b4 <calloc>
200e850: 90 10 20 01 mov 1, %o0
if ( memory )
200e854: b0 92 20 00 orcc %o0, 0, %i0
200e858: 02 80 00 05 be 200e86c <memfile_alloc_block+0x2c> <== NEVER TAKEN
200e85c: 03 00 80 78 sethi %hi(0x201e000), %g1
memfile_blocks_allocated++;
200e860: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 ! 201e01c <memfile_blocks_allocated>
200e864: 84 00 a0 01 inc %g2
200e868: c4 20 60 1c st %g2, [ %g1 + 0x1c ]
return memory;
}
200e86c: 81 c7 e0 08 ret
200e870: 81 e8 00 00 restore
0200edb8 <memfile_free_blocks_in_table>:
*/
static void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
200edb8: 9d e3 bf a0 save %sp, -96, %sp
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
200edbc: 80 a6 60 00 cmp %i1, 0
200edc0: 04 80 00 0f ble 200edfc <memfile_free_blocks_in_table+0x44><== NEVER TAKEN
200edc4: d0 06 00 00 ld [ %i0 ], %o0
200edc8: ba 10 00 08 mov %o0, %i5
200edcc: b8 10 20 00 clr %i4
if ( b[i] ) {
200edd0: d0 07 40 00 ld [ %i5 ], %o0
200edd4: 80 a2 20 00 cmp %o0, 0
200edd8: 02 80 00 05 be 200edec <memfile_free_blocks_in_table+0x34>
200eddc: b8 07 20 01 inc %i4
memfile_free_block( b[i] );
200ede0: 7f ff ff ed call 200ed94 <memfile_free_block>
200ede4: 01 00 00 00 nop
b[i] = 0;
200ede8: c0 27 40 00 clr [ %i5 ]
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
200edec: 80 a7 00 19 cmp %i4, %i1
200edf0: 12 bf ff f8 bne 200edd0 <memfile_free_blocks_in_table+0x18>
200edf4: ba 07 60 04 add %i5, 4, %i5
200edf8: d0 06 00 00 ld [ %i0 ], %o0
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
200edfc: 7f ff ff e6 call 200ed94 <memfile_free_block>
200ee00: 01 00 00 00 nop
*block_table = 0;
200ee04: c0 26 00 00 clr [ %i0 ]
200ee08: 81 c7 e0 08 ret
200ee0c: 81 e8 00 00 restore
0200f44c <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
200f44c: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
200f450: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
200f454: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
200f458: 80 a0 40 19 cmp %g1, %i1
200f45c: 06 80 00 11 bl 200f4a0 <memfile_ftruncate+0x54> <== NEVER TAKEN
200f460: 90 10 00 1d mov %i5, %o0
200f464: 22 80 00 0b be,a 200f490 <memfile_ftruncate+0x44> <== ALWAYS TAKEN
200f468: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
/*
* 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;
200f46c: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
200f470: f4 27 60 54 st %i2, [ %i5 + 0x54 ]
IMFS_update_atime( the_jnode );
200f474: 90 07 bf f8 add %fp, -8, %o0
200f478: 7f ff d0 a8 call 2003718 <gettimeofday>
200f47c: 92 10 20 00 clr %o1
200f480: c2 07 bf f8 ld [ %fp + -8 ], %g1
200f484: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return 0;
}
200f488: 81 c7 e0 08 ret
200f48c: 91 e8 20 00 restore %g0, 0, %o0
* 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 )
200f490: 80 a0 40 1a cmp %g1, %i2
200f494: 3a bf ff f7 bcc,a 200f470 <memfile_ftruncate+0x24>
200f498: f2 27 60 50 st %i1, [ %i5 + 0x50 ]
return IMFS_memfile_extend( the_jnode, true, length );
200f49c: 90 10 00 1d mov %i5, %o0
200f4a0: 92 10 20 01 mov 1, %o1
200f4a4: 94 10 00 19 mov %i1, %o2
200f4a8: 7f ff fe c4 call 200efb8 <IMFS_memfile_extend>
200f4ac: 96 10 00 1a mov %i2, %o3
200f4b0: 81 c7 e0 08 ret
200f4b4: 91 e8 00 08 restore %g0, %o0, %o0
0200f3d0 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
200f3d0: 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)
200f3d4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200f3d8: 80 88 60 04 btst 4, %g1
200f3dc: 02 80 00 07 be 200f3f8 <memfile_open+0x28>
200f3e0: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
200f3e4: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
200f3e8: c2 00 40 00 ld [ %g1 ], %g1
200f3ec: 80 a0 60 05 cmp %g1, 5
200f3f0: 22 80 00 04 be,a 200f400 <memfile_open+0x30> <== NEVER TAKEN
200f3f4: d8 02 20 54 ld [ %o0 + 0x54 ], %o4 <== NOT EXECUTED
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
200f3f8: 81 c7 e0 08 ret
200f3fc: 91 e8 20 00 restore %g0, 0, %o0
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
200f400: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
200f404: 03 00 80 71 sethi %hi(0x201c400), %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
200f408: c0 22 20 50 clr [ %o0 + 0x50 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
200f40c: 82 10 60 84 or %g1, 0x84, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
200f410: c0 22 20 54 clr [ %o0 + 0x54 ] <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
200f414: c0 22 20 58 clr [ %o0 + 0x58 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
200f418: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
200f41c: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
200f420: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
200f424: 02 bf ff f5 be 200f3f8 <memfile_open+0x28> <== NOT EXECUTED
200f428: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
200f42c: 92 10 20 00 clr %o1 <== NOT EXECUTED
200f430: 7f ff ff 53 call 200f17c <IMFS_memfile_write> <== NOT EXECUTED
200f434: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
200f438: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
200f43c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
200f440: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
200f444: 81 c7 e0 08 ret <== NOT EXECUTED
200f448: 81 e8 00 00 restore <== NOT EXECUTED
02003bf0 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2003bf0: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
2003bf4: 80 a6 e0 01 cmp %i3, 1
2003bf8: 18 80 00 9a bgu 2003e60 <mount+0x270>
2003bfc: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
2003c00: 40 00 23 a0 call 200ca80 <rtems_filesystem_get_mount_handler>
2003c04: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
2003c08: a4 92 20 00 orcc %o0, 0, %l2
2003c0c: 02 80 00 95 be 2003e60 <mount+0x270>
2003c10: 80 a6 60 00 cmp %i1, 0
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2003c14: 02 80 00 7b be 2003e00 <mount+0x210>
2003c18: 01 00 00 00 nop
}
return rv;
}
int mount(
2003c1c: 40 00 37 54 call 201196c <strlen>
2003c20: 90 10 00 19 mov %i1, %o0
2003c24: a6 02 20 01 add %o0, 1, %l3
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;
2003c28: 40 00 37 51 call 201196c <strlen>
2003c2c: 90 10 00 1a mov %i2, %o0
}
return rv;
}
int mount(
2003c30: aa 10 00 19 mov %i1, %l5
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;
2003c34: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003c38: 80 a6 20 00 cmp %i0, 0
2003c3c: 02 80 00 7a be 2003e24 <mount+0x234>
2003c40: a8 02 20 01 add %o0, 1, %l4
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003c44: ba 07 40 13 add %i5, %l3, %i5
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003c48: 40 00 37 49 call 201196c <strlen>
2003c4c: 90 10 00 18 mov %i0, %o0
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003c50: 92 07 60 65 add %i5, 0x65, %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;
2003c54: a2 02 20 01 add %o0, 1, %l1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2003c58: 90 10 20 01 mov 1, %o0
2003c5c: 7f ff fd d6 call 20033b4 <calloc>
2003c60: 92 02 40 11 add %o1, %l1, %o1
if ( mt_entry != NULL ) {
2003c64: ba 92 20 00 orcc %o0, 0, %i5
2003c68: 02 80 00 78 be 2003e48 <mount+0x258> <== NEVER TAKEN
2003c6c: a0 07 60 64 add %i5, 0x64, %l0
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 );
2003c70: 92 10 00 1a mov %i2, %o1
2003c74: 90 10 00 10 mov %l0, %o0
2003c78: 40 00 34 29 call 2010d1c <memcpy>
2003c7c: 94 10 00 14 mov %l4, %o2
mt_entry->type = str;
2003c80: e0 27 60 34 st %l0, [ %i5 + 0x34 ]
+ 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 =
2003c84: ac 07 60 40 add %i5, 0x40, %l6
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
2003c88: 80 a6 20 00 cmp %i0, 0
2003c8c: 02 80 00 08 be 2003cac <mount+0xbc>
2003c90: b4 04 00 14 add %l0, %l4, %i2
memcpy( str, source_or_null, source_size );
2003c94: 90 10 00 1a mov %i2, %o0
2003c98: 92 10 00 18 mov %i0, %o1
2003c9c: 40 00 34 20 call 2010d1c <memcpy>
2003ca0: 94 10 00 11 mov %l1, %o2
mt_entry->dev = str;
2003ca4: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
str += source_size;
2003ca8: b4 06 80 11 add %i2, %l1, %i2
}
memcpy( str, target, target_size );
2003cac: 92 10 00 15 mov %l5, %o1
2003cb0: 94 10 00 13 mov %l3, %o2
2003cb4: 40 00 34 1a call 2010d1c <memcpy>
2003cb8: 90 10 00 1a mov %i2, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
2003cbc: 82 10 20 01 mov 1, %g1
2003cc0: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
2003cc4: 03 00 80 70 sethi %hi(0x201c000), %g1
2003cc8: 82 10 60 94 or %g1, 0x94, %g1 ! 201c094 <rtems_filesystem_default_pathconf>
2003ccc: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
2003cd0: 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 );
2003cd4: 90 07 60 14 add %i5, 0x14, %o0
2003cd8: 92 10 00 16 mov %l6, %o1
2003cdc: 94 10 20 01 mov 1, %o2
2003ce0: 96 10 20 24 mov 0x24, %o3
2003ce4: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
2003ce8: f4 27 60 30 st %i2, [ %i5 + 0x30 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
2003cec: ec 27 60 24 st %l6, [ %i5 + 0x24 ]
2003cf0: 40 00 12 8c call 2008720 <_Chain_Initialize>
2003cf4: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
rv = (*fsmount_me_h)( mt_entry, data );
2003cf8: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2003cfc: b6 0e e0 01 and %i3, 1, %i3
rv = (*fsmount_me_h)( mt_entry, data );
2003d00: 92 10 00 1c mov %i4, %o1
2003d04: 9f c4 80 00 call %l2
2003d08: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
if ( rv == 0 ) {
2003d0c: b0 92 20 00 orcc %o0, 0, %i0
2003d10: 12 80 00 29 bne 2003db4 <mount+0x1c4>
2003d14: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
2003d18: 02 80 00 58 be 2003e78 <mount+0x288>
2003d1c: 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 =
2003d20: 94 10 20 1f mov 0x1f, %o2
2003d24: 40 00 03 3b call 2004a10 <rtems_filesystem_eval_path_start>
2003d28: 90 07 bf c8 add %fp, -56, %o0
static inline bool rtems_filesystem_location_is_instance_root(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2003d2c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
2003d30: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2003d34: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
2003d38: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
2003d3c: 9f c0 40 00 call %g1
2003d40: 01 00 00 00 nop
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
2003d44: 80 8a 20 ff btst 0xff, %o0
2003d48: 12 80 00 70 bne 2003f08 <mount+0x318>
2003d4c: 92 07 bf e0 add %fp, -32, %o1
static inline void rtems_filesystem_eval_path_extract_currentloc(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_location_info_t *get
)
{
rtems_filesystem_location_copy_and_detach(
2003d50: 40 00 04 29 call 2004df4 <rtems_filesystem_location_copy_and_detach>
2003d54: 90 07 bf b0 add %fp, -80, %o0
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
2003d58: 40 00 04 b6 call 2005030 <rtems_filesystem_location_transform_to_global>
2003d5c: 90 07 bf b0 add %fp, -80, %o0
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2003d60: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( !rtems_filesystem_location_is_instance_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 );
2003d64: b8 10 00 08 mov %o0, %i4
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2003d68: c2 00 60 0c ld [ %g1 + 0xc ], %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;
2003d6c: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2003d70: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
2003d74: 9f c0 40 00 call %g1
2003d78: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
2003d7c: b0 92 20 00 orcc %o0, 0, %i0
2003d80: 22 80 00 11 be,a 2003dc4 <mount+0x1d4>
2003d84: 39 00 80 78 sethi %hi(0x201e000), %i4
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
2003d88: 40 00 04 50 call 2004ec8 <rtems_filesystem_global_location_release>
2003d8c: 90 10 00 1c mov %i4, %o0
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003d90: 40 00 03 60 call 2004b10 <rtems_filesystem_eval_path_cleanup>
2003d94: 90 07 bf c8 add %fp, -56, %o0
rv = register_subordinate_file_system( mt_entry, target );
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
2003d98: 80 a6 20 00 cmp %i0, 0
2003d9c: 02 80 00 59 be 2003f00 <mount+0x310>
2003da0: 01 00 00 00 nop
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2003da4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2003da8: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
2003dac: 9f c0 40 00 call %g1
2003db0: 90 10 00 1d mov %i5, %o0
}
}
if ( rv != 0 ) {
free( mt_entry );
2003db4: 7f ff fe 2f call 2003670 <free>
2003db8: 90 10 00 1d mov %i5, %o0
errno = EINVAL;
rv = -1;
}
return rv;
}
2003dbc: 81 c7 e0 08 ret
2003dc0: 81 e8 00 00 restore
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2003dc4: d0 07 21 9c ld [ %i4 + 0x19c ], %o0
2003dc8: 92 10 20 00 clr %o1
2003dcc: 40 00 0f 65 call 2007b60 <rtems_semaphore_obtain>
2003dd0: 94 10 20 00 clr %o2
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2003dd4: d0 07 21 9c ld [ %i4 + 0x19c ], %o0
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2003dd8: 03 00 80 76 sethi %hi(0x201d800), %g1
2003ddc: 82 10 60 18 or %g1, 0x18, %g1 ! 201d818 <rtems_filesystem_mount_table>
2003de0: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2003de4: 86 00 60 04 add %g1, 4, %g3
2003de8: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
2003dec: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
2003df0: fa 20 80 00 st %i5, [ %g2 ]
2003df4: 40 00 0f aa call 2007c9c <rtems_semaphore_release>
2003df8: c4 27 60 04 st %g2, [ %i5 + 4 ]
2003dfc: 30 bf ff e5 b,a 2003d90 <mount+0x1a0>
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;
2003e00: 40 00 36 db call 201196c <strlen>
2003e04: 90 10 00 1a mov %i2, %o0
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2003e08: 2b 00 80 70 sethi %hi(0x201c000), %l5
2003e0c: a6 10 20 02 mov 2, %l3
2003e10: aa 15 60 90 or %l5, 0x90, %l5
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2003e14: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003e18: 80 a6 20 00 cmp %i0, 0
2003e1c: 12 bf ff 8a bne 2003c44 <mount+0x54> <== NEVER TAKEN
2003e20: a8 02 20 01 add %o0, 1, %l4
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003e24: ba 07 40 13 add %i5, %l3, %i5
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003e28: a2 10 20 00 clr %l1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003e2c: 92 07 60 65 add %i5, 0x65, %o1
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2003e30: 90 10 20 01 mov 1, %o0
2003e34: 7f ff fd 60 call 20033b4 <calloc>
2003e38: 92 02 40 11 add %o1, %l1, %o1
if ( mt_entry != NULL ) {
2003e3c: ba 92 20 00 orcc %o0, 0, %i5
2003e40: 12 bf ff 8c bne 2003c70 <mount+0x80> <== ALWAYS TAKEN
2003e44: a0 07 60 64 add %i5, 0x64, %l0
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
2003e48: 40 00 31 64 call 20103d8 <__errno> <== NOT EXECUTED
2003e4c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003e50: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
2003e54: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2003e58: 81 c7 e0 08 ret <== NOT EXECUTED
2003e5c: 81 e8 00 00 restore <== NOT EXECUTED
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
2003e60: 40 00 31 5e call 20103d8 <__errno>
2003e64: b0 10 3f ff mov -1, %i0
2003e68: 82 10 20 16 mov 0x16, %g1
2003e6c: c2 22 00 00 st %g1, [ %o0 ]
2003e70: 81 c7 e0 08 ret
2003e74: 81 e8 00 00 restore
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2003e78: 39 00 80 78 sethi %hi(0x201e000), %i4
2003e7c: d0 07 21 9c ld [ %i4 + 0x19c ], %o0 ! 201e19c <rtems_libio_semaphore>
2003e80: 92 10 20 00 clr %o1
2003e84: 40 00 0f 37 call 2007b60 <rtems_semaphore_obtain>
2003e88: 94 10 20 00 clr %o2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2003e8c: 03 00 80 76 sethi %hi(0x201d800), %g1
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
2003e90: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 ! 201d818 <rtems_filesystem_mount_table>
2003e94: 82 10 60 18 or %g1, 0x18, %g1
2003e98: 86 00 60 04 add %g1, 4, %g3
2003e9c: 80 a0 80 03 cmp %g2, %g3
2003ea0: 12 80 00 1f bne 2003f1c <mount+0x32c> <== NEVER TAKEN
2003ea4: 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;
2003ea8: c6 00 60 08 ld [ %g1 + 8 ], %g3
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2003eac: d0 07 21 9c ld [ %i4 + 0x19c ], %o0
the_node->next = tail;
2003eb0: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
2003eb4: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
2003eb8: fa 20 c0 00 st %i5, [ %g3 ]
2003ebc: 40 00 0f 78 call 2007c9c <rtems_semaphore_release>
2003ec0: c6 27 60 04 st %g3, [ %i5 + 4 ]
}
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 );
2003ec4: ba 07 60 24 add %i5, 0x24, %i5
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
2003ec8: 40 00 04 20 call 2004f48 <rtems_filesystem_global_location_obtain>
2003ecc: 90 10 00 1d mov %i5, %o0
2003ed0: 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 =
2003ed4: 40 00 04 1d call 2004f48 <rtems_filesystem_global_location_obtain>
2003ed8: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2003edc: 39 00 80 76 sethi %hi(0x201d800), %i4
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 =
2003ee0: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2003ee4: d0 07 20 38 ld [ %i4 + 0x38 ], %o0
2003ee8: 92 10 00 1b mov %i3, %o1
2003eec: 40 00 04 0d call 2004f20 <rtems_filesystem_global_location_assign>
2003ef0: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
2003ef4: d0 07 20 38 ld [ %i4 + 0x38 ], %o0
2003ef8: 40 00 04 0a call 2004f20 <rtems_filesystem_global_location_assign>
2003efc: 92 10 00 1d mov %i5, %o1
2003f00: 81 c7 e0 08 ret
2003f04: 81 e8 00 00 restore
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
2003f08: 90 07 bf c8 add %fp, -56, %o0
2003f0c: 92 10 20 10 mov 0x10, %o1
2003f10: 40 00 02 04 call 2004720 <rtems_filesystem_eval_path_error>
2003f14: b0 10 3f ff mov -1, %i0
2003f18: 30 bf ff 9e b,a 2003d90 <mount+0x1a0>
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
2003f1c: 40 00 31 2f call 20103d8 <__errno> <== NOT EXECUTED
2003f20: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003f24: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003f28: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2003f2c: 40 00 0f 5c call 2007c9c <rtems_semaphore_release> <== NOT EXECUTED
2003f30: d0 07 21 9c ld [ %i4 + 0x19c ], %o0 <== NOT EXECUTED
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2003f34: 10 bf ff 9d b 2003da8 <mount+0x1b8> <== NOT EXECUTED
2003f38: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
02009090 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2009090: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
2009094: 90 96 60 00 orcc %i1, 0, %o0
2009098: 02 80 00 0b be 20090c4 <mount_and_make_target_path+0x34>
200909c: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
20090a0: 40 00 03 0c call 2009cd0 <rtems_mkdir>
20090a4: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
20090a8: 82 92 20 00 orcc %o0, 0, %g1
20090ac: 02 80 00 04 be 20090bc <mount_and_make_target_path+0x2c> <== ALWAYS TAKEN
20090b0: 01 00 00 00 nop
} else {
errno = EINVAL;
}
return rv;
}
20090b4: 81 c7 e0 08 ret
20090b8: 91 e8 00 01 restore %g0, %g1, %o0
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
20090bc: 40 00 00 08 call 20090dc <mount>
20090c0: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
20090c4: 40 00 68 69 call 2023268 <__errno>
20090c8: 01 00 00 00 nop
20090cc: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
20090d0: 82 10 3f ff mov -1, %g1
options,
data
);
}
} else {
errno = EINVAL;
20090d4: 10 bf ff f8 b 20090b4 <mount_and_make_target_path+0x24>
20090d8: c4 22 00 00 st %g2, [ %o0 ]
02007d4c <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
2007d4c: 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)
{
uint32_t level = _Thread_Dispatch_disable_level;
2007d50: 03 00 80 8b sethi %hi(0x2022c00), %g1
2007d54: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 2022dd0 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
2007d58: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
2007d5c: 84 00 a0 01 inc %g2
2007d60: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2007d64: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2007d68: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
2007d6c: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
2007d70: a2 8e 62 00 andcc %i1, 0x200, %l1
2007d74: 12 80 00 36 bne 2007e4c <mq_open+0x100>
2007d78: a0 10 20 00 clr %l0
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
2007d7c: 39 00 80 8c sethi %hi(0x2023000), %i4
2007d80: 40 00 0c 21 call 200ae04 <_Objects_Allocate>
2007d84: 90 17 22 b0 or %i4, 0x2b0, %o0 ! 20232b0 <_POSIX_Message_queue_Information_fds>
attr = va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
2007d88: ba 92 20 00 orcc %o0, 0, %i5
2007d8c: 02 80 00 39 be 2007e70 <mq_open+0x124> <== NEVER TAKEN
2007d90: 01 00 00 00 nop
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
2007d94: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len );
2007d98: 35 00 80 8c sethi %hi(0x2023000), %i2
2007d9c: 92 10 00 18 mov %i0, %o1
2007da0: 90 16 a1 24 or %i2, 0x124, %o0
2007da4: 94 07 bf f0 add %fp, -16, %o2
2007da8: 40 00 01 42 call 20082b0 <_POSIX_Name_to_id>
2007dac: 96 07 bf fc add %fp, -4, %o3
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
2007db0: b6 92 20 00 orcc %o0, 0, %i3
2007db4: 22 80 00 0f be,a 2007df0 <mq_open+0xa4>
2007db8: 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) ) ) {
2007dbc: 80 a6 e0 02 cmp %i3, 2
2007dc0: 02 80 00 3f be 2007ebc <mq_open+0x170>
2007dc4: 80 a4 60 00 cmp %l1, 0
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
2007dc8: 90 17 22 b0 or %i4, 0x2b0, %o0
2007dcc: 40 00 0d 06 call 200b1e4 <_Objects_Free>
2007dd0: 92 10 00 1d mov %i5, %o1
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
2007dd4: 40 00 11 8f call 200c410 <_Thread_Enable_dispatch>
2007dd8: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
2007ddc: 40 00 29 46 call 20122f4 <__errno>
2007de0: 01 00 00 00 nop
2007de4: f6 22 00 00 st %i3, [ %o0 ]
2007de8: 81 c7 e0 08 ret
2007dec: 81 e8 00 00 restore
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
2007df0: 80 a6 6a 00 cmp %i1, 0xa00
2007df4: 02 80 00 27 be 2007e90 <mq_open+0x144>
2007df8: d2 07 bf f0 ld [ %fp + -16 ], %o1
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
2007dfc: 94 07 bf f8 add %fp, -8, %o2
2007e00: 40 00 0d 5f call 200b37c <_Objects_Get>
2007e04: 90 16 a1 24 or %i2, 0x124, %o0
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
the_mq->open_count += 1;
2007e08: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
2007e0c: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
2007e10: 84 00 a0 01 inc %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007e14: b8 17 22 b0 or %i4, 0x2b0, %i4
2007e18: c4 22 20 18 st %g2, [ %o0 + 0x18 ]
2007e1c: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
2007e20: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
2007e24: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
2007e28: 83 28 60 02 sll %g1, 2, %g1
2007e2c: fa 20 80 01 st %i5, [ %g2 + %g1 ]
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
2007e30: 40 00 11 78 call 200c410 <_Thread_Enable_dispatch>
2007e34: c0 27 60 0c clr [ %i5 + 0xc ]
_Thread_Enable_dispatch();
2007e38: 40 00 11 76 call 200c410 <_Thread_Enable_dispatch>
2007e3c: 01 00 00 00 nop
return (mqd_t)the_mq_fd->Object.id;
2007e40: f0 07 60 08 ld [ %i5 + 8 ], %i0
2007e44: 81 c7 e0 08 ret
2007e48: 81 e8 00 00 restore
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
2007e4c: 82 07 a0 4c add %fp, 0x4c, %g1
mode = va_arg( arg, mode_t );
attr = va_arg( arg, struct mq_attr * );
2007e50: e0 07 a0 50 ld [ %fp + 0x50 ], %l0
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
2007e54: c2 27 bf ec st %g1, [ %fp + -20 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
2007e58: 39 00 80 8c sethi %hi(0x2023000), %i4
2007e5c: 40 00 0b ea call 200ae04 <_Objects_Allocate>
2007e60: 90 17 22 b0 or %i4, 0x2b0, %o0 ! 20232b0 <_POSIX_Message_queue_Information_fds>
attr = va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
2007e64: ba 92 20 00 orcc %o0, 0, %i5
2007e68: 32 bf ff cc bne,a 2007d98 <mq_open+0x4c>
2007e6c: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_Thread_Enable_dispatch();
2007e70: 40 00 11 68 call 200c410 <_Thread_Enable_dispatch>
2007e74: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( ENFILE );
2007e78: 40 00 29 1f call 20122f4 <__errno>
2007e7c: 01 00 00 00 nop
2007e80: 82 10 20 17 mov 0x17, %g1 ! 17 <PROM_START+0x17>
2007e84: c2 22 00 00 st %g1, [ %o0 ]
2007e88: 81 c7 e0 08 ret
2007e8c: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
2007e90: 90 17 22 b0 or %i4, 0x2b0, %o0
2007e94: 40 00 0c d4 call 200b1e4 <_Objects_Free>
2007e98: 92 10 00 1d mov %i5, %o1
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
2007e9c: 40 00 11 5d call 200c410 <_Thread_Enable_dispatch>
2007ea0: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
2007ea4: 40 00 29 14 call 20122f4 <__errno>
2007ea8: 01 00 00 00 nop
2007eac: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
2007eb0: c2 22 00 00 st %g1, [ %o0 ]
2007eb4: 81 c7 e0 08 ret
2007eb8: 81 e8 00 00 restore
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
2007ebc: 02 bf ff c4 be 2007dcc <mq_open+0x80>
2007ec0: 90 17 22 b0 or %i4, 0x2b0, %o0
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
2007ec4: d2 07 bf fc ld [ %fp + -4 ], %o1
2007ec8: 90 10 00 18 mov %i0, %o0
2007ecc: 94 10 20 01 mov 1, %o2
2007ed0: 96 10 00 10 mov %l0, %o3
2007ed4: 40 00 1c 37 call 200efb0 <_POSIX_Message_queue_Create_support>
2007ed8: 98 07 bf f4 add %fp, -12, %o4
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
2007edc: 80 a2 3f ff cmp %o0, -1
2007ee0: 02 80 00 0d be 2007f14 <mq_open+0x1c8>
2007ee4: c6 07 bf f4 ld [ %fp + -12 ], %g3
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
2007ee8: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007eec: b8 17 22 b0 or %i4, 0x2b0, %i4
2007ef0: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
2007ef4: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
2007ef8: 83 28 60 02 sll %g1, 2, %g1
2007efc: fa 20 80 01 st %i5, [ %g2 + %g1 ]
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
2007f00: 40 00 11 44 call 200c410 <_Thread_Enable_dispatch>
2007f04: c0 27 60 0c clr [ %i5 + 0xc ]
return (mqd_t) the_mq_fd->Object.id;
2007f08: f0 07 60 08 ld [ %i5 + 8 ], %i0
}
2007f0c: 81 c7 e0 08 ret
2007f10: 81 e8 00 00 restore
2007f14: 90 17 22 b0 or %i4, 0x2b0, %o0
2007f18: 92 10 00 1d mov %i5, %o1
2007f1c: 40 00 0c b2 call 200b1e4 <_Objects_Free>
2007f20: b0 10 3f ff mov -1, %i0
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
2007f24: 40 00 11 3b call 200c410 <_Thread_Enable_dispatch>
2007f28: 01 00 00 00 nop
2007f2c: 81 c7 e0 08 ret
2007f30: 81 e8 00 00 restore
02018d5c <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
2018d5c: 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;
2018d60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2018d64: b8 07 bf 80 add %fp, -128, %i4
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;
2018d68: e0 00 60 08 ld [ %g1 + 8 ], %l0
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
2018d6c: c0 27 bf 6c clr [ %fp + -148 ]
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2018d70: 82 10 3f ff mov -1, %g1
time_t time_ret = 0;
uint16_t time_val = 0;
2018d74: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
2018d78: c0 37 bf 6a clrh [ %fp + -150 ]
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
2018d7c: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
2018d80: c0 27 bf 74 clr [ %fp + -140 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2018d84: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2018d88: c2 27 bf 7c st %g1, [ %fp + -132 ]
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2018d8c: c0 27 bf 80 clr [ %fp + -128 ]
2018d90: c0 27 bf 84 clr [ %fp + -124 ]
2018d94: c0 27 20 08 clr [ %i4 + 8 ]
2018d98: c0 27 20 0c clr [ %i4 + 0xc ]
2018d9c: c0 27 20 10 clr [ %i4 + 0x10 ]
2018da0: c0 27 20 14 clr [ %i4 + 0x14 ]
2018da4: c0 27 20 18 clr [ %i4 + 0x18 ]
2018da8: c0 27 20 1c clr [ %i4 + 0x1c ]
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
2018dac: c0 27 bf c0 clr [ %fp + -64 ]
2018db0: c0 27 bf c4 clr [ %fp + -60 ]
2018db4: c0 27 bf c8 clr [ %fp + -56 ]
2018db8: c0 27 bf cc clr [ %fp + -52 ]
2018dbc: c0 27 bf d0 clr [ %fp + -48 ]
2018dc0: c0 27 bf d4 clr [ %fp + -44 ]
2018dc4: c0 27 bf d8 clr [ %fp + -40 ]
2018dc8: c0 27 bf dc clr [ %fp + -36 ]
2018dcc: c0 27 bf e0 clr [ %fp + -32 ]
2018dd0: c0 27 bf e4 clr [ %fp + -28 ]
2018dd4: c0 27 bf e8 clr [ %fp + -24 ]
2018dd8: c0 27 bf ec clr [ %fp + -20 ]
2018ddc: c0 27 bf f0 clr [ %fp + -16 ]
2018de0: c0 27 bf f4 clr [ %fp + -12 ]
2018de4: c0 27 bf f8 clr [ %fp + -8 ]
2018de8: c0 27 bf fc clr [ %fp + -4 ]
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
2018dec: 80 a6 e1 04 cmp %i3, 0x104
2018df0: 14 80 00 e3 bg 201917c <msdos_creat_node+0x420> <== NEVER TAKEN
2018df4: e2 06 20 08 ld [ %i0 + 8 ], %l1
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
}
name_type = msdos_long_to_short (name, name_len,
2018df8: 90 10 00 1a mov %i2, %o0
2018dfc: 92 10 00 1b mov %i3, %o1
2018e00: 94 10 00 1c mov %i4, %o2
2018e04: 40 00 01 37 call 20192e0 <msdos_long_to_short>
2018e08: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
2018e0c: a4 92 20 00 orcc %o0, 0, %l2
2018e10: 02 80 00 e0 be 2019190 <msdos_creat_node+0x434> <== NEVER TAKEN
2018e14: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EINVAL);
}
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
2018e18: c0 2f bf 8c clrb [ %fp + -116 ]
/* set up last write date and time */
time_ret = time(NULL);
2018e1c: 40 00 24 0a call 2021e44 <time>
2018e20: 90 10 20 00 clr %o0
if ( time_ret == -1 )
2018e24: 80 a2 3f ff cmp %o0, -1
2018e28: 02 80 00 df be 20191a4 <msdos_creat_node+0x448> <== NEVER TAKEN
2018e2c: 92 07 bf 6a add %fp, -150, %o1
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
2018e30: 40 00 0c 8f call 201c06c <msdos_date_unix2dos>
2018e34: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
2018e38: c8 17 bf 68 lduh [ %fp + -152 ], %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2018e3c: c6 17 bf 6a lduh [ %fp + -150 ], %g3
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
2018e40: 89 29 20 10 sll %g4, 0x10, %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2018e44: 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);
2018e48: 85 31 20 08 srl %g4, 8, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2018e4c: 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);
2018e50: 89 31 20 18 srl %g4, 0x18, %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2018e54: 87 30 e0 18 srl %g3, 0x18, %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);
2018e58: 84 10 80 04 or %g2, %g4, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2018e5c: 82 10 40 03 or %g1, %g3, %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);
2018e60: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
2018e64: c4 37 bf 96 sth %g2, [ %fp + -106 ]
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2018e68: c2 37 bf 90 sth %g1, [ %fp + -112 ]
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
2018e6c: c2 37 bf 98 sth %g1, [ %fp + -104 ]
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
2018e70: c2 37 bf 92 sth %g1, [ %fp + -110 ]
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
2018e74: 80 a6 60 00 cmp %i1, 0
2018e78: 02 80 00 12 be 2018ec0 <msdos_creat_node+0x164>
2018e7c: c0 27 bf 9c clr [ %fp + -100 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
2018e80: 80 a6 60 02 cmp %i1, 2
2018e84: 02 80 00 89 be 20190a8 <msdos_creat_node+0x34c> <== NEVER TAKEN
2018e88: c2 0f bf 8b ldub [ %fp + -117 ], %g1
* 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;
2018e8c: 82 10 60 20 or %g1, 0x20, %g1
2018e90: c2 2f bf 8b stb %g1, [ %fp + -117 ]
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
2018e94: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2018e98: 90 10 00 18 mov %i0, %o0
2018e9c: 92 10 20 01 mov 1, %o1
2018ea0: 94 10 00 1a mov %i2, %o2
2018ea4: 96 10 00 1b mov %i3, %o3
2018ea8: 98 10 00 12 mov %l2, %o4
2018eac: 40 00 06 a4 call 201a93c <msdos_get_name_node>
2018eb0: 9a 07 bf 70 add %fp, -144, %o5
2018eb4: ba 10 00 08 mov %o0, %i5
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2018eb8: 81 c7 e0 08 ret
2018ebc: 91 e8 00 1d restore %g0, %i5, %o0
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
2018ec0: c2 0f bf 8b ldub [ %fp + -117 ], %g1
/*
* 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,
2018ec4: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
2018ec8: 82 10 60 10 or %g1, 0x10, %g1
/*
* 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,
2018ecc: 90 10 00 18 mov %i0, %o0
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
2018ed0: c2 2f bf 8b stb %g1, [ %fp + -117 ]
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
2018ed4: 92 10 20 01 mov 1, %o1
2018ed8: 94 10 00 1a mov %i2, %o2
2018edc: 96 10 00 1b mov %i3, %o3
2018ee0: 98 10 00 12 mov %l2, %o4
2018ee4: 40 00 06 96 call 201a93c <msdos_get_name_node>
2018ee8: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
2018eec: ba 92 20 00 orcc %o0, 0, %i5
2018ef0: 12 bf ff f2 bne 2018eb8 <msdos_creat_node+0x15c> <== NEVER TAKEN
2018ef4: 90 10 00 10 mov %l0, %o0
* to do
*/
if (type == MSDOS_DIRECTORY)
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
2018ef8: 92 07 bf 70 add %fp, -144, %o1
2018efc: 7f ff e8 4c call 201302c <fat_file_open>
2018f00: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
2018f04: ba 92 20 00 orcc %o0, 0, %i5
2018f08: 32 80 00 62 bne,a 2019090 <msdos_creat_node+0x334> <== NEVER TAKEN
2018f0c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
2018f10: f2 07 bf 6c ld [ %fp + -148 ], %i1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2018f14: 03 00 08 00 sethi %hi(0x200000), %g1
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
2018f18: c0 26 60 18 clr [ %i1 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2018f1c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
/*
* 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;
2018f20: c0 26 60 10 clr [ %i1 + 0x10 ]
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
2018f24: 03 00 80 b5 sethi %hi(0x202d400), %g1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2018f28: d8 1f bf 80 ldd [ %fp + -128 ], %o4
2018f2c: c4 1f bf 98 ldd [ %fp + -104 ], %g2
2018f30: f4 1f bf 88 ldd [ %fp + -120 ], %i2
2018f34: f8 1f bf 90 ldd [ %fp + -112 ], %i4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
2018f38: d2 00 63 ac ld [ %g1 + 0x3ac ], %o1
2018f3c: 94 10 20 0b mov 0xb, %o2
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2018f40: d8 3f bf c0 std %o4, [ %fp + -64 ]
2018f44: c4 3f bf d8 std %g2, [ %fp + -40 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
2018f48: d8 3f bf e0 std %o4, [ %fp + -32 ]
2018f4c: c4 3f bf f8 std %g2, [ %fp + -8 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2018f50: f4 3f bf c8 std %i2, [ %fp + -56 ]
2018f54: f8 3f bf d0 std %i4, [ %fp + -48 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
2018f58: f4 3f bf e8 std %i2, [ %fp + -24 ]
2018f5c: f8 3f bf f0 std %i4, [ %fp + -16 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
2018f60: 40 00 13 1a call 201dbc8 <memcpy>
2018f64: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
2018f68: 03 00 80 b5 sethi %hi(0x202d400), %g1
2018f6c: d2 00 63 a8 ld [ %g1 + 0x3a8 ], %o1 ! 202d7a8 <MSDOS_DOTDOT_NAME>
2018f70: 90 07 bf e0 add %fp, -32, %o0
2018f74: 40 00 13 15 call 201dbc8 <memcpy>
2018f78: 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)) &&
2018f7c: c2 04 60 20 ld [ %l1 + 0x20 ], %g1
2018f80: 80 a0 60 01 cmp %g1, 1
2018f84: 22 80 00 73 be,a 2019150 <msdos_creat_node+0x3f4>
2018f88: c2 04 60 24 ld [ %l1 + 0x24 ], %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
2018f8c: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2018f90: 07 00 00 3f sethi %hi(0xfc00), %g3
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
2018f94: 85 30 60 10 srl %g1, 0x10, %g2
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2018f98: 86 10 e3 ff or %g3, 0x3ff, %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)) =
2018f9c: 89 28 60 10 sll %g1, 0x10, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2018fa0: 82 08 40 03 and %g1, %g3, %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)) =
2018fa4: 89 31 20 18 srl %g4, 0x18, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2018fa8: 86 08 80 03 and %g2, %g3, %g3
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
2018fac: 83 28 60 08 sll %g1, 8, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
2018fb0: 87 28 e0 08 sll %g3, 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)) =
2018fb4: 82 10 40 04 or %g1, %g4, %g1
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
2018fb8: 85 30 a0 08 srl %g2, 8, %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
2018fbc: c2 37 bf fa sth %g1, [ %fp + -6 ]
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
2018fc0: 84 10 c0 02 or %g3, %g2, %g2
2018fc4: c4 37 bf f4 sth %g2, [ %fp + -12 ]
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
2018fc8: 90 10 00 10 mov %l0, %o0
2018fcc: 92 10 00 19 mov %i1, %o1
2018fd0: 94 10 20 00 clr %o2
2018fd4: 96 10 20 40 mov 0x40, %o3
2018fd8: 7f ff ea 87 call 20139f4 <fat_file_write>
2018fdc: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
2018fe0: 80 a2 20 00 cmp %o0, 0
2018fe4: 06 80 00 26 bl 201907c <msdos_creat_node+0x320> <== NEVER TAKEN
2018fe8: d2 07 bf 6c ld [ %fp + -148 ], %o1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
2018fec: c4 14 20 06 lduh [ %l0 + 6 ], %g2
2018ff0: c6 02 60 18 ld [ %o1 + 0x18 ], %g3
/* 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));
2018ff4: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
2018ff8: 84 00 c0 02 add %g3, %g2, %g2
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
2018ffc: bb 28 60 10 sll %g1, 0x10, %i5
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));
2019000: 87 30 60 10 srl %g1, 0x10, %g3
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
2019004: c4 22 60 18 st %g2, [ %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));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
2019008: 89 30 e0 08 srl %g3, 8, %g4
/* 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)) =
201900c: bb 37 60 18 srl %i5, 0x18, %i5
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2019010: 05 00 00 3f sethi %hi(0xfc00), %g2
2019014: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
2019018: 82 08 40 02 and %g1, %g2, %g1
201901c: 84 08 c0 02 and %g3, %g2, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
2019020: 83 28 60 08 sll %g1, 8, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
2019024: 85 28 a0 08 sll %g2, 8, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
2019028: 82 10 40 1d or %g1, %i5, %g1
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
201902c: 84 10 80 04 or %g2, %g4, %g2
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
2019030: 90 10 00 10 mov %l0, %o0
/* 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)) =
2019034: c2 37 bf da sth %g1, [ %fp + -38 ]
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
2019038: c4 37 bf d4 sth %g2, [ %fp + -44 ]
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
201903c: 94 10 20 00 clr %o2
2019040: 96 10 20 20 mov 0x20, %o3
2019044: 7f ff ea 6c call 20139f4 <fat_file_write>
2019048: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
201904c: 80 a2 20 00 cmp %o0, 0
2019050: 06 80 00 0c bl 2019080 <msdos_creat_node+0x324> <== NEVER TAKEN
2019054: ba 10 3f ff mov -1, %i5
rc = -1;
goto error;
}
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
2019058: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
201905c: 40 00 01 74 call 201962c <msdos_set_first_cluster_num>
2019060: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
2019064: ba 92 20 00 orcc %o0, 0, %i5
2019068: 12 80 00 07 bne 2019084 <msdos_creat_node+0x328> <== NEVER TAKEN
201906c: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
2019070: 7f ff e9 69 call 2013614 <fat_file_close>
2019074: 90 10 00 10 mov %l0, %o0
2019078: 30 bf ff 90 b,a 2018eb8 <msdos_creat_node+0x15c>
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
{
rc = -1;
201907c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
}
return RC_OK;
error:
fat_file_close(&fs_info->fat, fat_fd);
2019080: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
2019084: 7f ff e9 64 call 2013614 <fat_file_close> <== NOT EXECUTED
2019088: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
201908c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
2019090: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
2019094: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
2019098: 40 00 01 c9 call 20197bc <msdos_set_first_char4file_name> <== NOT EXECUTED
201909c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
}
20190a0: 81 c7 e0 08 ret <== NOT EXECUTED
20190a4: 81 e8 00 00 restore <== NOT EXECUTED
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
20190a8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
20190ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20190b0: 32 80 00 07 bne,a 20190cc <msdos_creat_node+0x370> <== NOT EXECUTED
20190b4: c6 0c 20 05 ldub [ %l0 + 5 ], %g3 <== NOT EXECUTED
20190b8: c4 0c 20 0e ldub [ %l0 + 0xe ], %g2 <== NOT EXECUTED
20190bc: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
20190c0: 32 80 00 07 bne,a 20190dc <msdos_creat_node+0x380> <== NOT EXECUTED
20190c4: d2 04 20 20 ld [ %l0 + 0x20 ], %o1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
20190c8: c6 0c 20 05 ldub [ %l0 + 5 ], %g3 <== NOT EXECUTED
20190cc: c4 04 20 34 ld [ %l0 + 0x34 ], %g2 <== NOT EXECUTED
20190d0: 92 00 7f fe add %g1, -2, %o1 <== NOT EXECUTED
20190d4: 93 2a 40 03 sll %o1, %g3, %o1 <== NOT EXECUTED
20190d8: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
20190dc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
20190e0: c4 0c 20 02 ldub [ %l0 + 2 ], %g2 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
20190e4: d4 14 00 00 lduh [ %l0 ], %o2 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
20190e8: 85 30 40 02 srl %g1, %g2, %g2 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
20190ec: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
20190f0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20190f4: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
20190f8: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
20190fc: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
2019100: 7f ff eb d7 call 201405c <_fat_block_read> <== NOT EXECUTED
2019104: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
2019108: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201910c: 06 80 00 26 bl 20191a4 <msdos_creat_node+0x448> <== NOT EXECUTED
2019110: c4 0f bf ad ldub [ %fp + -83 ], %g2 <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
2019114: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
2019118: c4 2f bf 8d stb %g2, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
201911c: c4 17 bf ae lduh [ %fp + -82 ], %g2 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
2019120: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
2019124: c4 37 bf 8e sth %g2, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
2019128: c4 17 bf b0 lduh [ %fp + -80 ], %g2 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
201912c: c2 2f bf 8b stb %g1, [ %fp + -117 ] <== NOT EXECUTED
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
2019130: c4 37 bf 90 sth %g2, [ %fp + -112 ] <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
2019134: c4 07 bf bc ld [ %fp + -68 ], %g2 <== NOT EXECUTED
2019138: c4 27 bf 9c st %g2, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
201913c: c4 17 bf ba lduh [ %fp + -70 ], %g2 <== NOT EXECUTED
2019140: c4 37 bf 9a sth %g2, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
2019144: c4 17 bf b4 lduh [ %fp + -76 ], %g2 <== NOT EXECUTED
2019148: 10 bf ff 53 b 2018e94 <msdos_creat_node+0x138> <== NOT EXECUTED
201914c: c4 37 bf 94 sth %g2, [ %fp + -108 ] <== NOT EXECUTED
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
2019150: 80 a0 60 00 cmp %g1, 0
2019154: 32 bf ff 8f bne,a 2018f90 <msdos_creat_node+0x234> <== NEVER TAKEN
2019158: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
201915c: c2 0c 20 0e ldub [ %l0 + 0xe ], %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)) &&
2019160: 82 08 60 04 and %g1, 4, %g1
2019164: 80 88 60 ff btst 0xff, %g1
2019168: 22 bf ff 8a be,a 2018f90 <msdos_creat_node+0x234> <== ALWAYS TAKEN
201916c: 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;
2019170: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
2019174: 10 bf ff 95 b 2018fc8 <msdos_creat_node+0x26c> <== NOT EXECUTED
2019178: c0 37 bf f4 clrh [ %fp + -12 ] <== NOT EXECUTED
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
201917c: 40 00 0f d4 call 201d0cc <__errno> <== NOT EXECUTED
2019180: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
2019184: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
2019188: 10 bf ff 4c b 2018eb8 <msdos_creat_node+0x15c> <== NOT EXECUTED
201918c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
name_type = msdos_long_to_short (name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
rtems_set_errno_and_return_minus_one(EINVAL);
2019190: 40 00 0f cf call 201d0cc <__errno> <== NOT EXECUTED
2019194: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
2019198: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201919c: 10 bf ff 47 b 2018eb8 <msdos_creat_node+0x15c> <== NOT EXECUTED
20191a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
20191a4: 10 bf ff 45 b 2018eb8 <msdos_creat_node+0x15c> <== NOT EXECUTED
20191a8: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
0201c1e4 <msdos_date_dos2unix>:
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
201c1e4: 09 00 80 bc sethi %hi(0x202f000), %g4
201c1e8: da 11 22 0a lduh [ %g4 + 0x20a ], %o5 ! 202f20a <lastdosdate>
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
201c1ec: 86 0a 67 e0 and %o1, 0x7e0, %g3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
201c1f0: 85 32 60 0b srl %o1, 0xb, %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
201c1f4: 83 30 e0 04 srl %g3, 4, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
201c1f8: 84 08 a0 1f and %g2, 0x1f, %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
201c1fc: 86 20 c0 01 sub %g3, %g1, %g3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
201c200: 99 28 a0 03 sll %g2, 3, %o4
201c204: 83 28 a0 07 sll %g2, 7, %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)
201c208: 92 0a 60 1f and %o1, 0x1f, %o1
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
201c20c: 82 20 40 0c sub %g1, %o4, %g1
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
201c210: 80 a3 40 08 cmp %o5, %o0
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;
201c214: 85 28 60 04 sll %g1, 4, %g2
201c218: 82 20 80 01 sub %g2, %g1, %g1
201c21c: 82 00 40 03 add %g1, %g3, %g1
201c220: 92 00 40 09 add %g1, %o1, %o1
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
201c224: 02 80 00 3a be 201c30c <msdos_date_dos2unix+0x128>
201c228: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
201c22c: d0 31 22 0a sth %o0, [ %g4 + 0x20a ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
201c230: 82 10 20 00 clr %g1
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
201c234: 89 32 20 09 srl %o0, 9, %g4
for (y = 0; y < year; y++)
201c238: 84 10 20 00 clr %g2
201c23c: 88 89 20 7f andcc %g4, 0x7f, %g4
201c240: 12 80 00 08 bne 201c260 <msdos_date_dos2unix+0x7c> <== ALWAYS TAKEN
201c244: 86 10 21 6e mov 0x16e, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
201c248: 10 80 00 2f b 201c304 <msdos_date_dos2unix+0x120> <== NOT EXECUTED
201c24c: 09 00 80 ba sethi %hi(0x202e800), %g4 <== NOT EXECUTED
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
201c250: 86 08 a0 03 and %g2, 3, %g3
201c254: 80 a0 00 03 cmp %g0, %g3
201c258: 86 60 3f ff subx %g0, -1, %g3
201c25c: 86 00 e1 6d add %g3, 0x16d, %g3
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
201c260: 84 00 a0 01 inc %g2
201c264: 80 a0 80 04 cmp %g2, %g4
201c268: 12 bf ff fa bne 201c250 <msdos_date_dos2unix+0x6c>
201c26c: 82 00 40 03 add %g1, %g3, %g1
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
201c270: 80 88 a0 03 btst 3, %g2
201c274: 02 80 00 24 be 201c304 <msdos_date_dos2unix+0x120> <== ALWAYS TAKEN
201c278: 09 00 80 ba sethi %hi(0x202e800), %g4
201c27c: 09 00 80 ba sethi %hi(0x202e800), %g4 <== NOT EXECUTED
201c280: 88 11 22 a8 or %g4, 0x2a8, %g4 ! 202eaa8 <regyear> <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
201c284: 9a 0a 21 e0 and %o0, 0x1e0, %o5
201c288: 9b 33 60 05 srl %o5, 5, %o5
if (month == 0) {
201c28c: 80 a3 60 00 cmp %o5, 0
201c290: 22 80 00 0d be,a 201c2c4 <msdos_date_dos2unix+0xe0> <== NEVER TAKEN
201c294: 90 0a 20 1f and %o0, 0x1f, %o0 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
201c298: 80 a3 60 01 cmp %o5, 1
201c29c: 02 80 00 09 be 201c2c0 <msdos_date_dos2unix+0xdc> <== ALWAYS TAKEN
201c2a0: 84 10 20 00 clr %g2
* Convert from dos' idea of time to unix'. This will probably only be
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
201c2a4: 9a 03 7f ff add %o5, -1, %o5 <== NOT EXECUTED
201c2a8: 9b 2b 60 01 sll %o5, 1, %o5 <== NOT EXECUTED
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
days += months[m];
201c2ac: c6 11 00 02 lduh [ %g4 + %g2 ], %g3 <== NOT EXECUTED
201c2b0: 84 00 a0 02 add %g2, 2, %g2 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
201c2b4: 80 a0 80 0d cmp %g2, %o5 <== NOT EXECUTED
201c2b8: 12 bf ff fd bne 201c2ac <msdos_date_dos2unix+0xc8> <== NOT EXECUTED
201c2bc: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
201c2c0: 90 0a 20 1f and %o0, 0x1f, %o0
201c2c4: 90 02 3f ff add %o0, -1, %o0
201c2c8: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
201c2cc: 85 28 60 07 sll %g1, 7, %g2
201c2d0: 83 28 60 09 sll %g1, 9, %g1
201c2d4: 82 20 40 02 sub %g1, %g2, %g1
201c2d8: 85 28 60 04 sll %g1, 4, %g2
201c2dc: 82 20 80 01 sub %g2, %g1, %g1
201c2e0: 85 28 60 04 sll %g1, 4, %g2
201c2e4: 82 20 80 01 sub %g2, %g1, %g1
201c2e8: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
201c2ec: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_END+0x108ea600>
201c2f0: 90 00 40 02 add %g1, %g2, %o0
201c2f4: 05 00 80 bc sethi %hi(0x202f000), %g2
201c2f8: d0 20 a2 0c st %o0, [ %g2 + 0x20c ] ! 202f20c <lastseconds>
}
return seconds + lastseconds;
}
201c2fc: 81 c3 e0 08 retl
201c300: 90 02 00 09 add %o0, %o1, %o0
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
201c304: 10 bf ff e0 b 201c284 <msdos_date_dos2unix+0xa0>
201c308: 88 11 22 c0 or %g4, 0x2c0, %g4
201c30c: 03 00 80 bc sethi %hi(0x202f000), %g1
201c310: d0 00 62 0c ld [ %g1 + 0x20c ], %o0 ! 202f20c <lastseconds>
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
}
return seconds + lastseconds;
}
201c314: 81 c3 e0 08 retl
201c318: 90 02 00 09 add %o0, %o1, %o0
0201c06c <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)
{
201c06c: 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) {
201c070: 03 00 80 bc sethi %hi(0x202f000), %g1
201c074: c4 00 61 fc ld [ %g1 + 0x1fc ], %g2 ! 202f1fc <lasttime>
201c078: 80 a0 80 18 cmp %g2, %i0
201c07c: 02 80 00 4d be 201c1b0 <msdos_date_unix2dos+0x144>
201c080: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
201c084: f0 20 61 fc st %i0, [ %g1 + 0x1fc ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
201c088: 7f ff 99 7b call 2002674 <.udiv>
201c08c: 90 10 00 18 mov %i0, %o0
201c090: 40 00 39 59 call 202a5f4 <.urem>
201c094: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
201c098: 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)
201c09c: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
201c0a0: 7f ff 99 75 call 2002674 <.udiv>
201c0a4: 90 10 00 18 mov %i0, %o0
201c0a8: 40 00 39 53 call 202a5f4 <.urem>
201c0ac: 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)
201c0b0: 83 2a 20 0b sll %o0, 0xb, %g1
201c0b4: 92 10 20 3c mov 0x3c, %o1
201c0b8: ba 07 40 01 add %i5, %g1, %i5
201c0bc: 40 00 39 4e call 202a5f4 <.urem>
201c0c0: 90 10 00 18 mov %i0, %o0
201c0c4: 05 00 80 bc sethi %hi(0x202f000), %g2
201c0c8: 91 32 20 01 srl %o0, 1, %o0
201c0cc: 82 07 40 08 add %i5, %o0, %g1
/*
* 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);
201c0d0: 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)
201c0d4: c2 30 a2 00 sth %g1, [ %g2 + 0x200 ]
201c0d8: ba 10 00 01 mov %g1, %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);
201c0dc: 90 10 00 18 mov %i0, %o0
201c0e0: 7f ff 99 65 call 2002674 <.udiv>
201c0e4: 92 12 61 80 or %o1, 0x180, %o1
if (days != lastday) {
201c0e8: 03 00 80 bc sethi %hi(0x202f000), %g1
201c0ec: c4 00 62 04 ld [ %g1 + 0x204 ], %g2 ! 202f204 <lastday>
201c0f0: 80 a2 00 02 cmp %o0, %g2
201c0f4: 22 80 00 37 be,a 201c1d0 <msdos_date_unix2dos+0x164>
201c0f8: 03 00 80 bc sethi %hi(0x202f000), %g1
lastday = days;
201c0fc: d0 20 62 04 st %o0, [ %g1 + 0x204 ] ! 202f204 <lastday>
for (year = 1970;; year++) {
201c100: 10 80 00 03 b 201c10c <msdos_date_unix2dos+0xa0>
201c104: 82 10 27 b2 mov 0x7b2, %g1
201c108: 82 00 60 01 inc %g1
inc = year & 0x03 ? 365 : 366;
201c10c: 86 08 60 03 and %g1, 3, %g3
201c110: 80 a0 00 03 cmp %g0, %g3
201c114: 84 60 3f ff subx %g0, -1, %g2
201c118: 84 00 a1 6d add %g2, 0x16d, %g2
if (days < inc)
201c11c: 80 a2 00 02 cmp %o0, %g2
201c120: 3a bf ff fa bcc,a 201c108 <msdos_date_unix2dos+0x9c>
201c124: 90 22 00 02 sub %o0, %g2, %o0
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
201c128: 80 a0 e0 00 cmp %g3, 0
201c12c: 02 80 00 1d be 201c1a0 <msdos_date_unix2dos+0x134> <== ALWAYS TAKEN
201c130: 09 00 80 ba sethi %hi(0x202e800), %g4
201c134: 09 00 80 ba sethi %hi(0x202e800), %g4 <== NOT EXECUTED
201c138: 88 11 22 a8 or %g4, 0x2a8, %g4 ! 202eaa8 <regyear> <== NOT EXECUTED
for (month = 0; month < 12; month++) {
201c13c: 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,
201c140: 87 28 a0 01 sll %g2, 1, %g3
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
if (days < months[month])
201c144: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
201c148: 80 a0 c0 08 cmp %g3, %o0
201c14c: 18 80 00 17 bgu 201c1a8 <msdos_date_unix2dos+0x13c> <== ALWAYS TAKEN
201c150: 84 00 a0 01 inc %g2
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
201c154: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
201c158: 12 bf ff fa bne 201c140 <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
201c15c: 90 22 00 03 sub %o0, %g3, %o0 <== NOT EXECUTED
201c160: 84 10 21 a0 mov 0x1a0, %g2 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
201c164: 84 00 a0 01 inc %g2
* 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)
201c168: 80 a0 67 bc cmp %g1, 0x7bc
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
201c16c: 90 00 80 08 add %g2, %o0, %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)
201c170: 08 80 00 06 bleu 201c188 <msdos_date_unix2dos+0x11c> <== NEVER TAKEN
201c174: 84 10 00 08 mov %o0, %g2
lastddate += (year - 1980) <<
201c178: 82 00 78 44 add %g1, -1980, %g1
201c17c: 83 28 60 09 sll %g1, 9, %g1
201c180: 90 02 00 01 add %o0, %g1, %o0
201c184: 84 10 00 08 mov %o0, %g2
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
201c188: fa 36 80 00 sth %i5, [ %i2 ]
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
lastddate += (year - 1980) <<
201c18c: 03 00 80 bc sethi %hi(0x202f000), %g1
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
201c190: c4 36 40 00 sth %g2, [ %i1 ]
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
lastddate += (year - 1980) <<
201c194: d0 30 62 08 sth %o0, [ %g1 + 0x208 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
201c198: 81 c7 e0 08 ret
201c19c: 81 e8 00 00 restore
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
201c1a0: 10 bf ff e7 b 201c13c <msdos_date_unix2dos+0xd0>
201c1a4: 88 11 22 c0 or %g4, 0x2c0, %g4
201c1a8: 10 bf ff ef b 201c164 <msdos_date_unix2dos+0xf8>
201c1ac: 85 28 a0 05 sll %g2, 5, %g2
201c1b0: 03 00 80 bc sethi %hi(0x202f000), %g1
201c1b4: fa 10 62 00 lduh [ %g1 + 0x200 ], %i5 ! 202f200 <lastdtime>
201c1b8: 03 00 80 bc sethi %hi(0x202f000), %g1
201c1bc: c4 10 62 08 lduh [ %g1 + 0x208 ], %g2 ! 202f208 <lastddate>
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
201c1c0: fa 36 80 00 sth %i5, [ %i2 ]
*ddp = lastddate;
201c1c4: c4 36 40 00 sth %g2, [ %i1 ]
201c1c8: 81 c7 e0 08 ret
201c1cc: 81 e8 00 00 restore
201c1d0: c4 10 62 08 lduh [ %g1 + 0x208 ], %g2
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
201c1d4: fa 36 80 00 sth %i5, [ %i2 ]
*ddp = lastddate;
201c1d8: c4 36 40 00 sth %g2, [ %i1 ]
201c1dc: 81 c7 e0 08 ret
201c1e0: 81 e8 00 00 restore
0201996c <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
)
{
201996c: 9d e3 bf a0 save %sp, -96, %sp
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2019970: e0 06 20 08 ld [ %i0 + 8 ], %l0
*/
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,
2019974: 25 00 80 b5 sethi %hi(0x202d400), %l2
2019978: e2 14 00 00 lduh [ %l0 ], %l1
201997c: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
2019980: 29 00 80 b5 sethi %hi(0x202d400), %l4
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;
2019984: 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;
2019988: a6 10 20 00 clr %l3
201998c: a3 2c 60 10 sll %l1, 0x10, %l1
*/
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,
2019990: a4 14 a3 68 or %l2, 0x368, %l2
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
2019994: a8 15 23 78 or %l4, 0x378, %l4
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
2019998: a3 34 60 10 srl %l1, 0x10, %l1
201999c: 92 10 00 13 mov %l3, %o1
20199a0: 7f ff a2 fb call 200258c <.umul>
20199a4: 90 10 00 11 mov %l1, %o0
20199a8: 92 10 00 19 mov %i1, %o1
20199ac: 94 10 00 08 mov %o0, %o2
20199b0: 96 10 00 11 mov %l1, %o3
20199b4: 90 10 00 10 mov %l0, %o0
20199b8: 7f ff e6 51 call 20132fc <fat_file_read>
20199bc: 98 10 00 15 mov %l5, %o4
20199c0: 80 a2 20 00 cmp %o0, 0
20199c4: 02 80 00 34 be 2019a94 <msdos_dir_is_empty+0x128> <== NEVER TAKEN
20199c8: 80 a2 20 1f cmp %o0, 0x1f
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
20199cc: 04 80 00 27 ble 2019a68 <msdos_dir_is_empty+0xfc> <== NEVER TAKEN
20199d0: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
20199d4: e2 14 00 00 lduh [ %l0 ], %l1
20199d8: a3 2c 60 10 sll %l1, 0x10, %l1
20199dc: b1 34 60 10 srl %l1, 0x10, %i0
20199e0: 80 a6 00 08 cmp %i0, %o0
20199e4: 12 80 00 2e bne 2019a9c <msdos_dir_is_empty+0x130> <== NEVER TAKEN
20199e8: 80 a6 20 00 cmp %i0, 0
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
20199ec: 02 80 00 27 be 2019a88 <msdos_dir_is_empty+0x11c> <== NEVER TAKEN
20199f0: b8 10 20 00 clr %i4
20199f4: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
20199f8: ba 10 00 15 mov %l5, %i5
* 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)) ==
20199fc: f6 0f 40 00 ldub [ %i5 ], %i3
2019a00: 80 a6 e0 e5 cmp %i3, 0xe5
2019a04: 22 80 00 1c be,a 2019a74 <msdos_dir_is_empty+0x108> <== NEVER TAKEN
2019a08: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
2019a0c: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
2019a10: 82 08 60 3f and %g1, 0x3f, %g1
2019a14: 80 a0 60 0f cmp %g1, 0xf
2019a18: 02 80 00 16 be 2019a70 <msdos_dir_is_empty+0x104> <== NEVER TAKEN
2019a1c: 90 10 00 1d mov %i5, %o0
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
2019a20: 92 10 00 12 mov %l2, %o1
2019a24: 40 00 16 c4 call 201f534 <strncmp>
2019a28: 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) ||
2019a2c: 80 a2 20 00 cmp %o0, 0
2019a30: 22 80 00 11 be,a 2019a74 <msdos_dir_is_empty+0x108>
2019a34: b8 07 20 20 add %i4, 0x20, %i4
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
2019a38: 90 10 00 1d mov %i5, %o0
2019a3c: 92 10 00 14 mov %l4, %o1
2019a40: 40 00 16 bd call 201f534 <strncmp>
2019a44: 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) ||
2019a48: 80 a2 20 00 cmp %o0, 0
2019a4c: 22 80 00 0a be,a 2019a74 <msdos_dir_is_empty+0x108>
2019a50: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
2019a54: 80 a6 e0 00 cmp %i3, 0
2019a58: 12 80 00 04 bne 2019a68 <msdos_dir_is_empty+0xfc>
2019a5c: b0 10 20 00 clr %i0
*/
return RC_OK;
}
j++;
}
*ret_val = true;
2019a60: 82 10 20 01 mov 1, %g1
2019a64: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
2019a68: 81 c7 e0 08 ret
2019a6c: 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;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2019a70: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
2019a74: 80 a7 00 18 cmp %i4, %i0
2019a78: 0a bf ff e1 bcs 20199fc <msdos_dir_is_empty+0x90> <== ALWAYS TAKEN
2019a7c: ba 07 60 20 add %i5, 0x20, %i5
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
2019a80: 10 bf ff c6 b 2019998 <msdos_dir_is_empty+0x2c> <== NOT EXECUTED
2019a84: a6 04 e0 01 inc %l3 <== NOT EXECUTED
2019a88: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5 <== NOT EXECUTED
2019a8c: 10 bf ff c3 b 2019998 <msdos_dir_is_empty+0x2c> <== NOT EXECUTED
2019a90: a6 04 e0 01 inc %l3 <== NOT EXECUTED
}
*ret_val = true;
return RC_OK;
2019a94: 10 bf ff f3 b 2019a60 <msdos_dir_is_empty+0xf4> <== NOT EXECUTED
2019a98: b0 10 20 00 clr %i0 <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
2019a9c: 11 00 80 b5 sethi %hi(0x202d400), %o0 <== NOT EXECUTED
2019aa0: 15 00 80 b5 sethi %hi(0x202d400), %o2 <== NOT EXECUTED
2019aa4: 17 00 80 b5 sethi %hi(0x202d400), %o3 <== NOT EXECUTED
2019aa8: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
2019aac: 92 10 23 65 mov 0x365, %o1 <== NOT EXECUTED
2019ab0: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED
2019ab4: 7f ff ef bf call 20159b0 <__assert_func> <== NOT EXECUTED
2019ab8: 96 12 e3 48 or %o3, 0x348, %o3 <== NOT EXECUTED
0201c520 <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)
{
201c520: 9d e3 be 60 save %sp, -416, %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;
201c524: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
201c528: d0 1e 20 08 ldd [ %i0 + 8 ], %o0 <== NOT EXECUTED
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201c52c: ea 06 20 1c ld [ %i0 + 0x1c ], %l5 <== 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);
201c530: 94 10 20 00 clr %o2 <== NOT EXECUTED
201c534: 96 10 21 18 mov 0x118, %o3 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
201c538: a4 10 00 18 mov %i0, %l2 <== 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;
201c53c: c0 27 be d0 clr [ %fp + -304 ] <== 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;
201c540: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== 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);
201c544: 7f ff 97 27 call 20021e0 <__divdi3> <== NOT EXECUTED
201c548: c0 27 be d4 clr [ %fp + -300 ] <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
201c54c: 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);
201c550: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
201c554: 7f ff 98 48 call 2002674 <.udiv> <== NOT EXECUTED
201c558: 92 10 21 18 mov 0x118, %o1 <== 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 :
201c55c: c2 05 60 20 ld [ %l5 + 0x20 ], %g1 <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
201c560: a3 2a 20 03 sll %o0, 3, %l1 <== 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 :
201c564: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
201c568: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
201c56c: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED
201c570: a3 2a 20 03 sll %o0, 3, %l1 <== 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 :
201c574: 02 80 00 f2 be 201c93c <msdos_dir_read+0x41c> <== NOT EXECUTED
201c578: a2 24 40 08 sub %l1, %o0, %l1 <== NOT EXECUTED
201c57c: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
201c580: c2 27 be c4 st %g1, [ %fp + -316 ] <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201c584: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
201c588: 92 10 20 00 clr %o1 <== NOT EXECUTED
201c58c: 7f ff b5 f9 call 2009d70 <rtems_semaphore_obtain> <== NOT EXECUTED
201c590: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201c594: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201c598: 12 80 01 37 bne 201ca74 <msdos_dir_read+0x554> <== NOT EXECUTED
201c59c: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
201c5a0: 02 80 00 3a be 201c688 <msdos_dir_read+0x168> <== NOT EXECUTED
201c5a4: b8 10 20 00 clr %i4 <== NOT EXECUTED
201c5a8: a6 10 20 00 clr %l3 <== NOT EXECUTED
201c5ac: a8 10 20 00 clr %l4 <== NOT EXECUTED
201c5b0: c0 2f be cf clrb [ %fp + -305 ] <== NOT EXECUTED
201c5b4: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
201c5b8: a0 10 20 00 clr %l0 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
201c5bc: d8 06 20 a0 ld [ %i0 + 0xa0 ], %o4 <== NOT EXECUTED
201c5c0: d6 07 be c4 ld [ %fp + -316 ], %o3 <== NOT EXECUTED
201c5c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c5c8: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201c5cc: 7f ff db 4c call 20132fc <fat_file_read> <== NOT EXECUTED
201c5d0: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
201c5d4: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
201c5d8: 04 80 01 1e ble 201ca50 <msdos_dir_read+0x530> <== NOT EXECUTED
201c5dc: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
201c5e0: fa 06 20 a0 ld [ %i0 + 0xa0 ], %i5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
201c5e4: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
201c5e8: 86 88 a0 ff andcc %g2, 0xff, %g3 <== NOT EXECUTED
201c5ec: 02 80 00 ce be 201c924 <msdos_dir_read+0x404> <== NOT EXECUTED
201c5f0: ae 10 20 00 clr %l7 <== 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)
201c5f4: 10 80 00 0f b 201c630 <msdos_dir_read+0x110> <== NOT EXECUTED
201c5f8: 80 a0 e0 e5 cmp %g3, 0xe5 <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
201c5fc: 80 a0 e0 0f cmp %g3, 0xf <== NOT EXECUTED
201c600: 02 80 00 28 be 201c6a0 <msdos_dir_read+0x180> <== NOT EXECUTED
201c604: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
201c608: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
201c60c: 80 a5 c0 16 cmp %l7, %l6 <== NOT EXECUTED
201c610: 1a 80 00 1a bcc 201c678 <msdos_dir_read+0x158> <== NOT EXECUTED
201c614: c2 07 be c4 ld [ %fp + -316 ], %g1 <== NOT EXECUTED
{
char* entry = (char*) fs_info->cl_buf + i;
201c618: fa 06 20 a0 ld [ %i0 + 0xa0 ], %i5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
201c61c: c4 0f 40 17 ldub [ %i5 + %l7 ], %g2 <== NOT EXECUTED
201c620: 86 88 a0 ff andcc %g2, 0xff, %g3 <== NOT EXECUTED
201c624: 02 80 00 c0 be 201c924 <msdos_dir_read+0x404> <== NOT EXECUTED
201c628: ba 07 40 17 add %i5, %l7, %i5 <== 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)
201c62c: 80 a0 e0 e5 cmp %g3, 0xe5 <== NOT EXECUTED
201c630: 22 bf ff f7 be,a 201c60c <msdos_dir_read+0xec> <== NOT EXECUTED
201c634: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
201c638: c6 0f 60 0b ldub [ %i5 + 0xb ], %g3 <== NOT EXECUTED
201c63c: b8 08 e0 08 and %g3, 8, %i4 <== NOT EXECUTED
201c640: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
201c644: 12 bf ff ee bne 201c5fc <msdos_dir_read+0xdc> <== NOT EXECUTED
201c648: 86 08 e0 3f and %g3, 0x3f, %g3 <== 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) ==
201c64c: 80 a0 e0 0f cmp %g3, 0xf <== NOT EXECUTED
201c650: 02 80 00 13 be 201c69c <msdos_dir_read+0x17c> <== NOT EXECUTED
201c654: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
201c658: 02 80 00 3c be 201c748 <msdos_dir_read+0x228> <== NOT EXECUTED
201c65c: 90 10 00 18 mov %i0, %o0 <== 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)
201c660: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
* Skip active entries until get the entry to start from.
*/
if (start)
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
201c664: b6 06 ff ff add %i3, -1, %i3 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
201c668: 80 a5 c0 16 cmp %l7, %l6 <== NOT EXECUTED
201c66c: 0a bf ff eb bcs 201c618 <msdos_dir_read+0xf8> <== NOT EXECUTED
201c670: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
201c674: c2 07 be c4 ld [ %fp + -316 ], %g1 <== 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)
201c678: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
201c67c: 12 bf ff d0 bne 201c5bc <msdos_dir_read+0x9c> <== NOT EXECUTED
201c680: a6 04 c0 01 add %l3, %g1, %l3 <== NOT EXECUTED
201c684: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
201c688: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
201c68c: 7f ff b6 08 call 2009eac <rtems_semaphore_release> <== NOT EXECUTED
201c690: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
return cmpltd;
}
201c694: 81 c7 e0 08 ret <== NOT EXECUTED
201c698: 81 e8 00 00 restore <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
201c69c: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
201c6a0: 02 80 00 93 be 201c8ec <msdos_dir_read+0x3cc> <== NOT EXECUTED
201c6a4: 86 08 a0 40 and %g2, 0x40, %g3 <== 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) &
201c6a8: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
201c6ac: 84 08 a0 3f and %g2, 0x3f, %g2 <== NOT EXECUTED
201c6b0: 80 a0 80 14 cmp %g2, %l4 <== NOT EXECUTED
201c6b4: 22 80 00 04 be,a 201c6c4 <msdos_dir_read+0x1a4> <== NOT EXECUTED
201c6b8: d8 0f 60 0d ldub [ %i5 + 0xd ], %o4 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
201c6bc: 10 bf ff d3 b 201c608 <msdos_dir_read+0xe8> <== NOT EXECUTED
201c6c0: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
201c6c4: c4 0f be cf ldub [ %fp + -305 ], %g2 <== NOT EXECUTED
201c6c8: 86 0b 20 ff and %o4, 0xff, %g3 <== NOT EXECUTED
201c6cc: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
201c6d0: 32 bf ff ce bne,a 201c608 <msdos_dir_read+0xe8> <== NOT EXECUTED
201c6d4: 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--;
201c6d8: a8 05 3f ff add %l4, -1, %l4 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
201c6dc: 85 2d 20 02 sll %l4, 2, %g2 <== NOT EXECUTED
201c6e0: 95 2d 20 04 sll %l4, 4, %o2 <== 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;
201c6e4: ba 07 60 01 inc %i5 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
201c6e8: 94 22 80 02 sub %o2, %g2, %o2 <== NOT EXECUTED
201c6ec: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
201c6f0: 94 02 80 14 add %o2, %l4, %o2 <== NOT EXECUTED
201c6f4: 84 10 00 0a mov %o2, %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)
201c6f8: 82 07 be e8 add %fp, -280, %g1 <== NOT EXECUTED
201c6fc: 86 20 80 0a sub %g2, %o2, %g3 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
201c700: 80 a0 a0 fe cmp %g2, 0xfe <== NOT EXECUTED
201c704: 18 80 00 99 bgu 201c968 <msdos_dir_read+0x448> <== NOT EXECUTED
201c708: 9e 00 40 02 add %g1, %g2, %o7 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
201c70c: d6 0f 40 00 ldub [ %i5 ], %o3 <== NOT EXECUTED
201c710: d6 2b e0 14 stb %o3, [ %o7 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
201c714: de 4f 40 00 ldsb [ %i5 ], %o7 <== NOT EXECUTED
201c718: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
201c71c: 02 80 00 93 be 201c968 <msdos_dir_read+0x448> <== NOT EXECUTED
201c720: 84 00 a0 01 inc %g2 <== NOT EXECUTED
break;
switch (q)
201c724: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
201c728: 02 80 00 92 be 201c970 <msdos_dir_read+0x450> <== NOT EXECUTED
201c72c: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
201c730: 02 80 00 93 be 201c97c <msdos_dir_read+0x45c> <== NOT EXECUTED
201c734: 80 a7 20 0d cmp %i4, 0xd <== 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++)
201c738: 02 80 00 8c be 201c968 <msdos_dir_read+0x448> <== NOT EXECUTED
201c73c: ba 07 60 02 add %i5, 2, %i5 <== NOT EXECUTED
201c740: 10 bf ff ef b 201c6fc <msdos_dir_read+0x1dc> <== NOT EXECUTED
201c744: b8 07 20 01 inc %i4 <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
201c748: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201c74c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201c750: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED
201c754: 7f ff db de call 20136cc <fat_file_ioctl> <== NOT EXECUTED
201c758: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
201c75c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201c760: 12 bf ff ca bne 201c688 <msdos_dir_read+0x168> <== NOT EXECUTED
201c764: c4 07 be d4 ld [ %fp + -300 ], %g2 <== 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;
201c768: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
201c76c: c4 27 be d8 st %g2, [ %fp + -296 ] <== NOT EXECUTED
201c770: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
201c774: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
201c778: ee 27 be dc st %l7, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
201c77c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c780: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
201c784: 7f ff da 2a call 201302c <fat_file_open> <== NOT EXECUTED
201c788: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
201c78c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201c790: 12 bf ff be bne 201c688 <msdos_dir_read+0x168> <== NOT EXECUTED
201c794: c4 07 be d0 ld [ %fp + -304 ], %g2 <== 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);
201c798: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
201c79c: c4 00 a0 0c ld [ %g2 + 0xc ], %g2 <== 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;
201c7a0: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
201c7a4: e0 27 be f4 st %l0, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
201c7a8: c2 37 be f8 sth %g1, [ %fp + -264 ] <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
201c7ac: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
201c7b0: 02 80 00 35 be 201c884 <msdos_dir_read+0x364> <== NOT EXECUTED
201c7b4: c4 27 be e8 st %g2, [ %fp + -280 ] <== 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)
201c7b8: 9e 07 60 0b add %i5, 0xb, %o7 <== NOT EXECUTED
201c7bc: 84 10 00 1d mov %i5, %g2 <== NOT EXECUTED
201c7c0: b8 10 20 00 clr %i4 <== 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;
201c7c4: 10 80 00 06 b 201c7dc <msdos_dir_read+0x2bc> <== NOT EXECUTED
201c7c8: 86 10 20 00 clr %g3 <== NOT EXECUTED
201c7cc: 80 a0 00 0c cmp %g0, %o4 <== NOT EXECUTED
201c7d0: 86 40 3f ff addx %g0, -1, %g3 <== NOT EXECUTED
201c7d4: 86 08 e0 80 and %g3, 0x80, %g3 <== NOT EXECUTED
201c7d8: 86 00 ff 80 add %g3, -128, %g3 <== NOT EXECUTED
201c7dc: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
201c7e0: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED
201c7e4: b9 37 20 01 srl %i4, 1, %i4 <== NOT EXECUTED
201c7e8: b8 03 00 1c add %o4, %i4, %i4 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
201c7ec: 84 00 a0 01 inc %g2 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
201c7f0: 86 07 00 03 add %i4, %g3, %g3 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
201c7f4: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
201c7f8: 98 08 e0 01 and %g3, 1, %o4 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
201c7fc: 12 bf ff f4 bne 201c7cc <msdos_dir_read+0x2ac> <== NOT EXECUTED
201c800: b8 10 00 03 mov %g3, %i4 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
201c804: c2 0f be cf ldub [ %fp + -305 ], %g1 <== NOT EXECUTED
201c808: b8 18 40 1c xor %g1, %i4, %i4 <== NOT EXECUTED
201c80c: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
201c810: 12 80 00 1e bne 201c888 <msdos_dir_read+0x368> <== NOT EXECUTED
201c814: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201c818: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
201c81c: 32 80 00 1c bne,a 201c88c <msdos_dir_read+0x36c> <== NOT EXECUTED
201c820: b4 07 40 09 add %i5, %o1, %i2 <== 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);
201c824: 40 00 0b 12 call 201f46c <strlen> <== NOT EXECUTED
201c828: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
201c82c: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
201c830: 90 06 40 10 add %i1, %l0, %o0 <== NOT EXECUTED
201c834: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
201c838: 40 00 04 e4 call 201dbc8 <memcpy> <== NOT EXECUTED
201c83c: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
201c840: c4 1c a0 08 ldd [ %l2 + 8 ], %g2 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
201c844: d2 07 be d0 ld [ %fp + -304 ], %o1 <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
201c848: ba 80 e1 18 addcc %g3, 0x118, %i5 <== NOT EXECUTED
201c84c: b8 40 a0 00 addx %g2, 0, %i4 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
201c850: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
201c854: f8 3c a0 08 std %i4, [ %l2 + 8 ] <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
201c858: 7f ff db 6f call 2013614 <fat_file_close> <== NOT EXECUTED
201c85c: a0 04 21 18 add %l0, 0x118, %l0 <== 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));
201c860: a2 04 7e e8 add %l1, -280, %l1 <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
if (rc != RC_OK)
201c864: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201c868: 12 bf ff 88 bne 201c688 <msdos_dir_read+0x168> <== NOT EXECUTED
201c86c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
201c870: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
201c874: 32 bf ff 66 bne,a 201c60c <msdos_dir_read+0xec> <== NOT EXECUTED
201c878: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
201c87c: 10 bf ff 83 b 201c688 <msdos_dir_read+0x168> <== NOT EXECUTED
201c880: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
201c884: 92 10 20 08 mov 8, %o1 <== 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)
201c888: b4 07 40 09 add %i5, %o1, %i2 <== 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) &&
201c88c: c4 4e bf ff ldsb [ %i2 + -1 ], %g2 <== NOT EXECUTED
201c890: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
201c894: 12 80 00 3d bne 201c988 <msdos_dir_read+0x468> <== NOT EXECUTED
201c898: 03 00 80 ba sethi %hi(0x202e800), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
201c89c: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
201c8a0: 32 bf ff fb bne,a 201c88c <msdos_dir_read+0x36c> <== NOT EXECUTED
201c8a4: b4 07 40 09 add %i5, %o1, %i2 <== 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(
201c8a8: 86 07 be fc add %fp, -260, %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) &&
201c8ac: c4 4f 60 0a ldsb [ %i5 + 0xa ], %g2 <== NOT EXECUTED
201c8b0: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
201c8b4: 12 80 00 46 bne 201c9cc <msdos_dir_read+0x4ac> <== NOT EXECUTED
201c8b8: 98 10 20 03 mov 3, %o4 <== NOT EXECUTED
201c8bc: c4 4f 60 09 ldsb [ %i5 + 9 ], %g2 <== NOT EXECUTED
201c8c0: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
201c8c4: 32 80 00 42 bne,a 201c9cc <msdos_dir_read+0x4ac> <== NOT EXECUTED
201c8c8: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
201c8cc: c4 4f 60 08 ldsb [ %i5 + 8 ], %g2 <== NOT EXECUTED
201c8d0: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
201c8d4: 12 80 00 3e bne 201c9cc <msdos_dir_read+0x4ac> <== NOT EXECUTED
201c8d8: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
201c8dc: c0 28 c0 00 clrb [ %g3 ] <== 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(
201c8e0: d2 37 be fa sth %o1, [ %fp + -262 ] <== NOT EXECUTED
201c8e4: 10 bf ff d3 b 201c830 <msdos_dir_read+0x310> <== NOT EXECUTED
201c8e8: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
if (lfn_start == FAT_FILE_SHORT_NAME)
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
201c8ec: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
201c8f0: 22 bf ff 47 be,a 201c60c <msdos_dir_read+0xec> <== NOT EXECUTED
201c8f4: ae 05 e0 20 add %l7, 0x20, %l7 <== 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);
201c8f8: c2 0f 60 0d ldub [ %i5 + 0xd ], %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)
201c8fc: b4 05 c0 13 add %l7, %l3, %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) &
201c900: a8 08 a0 3f and %g2, 0x3f, %l4 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
201c904: 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);
201c908: c2 2f be cf stb %g1, [ %fp + -305 ] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
201c90c: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
201c910: 92 10 20 00 clr %o1 <== NOT EXECUTED
201c914: 40 00 04 ea call 201dcbc <memset> <== NOT EXECUTED
201c918: 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) &
201c91c: 10 bf ff 64 b 201c6ac <msdos_dir_read+0x18c> <== NOT EXECUTED
201c920: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
rtems_semaphore_release(fs_info->vol_sema);
201c924: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
201c928: 7f ff b5 61 call 2009eac <rtems_semaphore_release> <== NOT EXECUTED
201c92c: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
201c930: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
201c934: 81 c7 e0 08 ret <== NOT EXECUTED
201c938: 81 e8 00 00 restore <== 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) &&
201c93c: c2 05 60 24 ld [ %l5 + 0x24 ], %g1 <== NOT EXECUTED
201c940: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201c944: 32 bf ff 0f bne,a 201c580 <msdos_dir_read+0x60> <== NOT EXECUTED
201c948: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
201c94c: c2 0e 20 0e ldub [ %i0 + 0xe ], %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) &&
201c950: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
201c954: 22 bf ff 0b be,a 201c580 <msdos_dir_read+0x60> <== NOT EXECUTED
201c958: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
201c95c: c2 05 60 18 ld [ %l5 + 0x18 ], %g1 <== NOT EXECUTED
201c960: 10 bf ff 09 b 201c584 <msdos_dir_read+0x64> <== NOT EXECUTED
201c964: c2 27 be c4 st %g1, [ %fp + -316 ] <== NOT EXECUTED
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
if (*p == '\0')
201c968: 10 bf ff c2 b 201c870 <msdos_dir_read+0x350> <== NOT EXECUTED
201c96c: d8 2f be cf stb %o4, [ %fp + -305 ] <== NOT EXECUTED
break;
switch (q)
{
case 4:
p += 5;
201c970: ba 07 60 05 add %i5, 5, %i5 <== NOT EXECUTED
201c974: 10 bf ff 61 b 201c6f8 <msdos_dir_read+0x1d8> <== NOT EXECUTED
201c978: b8 07 20 01 inc %i4 <== NOT EXECUTED
break;
case 10:
p += 4;
201c97c: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
201c980: 10 bf ff 5e b 201c6f8 <msdos_dir_read+0x1d8> <== NOT EXECUTED
201c984: b8 07 20 01 inc %i4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201c988: 84 10 00 1d mov %i5, %g2 <== NOT EXECUTED
201c98c: d8 00 62 d8 ld [ %g1 + 0x2d8 ], %o4 <== 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(
201c990: 10 80 00 06 b 201c9a8 <msdos_dir_read+0x488> <== NOT EXECUTED
201c994: 86 07 be fc add %fp, -260, %g3 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201c998: f8 28 c0 00 stb %i4, [ %g3 ] <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
201c99c: 80 a0 80 1a cmp %g2, %i2 <== NOT EXECUTED
201c9a0: 02 bf ff c3 be 201c8ac <msdos_dir_read+0x38c> <== NOT EXECUTED
201c9a4: 86 00 e0 01 inc %g3 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
201c9a8: f8 08 80 00 ldub [ %g2 ], %i4 <== NOT EXECUTED
201c9ac: 9e 03 00 1c add %o4, %i4, %o7 <== NOT EXECUTED
201c9b0: de 0b e0 01 ldub [ %o7 + 1 ], %o7 <== NOT EXECUTED
201c9b4: 9e 0b e0 03 and %o7, 3, %o7 <== NOT EXECUTED
201c9b8: 80 a3 e0 01 cmp %o7, 1 <== NOT EXECUTED
201c9bc: 12 bf ff f7 bne 201c998 <msdos_dir_read+0x478> <== NOT EXECUTED
201c9c0: 84 00 a0 01 inc %g2 <== NOT EXECUTED
201c9c4: 10 bf ff f5 b 201c998 <msdos_dir_read+0x478> <== NOT EXECUTED
201c9c8: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
201c9cc: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
201c9d0: 96 00 e0 01 add %g3, 1, %o3 <== NOT EXECUTED
201c9d4: c2 28 c0 00 stb %g1, [ %g3 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
201c9d8: 94 03 20 01 add %o4, 1, %o2 <== 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)
201c9dc: b8 03 20 08 add %o4, 8, %i4 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
201c9e0: 94 02 40 0a add %o1, %o2, %o2 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
201c9e4: 84 07 60 08 add %i5, 8, %g2 <== NOT EXECUTED
201c9e8: 03 00 80 ba sethi %hi(0x202e800), %g1 <== NOT EXECUTED
while (i-- > 0) {
201c9ec: 92 03 3f ff add %o4, -1, %o1 <== NOT EXECUTED
201c9f0: de 00 62 d8 ld [ %g1 + 0x2d8 ], %o7 <== 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)
201c9f4: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
201c9f8: 10 80 00 06 b 201ca10 <msdos_dir_read+0x4f0> <== NOT EXECUTED
201c9fc: 86 10 00 0b mov %o3, %g3 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201ca00: f8 28 c0 00 stb %i4, [ %g3 ] <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
201ca04: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
201ca08: 02 80 00 0e be 201ca40 <msdos_dir_read+0x520> <== NOT EXECUTED
201ca0c: 86 00 e0 01 inc %g3 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
201ca10: f8 08 80 00 ldub [ %g2 ], %i4 <== NOT EXECUTED
201ca14: b4 03 c0 1c add %o7, %i4, %i2 <== NOT EXECUTED
201ca18: f4 0e a0 01 ldub [ %i2 + 1 ], %i2 <== NOT EXECUTED
201ca1c: b4 0e a0 03 and %i2, 3, %i2 <== NOT EXECUTED
201ca20: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
201ca24: 12 bf ff f7 bne 201ca00 <msdos_dir_read+0x4e0> <== NOT EXECUTED
201ca28: 84 00 a0 01 inc %g2 <== NOT EXECUTED
201ca2c: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
201ca30: f8 28 c0 00 stb %i4, [ %g3 ] <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
201ca34: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
201ca38: 12 bf ff f6 bne 201ca10 <msdos_dir_read+0x4f0> <== NOT EXECUTED
201ca3c: 86 00 e0 01 inc %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)
201ca40: 94 02 a0 01 inc %o2 <== NOT EXECUTED
201ca44: 86 02 c0 0c add %o3, %o4, %g3 <== NOT EXECUTED
201ca48: 10 bf ff a5 b 201c8dc <msdos_dir_read+0x3bc> <== NOT EXECUTED
201ca4c: 92 02 80 09 add %o2, %o1, %o1 <== NOT EXECUTED
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
rtems_semaphore_release(fs_info->vol_sema);
201ca50: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
201ca54: 7f ff b5 16 call 2009eac <rtems_semaphore_release> <== NOT EXECUTED
201ca58: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
201ca5c: 40 00 01 9c call 201d0cc <__errno> <== NOT EXECUTED
201ca60: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
201ca64: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201ca68: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201ca6c: 81 c7 e0 08 ret <== NOT EXECUTED
201ca70: 81 e8 00 00 restore <== NOT EXECUTED
fs_info->fat.vol.bpc;
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);
201ca74: 40 00 01 96 call 201d0cc <__errno> <== NOT EXECUTED
201ca78: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
201ca7c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201ca80: 10 bf ff ac b 201c930 <msdos_dir_read+0x410> <== NOT EXECUTED
201ca84: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
0201ca88 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
201ca88: 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;
201ca8c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
201ca90: 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;
201ca94: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201ca98: 92 10 20 00 clr %o1
201ca9c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
201caa0: 7f ff b4 b4 call 2009d70 <rtems_semaphore_obtain>
201caa4: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201caa8: 80 a2 20 00 cmp %o0, 0
201caac: 12 80 00 1a bne 201cb14 <msdos_dir_stat+0x8c> <== NEVER TAKEN
201cab0: 01 00 00 00 nop
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
201cab4: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
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;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
201cab8: f6 17 40 00 lduh [ %i5 ], %i3
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);
201cabc: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
201cac0: f4 07 20 0c ld [ %i4 + 0xc ], %i2
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
201cac4: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
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;
201cac8: c8 07 20 40 ld [ %i4 + 0x40 ], %g4
rtems_semaphore_release(fs_info->vol_sema);
201cacc: d0 07 60 9c ld [ %i5 + 0x9c ], %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);
201cad0: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
201cad4: 05 00 00 10 sethi %hi(0x4000), %g2
201cad8: 84 10 a1 ff or %g2, 0x1ff, %g2 ! 41ff <PROM_START+0x41ff>
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
201cadc: bb 30 60 09 srl %g1, 9, %i5
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);
buf->st_ino = fat_fd->ino;
201cae0: f4 26 60 08 st %i2, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
201cae4: c0 26 60 18 clr [ %i1 + 0x18 ]
201cae8: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
201caec: c0 26 60 20 clr [ %i1 + 0x20 ]
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);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
201caf0: c4 26 60 0c st %g2, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
201caf4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
201caf8: fa 26 60 44 st %i5, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
201cafc: f6 26 60 40 st %i3, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
201cb00: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
201cb04: 7f ff b4 ea call 2009eac <rtems_semaphore_release>
201cb08: b0 10 20 00 clr %i0
return RC_OK;
}
201cb0c: 81 c7 e0 08 ret
201cb10: 81 e8 00 00 restore
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
201cb14: 40 00 01 6e call 201d0cc <__errno> <== NOT EXECUTED
201cb18: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201cb1c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201cb20: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201cb24: 81 c7 e0 08 ret <== NOT EXECUTED
201cb28: 81 e8 00 00 restore <== NOT EXECUTED
020191c0 <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
20191c0: 9d e3 bf a0 save %sp, -96, %sp
20191c4: 80 a6 e0 01 cmp %i3, 1
20191c8: 02 80 00 17 be 2019224 <msdos_eval_token+0x64>
20191cc: ba 10 00 18 mov %i0, %i5
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);
20191d0: 90 07 60 18 add %i5, 0x18, %o0
20191d4: 92 10 00 1a mov %i2, %o1
20191d8: 40 00 06 1a call 201aa40 <msdos_find_name>
20191dc: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
20191e0: 80 a2 20 00 cmp %o0, 0
20191e4: 12 80 00 17 bne 2019240 <msdos_eval_token+0x80>
20191e8: 03 00 00 1f sethi %hi(0x7c00), %g1
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
20191ec: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
20191f0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
20191f4: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
20191f8: c0 27 60 0c clr [ %i5 + 0xc ]
20191fc: 80 a0 a0 00 cmp %g2, 0
2019200: 12 80 00 1a bne 2019268 <msdos_eval_token+0xa8>
2019204: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
2019208: c2 00 60 94 ld [ %g1 + 0x94 ], %g1
201920c: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
int rc = msdos_find_name(currentloc, token, tokenlen);
if (rc == RC_OK) {
rtems_filesystem_eval_path_clear_token(ctx);
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
2019210: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2019214: 80 a0 00 01 cmp %g0, %g1
2019218: b0 60 3f ff subx %g0, -1, %i0
201921c: 81 c7 e0 08 ret
2019220: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
2019224: c2 4e 80 00 ldsb [ %i2 ], %g1
2019228: 80 a0 60 2e cmp %g1, 0x2e
201922c: 12 bf ff ea bne 20191d4 <msdos_eval_token+0x14>
2019230: 90 07 60 18 add %i5, 0x18, %o0
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
2019234: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_error(ctx, 0);
}
}
return status;
}
2019238: 81 c7 e0 08 ret
201923c: 91 e8 20 00 restore %g0, 0, %o0
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) {
2019240: 82 10 61 01 or %g1, 0x101, %g1
2019244: 80 a2 00 01 cmp %o0, %g1
2019248: 02 bf ff f5 be 201921c <msdos_eval_token+0x5c> <== ALWAYS TAKEN
201924c: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
2019250: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2019254: 92 10 20 00 clr %o1 <== NOT EXECUTED
2019258: 7f ff b5 26 call 20066f0 <rtems_filesystem_eval_path_error><== NOT EXECUTED
201925c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2019260: 81 c7 e0 08 ret <== NOT EXECUTED
2019264: 81 e8 00 00 restore <== NOT EXECUTED
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
else
loc->handlers = fs_info->file_handlers;
2019268: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
201926c: 10 bf ff e9 b 2019210 <msdos_eval_token+0x50>
2019270: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
0201cb88 <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)
{
201cb88: 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;
201cb8c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cb90: 92 10 20 00 clr %o1
int
msdos_file_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201cb94: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cb98: 94 10 20 00 clr %o2
201cb9c: 7f ff b4 75 call 2009d70 <rtems_semaphore_obtain>
201cba0: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201cba4: 80 a2 20 00 cmp %o0, 0
201cba8: 12 80 00 09 bne 201cbcc <msdos_file_close+0x44> <== NEVER TAKEN
201cbac: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
201cbb0: 7f ff ff df call 201cb2c <msdos_file_update>
201cbb4: 90 10 00 18 mov %i0, %o0
201cbb8: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
201cbbc: 7f ff b4 bc call 2009eac <rtems_semaphore_release>
201cbc0: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
201cbc4: 81 c7 e0 08 ret
201cbc8: 81 e8 00 00 restore
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
201cbcc: 40 00 01 40 call 201d0cc <__errno> <== NOT EXECUTED
201cbd0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201cbd4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201cbd8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201cbdc: 81 c7 e0 08 ret <== NOT EXECUTED
201cbe0: 81 e8 00 00 restore <== NOT EXECUTED
0201cdec <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)
{
201cdec: 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;
201cdf0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201cdf4: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201cdf8: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t old_length;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cdfc: 92 10 20 00 clr %o1
201ce00: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
201ce04: 7f ff b3 db call 2009d70 <rtems_semaphore_obtain>
201ce08: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201ce0c: 80 a2 20 00 cmp %o0, 0
201ce10: 12 80 00 31 bne 201ced4 <msdos_file_ftruncate+0xe8> <== NEVER TAKEN
201ce14: 80 a2 00 19 cmp %o0, %i1
rtems_set_errno_and_return_minus_one(EIO);
old_length = fat_fd->fat_file_size;
if (length < old_length) {
201ce18: 14 80 00 1f bg 201ce94 <msdos_file_ftruncate+0xa8> <== NEVER TAKEN
201ce1c: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
201ce20: 80 a2 00 19 cmp %o0, %i1
201ce24: 12 80 00 06 bne 201ce3c <msdos_file_ftruncate+0x50> <== NEVER TAKEN
201ce28: 90 10 00 1d mov %i5, %o0
201ce2c: 80 a6 c0 1a cmp %i3, %i2
201ce30: 18 80 00 1b bgu 201ce9c <msdos_file_ftruncate+0xb0>
201ce34: 92 10 00 1c mov %i4, %o1
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
} else {
uint32_t new_length;
rc = fat_file_extend(&fs_info->fat,
201ce38: 90 10 00 1d mov %i5, %o0
201ce3c: 92 10 00 1c mov %i4, %o1
201ce40: 94 10 20 01 mov 1, %o2
201ce44: 96 10 00 1a mov %i2, %o3
201ce48: 7f ff da 56 call 20137a0 <fat_file_extend>
201ce4c: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
201ce50: b0 92 20 00 orcc %o0, 0, %i0
201ce54: 12 80 00 17 bne 201ceb0 <msdos_file_ftruncate+0xc4> <== NEVER TAKEN
201ce58: 80 a6 00 19 cmp %i0, %i1
201ce5c: 02 80 00 19 be 201cec0 <msdos_file_ftruncate+0xd4> <== ALWAYS TAKEN
201ce60: c2 07 bf fc ld [ %fp + -4 ], %g1
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
201ce64: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201ce68: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
201ce6c: 7f ff d9 a9 call 2013510 <fat_file_truncate> <== NOT EXECUTED
201ce70: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
201ce74: 40 00 00 96 call 201d0cc <__errno> <== NOT EXECUTED
201ce78: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201ce7c: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
201ce80: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (rc == RC_OK) {
fat_fd->fat_file_size = length;
}
rtems_semaphore_release(fs_info->vol_sema);
201ce84: 7f ff b4 0a call 2009eac <rtems_semaphore_release> <== NOT EXECUTED
201ce88: d0 07 60 9c ld [ %i5 + 0x9c ], %o0 <== NOT EXECUTED
return rc;
}
201ce8c: 81 c7 e0 08 ret <== NOT EXECUTED
201ce90: 81 e8 00 00 restore <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
old_length = fat_fd->fat_file_size;
if (length < old_length) {
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
201ce94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ce98: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201ce9c: 7f ff d9 9d call 2013510 <fat_file_truncate>
201cea0: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
201cea4: b0 92 20 00 orcc %o0, 0, %i0
201cea8: 22 80 00 02 be,a 201ceb0 <msdos_file_ftruncate+0xc4> <== ALWAYS TAKEN
201ceac: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_fd->fat_file_size = length;
}
rtems_semaphore_release(fs_info->vol_sema);
201ceb0: 7f ff b3 ff call 2009eac <rtems_semaphore_release>
201ceb4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
201ceb8: 81 c7 e0 08 ret
201cebc: 81 e8 00 00 restore
rc = fat_file_extend(&fs_info->fat,
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
201cec0: 80 a0 40 1a cmp %g1, %i2
201cec4: 12 bf ff e9 bne 201ce68 <msdos_file_ftruncate+0x7c> <== NEVER TAKEN
201cec8: 92 10 00 1c mov %i4, %o1
rc = -1;
}
}
if (rc == RC_OK) {
fat_fd->fat_file_size = length;
201cecc: 10 bf ff f9 b 201ceb0 <msdos_file_ftruncate+0xc4>
201ced0: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
uint32_t old_length;
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);
201ced4: 40 00 00 7e call 201d0cc <__errno> <== NOT EXECUTED
201ced8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201cedc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201cee0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201cee4: 81 c7 e0 08 ret <== NOT EXECUTED
201cee8: 81 e8 00 00 restore <== NOT EXECUTED
0201cbe4 <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)
{
201cbe4: 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;
201cbe8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201cbec: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201cbf0: e0 00 60 08 ld [ %g1 + 8 ], %l0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cbf4: 92 10 20 00 clr %o1
201cbf8: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
201cbfc: 7f ff b4 5d call 2009d70 <rtems_semaphore_obtain>
201cc00: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201cc04: 80 a2 20 00 cmp %o0, 0
201cc08: 12 80 00 12 bne 201cc50 <msdos_file_read+0x6c> <== NEVER TAKEN
201cc0c: 98 10 00 19 mov %i1, %o4
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
201cc10: d4 06 20 0c ld [ %i0 + 0xc ], %o2
201cc14: 90 10 00 10 mov %l0, %o0
201cc18: 92 10 00 1d mov %i5, %o1
201cc1c: 7f ff d9 b8 call 20132fc <fat_file_read>
201cc20: 96 10 00 1a mov %i2, %o3
buffer);
if (ret > 0)
201cc24: b2 92 20 00 orcc %o0, 0, %i1
201cc28: 04 80 00 06 ble 201cc40 <msdos_file_read+0x5c>
201cc2c: 85 3e 60 1f sra %i1, 0x1f, %g2
iop->offset += ret;
201cc30: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
201cc34: b6 87 40 19 addcc %i5, %i1, %i3
201cc38: b4 47 00 02 addx %i4, %g2, %i2
201cc3c: f4 3e 20 08 std %i2, [ %i0 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
201cc40: 7f ff b4 9b call 2009eac <rtems_semaphore_release>
201cc44: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
201cc48: 81 c7 e0 08 ret
201cc4c: 91 e8 00 19 restore %g0, %i1, %o0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
201cc50: 40 00 01 1f call 201d0cc <__errno> <== NOT EXECUTED
201cc54: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
201cc58: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201cc5c: 10 bf ff fb b 201cc48 <msdos_file_read+0x64> <== NOT EXECUTED
201cc60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
0201cd3c <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
201cd3c: 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;
201cd40: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
201cd44: 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;
201cd48: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_file_fd_t *fat_fd = loc->node_access;
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cd4c: 92 10 20 00 clr %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
201cd50: f6 17 60 06 lduh [ %i5 + 6 ], %i3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cd54: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
201cd58: 94 10 20 00 clr %o2
201cd5c: 7f ff b4 05 call 2009d70 <rtems_semaphore_obtain>
201cd60: b6 06 ff ff add %i3, -1, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201cd64: 80 a2 20 00 cmp %o0, 0
201cd68: 12 80 00 1b bne 201cdd4 <msdos_file_stat+0x98> <== NEVER TAKEN
201cd6c: 01 00 00 00 nop
201cd70: c2 07 60 64 ld [ %i5 + 0x64 ], %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;
201cd74: f0 07 20 0c ld [ %i4 + 0xc ], %i0
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);
201cd78: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
201cd7c: f4 17 60 06 lduh [ %i5 + 6 ], %i2
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;
201cd80: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
201cd84: c8 07 20 40 ld [ %i4 + 0x40 ], %g4
rtems_semaphore_release(fs_info->vol_sema);
201cd88: d0 07 60 9c ld [ %i5 + 0x9c ], %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);
201cd8c: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
201cd90: 05 00 00 20 sethi %hi(0x8000), %g2
201cd94: 84 10 a1 ff or %g2, 0x1ff, %g2 ! 81ff <PROM_START+0x81ff>
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
201cd98: ba 06 c0 01 add %i3, %g1, %i5
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);
buf->st_ino = fat_fd->ino;
201cd9c: f0 26 60 08 st %i0, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
201cda0: b6 2f 40 1b andn %i5, %i3, %i3
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;
201cda4: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
201cda8: b7 36 e0 09 srl %i3, 9, %i3
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;
201cdac: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
201cdb0: c0 26 60 20 clr [ %i1 + 0x20 ]
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);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
201cdb4: c4 26 60 0c st %g2, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
201cdb8: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
201cdbc: f4 3e 60 40 std %i2, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
201cdc0: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
201cdc4: 7f ff b4 3a call 2009eac <rtems_semaphore_release>
201cdc8: b0 10 20 00 clr %i0
return RC_OK;
}
201cdcc: 81 c7 e0 08 ret
201cdd0: 81 e8 00 00 restore
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
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);
201cdd4: 40 00 00 be call 201d0cc <__errno> <== NOT EXECUTED
201cdd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201cddc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201cde0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201cde4: 81 c7 e0 08 ret <== NOT EXECUTED
201cde8: 81 e8 00 00 restore <== NOT EXECUTED
0201ceec <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
201ceec: 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;
201cef0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cef4: 92 10 20 00 clr %o1
int
msdos_file_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201cef8: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cefc: 94 10 20 00 clr %o2
201cf00: 7f ff b3 9c call 2009d70 <rtems_semaphore_obtain>
201cf04: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201cf08: 80 a2 20 00 cmp %o0, 0
201cf0c: 12 80 00 0d bne 201cf40 <msdos_file_sync+0x54> <== NEVER TAKEN
201cf10: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
201cf14: 7f ff ff 06 call 201cb2c <msdos_file_update>
201cf18: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
201cf1c: b0 92 20 00 orcc %o0, 0, %i0
201cf20: 12 80 00 04 bne 201cf30 <msdos_file_sync+0x44> <== NEVER TAKEN
201cf24: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
201cf28: 7f ff df 60 call 2014ca8 <fat_sync>
201cf2c: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
201cf30: 7f ff b3 df call 2009eac <rtems_semaphore_release>
201cf34: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return RC_OK;
}
201cf38: 81 c7 e0 08 ret
201cf3c: 81 e8 00 00 restore
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
201cf40: 40 00 00 63 call 201d0cc <__errno> <== NOT EXECUTED
201cf44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201cf48: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201cf4c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201cf50: 81 c7 e0 08 ret <== NOT EXECUTED
201cf54: 81 e8 00 00 restore <== NOT EXECUTED
0201cb2c <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
201cb2c: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201cb30: f2 06 20 1c ld [ %i0 + 0x1c ], %i1
/*
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
201cb34: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
201cb38: 80 88 60 01 btst 1, %g1
201cb3c: 02 80 00 04 be 201cb4c <msdos_file_update+0x20> <== ALWAYS TAKEN
201cb40: 90 10 20 00 clr %o0
return rc;
}
}
return rc;
}
201cb44: 81 c7 e0 08 ret <== NOT EXECUTED
201cb48: 91 e8 00 08 restore %g0, %o0, %o0 <== 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))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
201cb4c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
201cb50: 7f ff f2 b7 call 201962c <msdos_set_first_cluster_num>
201cb54: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
201cb58: 80 a2 20 00 cmp %o0, 0
201cb5c: 12 bf ff fa bne 201cb44 <msdos_file_update+0x18> <== NEVER TAKEN
201cb60: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
201cb64: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
201cb68: 7f ff f2 ec call 2019718 <msdos_set_file_size>
201cb6c: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
201cb70: 80 a2 20 00 cmp %o0, 0
201cb74: 12 bf ff f4 bne 201cb44 <msdos_file_update+0x18> <== NEVER TAKEN
201cb78: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
201cb7c: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
201cb80: 7f ff f2 66 call 2019518 <msdos_set_dir_wrt_time_and_date>
201cb84: 81 e8 00 00 restore
0201cc64 <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)
{
201cc64: 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;
201cc68: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201cc6c: e2 06 20 1c ld [ %i0 + 0x1c ], %l1
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201cc70: e0 00 60 08 ld [ %g1 + 8 ], %l0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201cc74: 92 10 20 00 clr %o1
201cc78: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
201cc7c: 7f ff b4 3d call 2009d70 <rtems_semaphore_obtain>
201cc80: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201cc84: 80 a2 20 00 cmp %o0, 0
201cc88: 12 80 00 24 bne 201cd18 <msdos_file_write+0xb4> <== NEVER TAKEN
201cc8c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
201cc90: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201cc94: 80 88 62 00 btst 0x200, %g1
201cc98: 32 80 00 1b bne,a 201cd04 <msdos_file_write+0xa0>
201cc9c: d4 04 60 18 ld [ %l1 + 0x18 ], %o2
201cca0: d4 06 20 0c ld [ %i0 + 0xc ], %o2
iop->offset = fat_fd->fat_file_size;
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
201cca4: 98 10 00 19 mov %i1, %o4
201cca8: 90 10 00 10 mov %l0, %o0
201ccac: 92 10 00 11 mov %l1, %o1
201ccb0: 7f ff db 51 call 20139f4 <fat_file_write>
201ccb4: 96 10 00 1a mov %i2, %o3
buffer);
if (ret < 0)
201ccb8: b2 92 20 00 orcc %o0, 0, %i1
201ccbc: 06 80 00 1c bl 201cd2c <msdos_file_write+0xc8> <== NEVER TAKEN
201ccc0: b9 3e 60 1f sra %i1, 0x1f, %i4
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
201ccc4: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
201ccc8: 86 86 40 1b addcc %i1, %i3, %g3
201cccc: 84 47 00 1a addx %i4, %i2, %g2
201ccd0: c4 3e 20 08 std %g2, [ %i0 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
201ccd4: 80 a0 a0 00 cmp %g2, 0
201ccd8: 14 80 00 0e bg 201cd10 <msdos_file_write+0xac> <== NEVER TAKEN
201ccdc: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
201cce0: 80 a0 a0 00 cmp %g2, 0
201cce4: 12 80 00 04 bne 201ccf4 <msdos_file_write+0x90> <== NEVER TAKEN
201cce8: 80 a0 c0 01 cmp %g3, %g1
201ccec: 38 80 00 02 bgu,a 201ccf4 <msdos_file_write+0x90>
201ccf0: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
fat_fd->fat_file_size = iop->offset;
rtems_semaphore_release(fs_info->vol_sema);
201ccf4: 7f ff b4 6e call 2009eac <rtems_semaphore_release>
201ccf8: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
201ccfc: 81 c7 e0 08 ret
201cd00: 91 e8 00 19 restore %g0, %i1, %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
iop->offset = fat_fd->fat_file_size;
201cd04: c0 26 20 08 clr [ %i0 + 8 ]
201cd08: 10 bf ff e7 b 201cca4 <msdos_file_write+0x40>
201cd0c: d4 26 20 0c st %o2, [ %i0 + 0xc ]
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
if (iop->offset > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset;
201cd10: 10 bf ff f9 b 201ccf4 <msdos_file_write+0x90> <== NOT EXECUTED
201cd14: c6 24 60 18 st %g3, [ %l1 + 0x18 ] <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
201cd18: 40 00 00 ed call 201d0cc <__errno> <== NOT EXECUTED
201cd1c: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
201cd20: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201cd24: 10 bf ff f6 b 201ccfc <msdos_file_write+0x98> <== NOT EXECUTED
201cd28: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
buffer);
if (ret < 0)
{
rtems_semaphore_release(fs_info->vol_sema);
201cd2c: d0 04 20 9c ld [ %l0 + 0x9c ], %o0 <== NOT EXECUTED
201cd30: 7f ff b4 5f call 2009eac <rtems_semaphore_release> <== NOT EXECUTED
201cd34: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
return -1;
201cd38: 30 bf ff f1 b,a 201ccfc <msdos_file_write+0x98> <== NOT EXECUTED
0201c31c <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
201c31c: 82 10 20 00 clr %g1
dn[i] = ' ';
201c320: 84 10 20 20 mov 0x20, %g2
201c324: 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++)
201c328: 82 00 60 01 inc %g1
201c32c: 80 a0 60 0b cmp %g1, 0xb
201c330: 32 bf ff fe bne,a 201c328 <msdos_filename_unix2dos+0xc>
201c334: 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) {
201c338: c2 4a 00 00 ldsb [ %o0 ], %g1
201c33c: 80 a0 60 2e cmp %g1, 0x2e
201c340: 02 80 00 5f be 201c4bc <msdos_filename_unix2dos+0x1a0> <== NEVER TAKEN
201c344: c4 0a 00 00 ldub [ %o0 ], %g2
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
201c348: 80 a2 60 00 cmp %o1, 0
201c34c: 02 80 00 5a be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c350: 01 00 00 00 nop
* 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++) {
201c354: 82 88 a0 ff andcc %g2, 0xff, %g1
201c358: 02 80 00 57 be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c35c: 09 00 80 b6 sethi %hi(0x202d800), %g4
if (msdos_map[c] == 0)
201c360: 88 11 21 b8 or %g4, 0x1b8, %g4 ! 202d9b8 <msdos_map>
201c364: c4 09 00 01 ldub [ %g4 + %g1 ], %g2
201c368: 80 88 a0 ff btst 0xff, %g2
201c36c: 02 80 00 22 be 201c3f4 <msdos_filename_unix2dos+0xd8>
201c370: 86 10 00 08 mov %o0, %g3
201c374: 10 80 00 0f b 201c3b0 <msdos_filename_unix2dos+0x94>
201c378: 82 10 20 00 clr %g1
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
201c37c: 02 80 00 18 be 201c3dc <msdos_filename_unix2dos+0xc0>
201c380: 01 00 00 00 nop
201c384: c4 08 c0 00 ldub [ %g3 ], %g2
201c388: 80 a0 a0 00 cmp %g2, 0
201c38c: 02 80 00 16 be 201c3e4 <msdos_filename_unix2dos+0xc8> <== NEVER TAKEN
201c390: 80 a0 a0 2e cmp %g2, 0x2e
201c394: 22 80 00 15 be,a 201c3e8 <msdos_filename_unix2dos+0xcc>
201c398: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
if (msdos_map[c] == 0)
201c39c: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
201c3a0: 80 88 a0 ff btst 0xff, %g2
201c3a4: 22 80 00 11 be,a 201c3e8 <msdos_filename_unix2dos+0xcc>
201c3a8: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
break;
dn[i] = msdos_map[c];
un++;
201c3ac: 90 10 00 03 mov %g3, %o0
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
201c3b0: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
un++;
201c3b4: 86 02 20 01 add %o0, 1, %g3
* 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++) {
201c3b8: 82 00 60 01 inc %g1
201c3bc: 84 10 20 01 mov 1, %g2
201c3c0: 80 a0 60 07 cmp %g1, 7
201c3c4: 04 80 00 03 ble 201c3d0 <msdos_filename_unix2dos+0xb4>
201c3c8: 92 02 7f ff add %o1, -1, %o1
201c3cc: 84 10 20 00 clr %g2
201c3d0: 80 88 a0 ff btst 0xff, %g2
201c3d4: 12 bf ff ea bne 201c37c <msdos_filename_unix2dos+0x60>
201c3d8: 80 a2 60 00 cmp %o1, 0
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
201c3dc: 02 80 00 36 be 201c4b4 <msdos_filename_unix2dos+0x198>
201c3e0: 01 00 00 00 nop
201c3e4: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
201c3e8: 80 a0 60 00 cmp %g1, 0
201c3ec: 02 80 00 32 be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c3f0: 01 00 00 00 nop
un++;
201c3f4: 86 00 e0 01 inc %g3
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
201c3f8: 80 a0 60 2e cmp %g1, 0x2e
201c3fc: 02 80 00 0c be 201c42c <msdos_filename_unix2dos+0x110>
201c400: 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)) {
201c404: 80 a2 60 00 cmp %o1, 0
201c408: 02 80 00 2b be 201c4b4 <msdos_filename_unix2dos+0x198>
201c40c: 01 00 00 00 nop
201c410: c2 08 c0 00 ldub [ %g3 ], %g1
201c414: 80 a0 60 00 cmp %g1, 0
201c418: 02 80 00 27 be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c41c: 92 02 7f ff add %o1, -1, %o1
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
201c420: 80 a0 60 2e cmp %g1, 0x2e
201c424: 12 bf ff f8 bne 201c404 <msdos_filename_unix2dos+0xe8> <== ALWAYS TAKEN
201c428: 86 00 e0 01 inc %g3
/*
* 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++) {
201c42c: 80 a2 60 00 cmp %o1, 0
201c430: 02 80 00 21 be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c434: 01 00 00 00 nop
201c438: c2 08 c0 00 ldub [ %g3 ], %g1
201c43c: 80 a0 60 00 cmp %g1, 0
201c440: 02 80 00 1d be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c444: 01 00 00 00 nop
if (msdos_map[c] == 0)
201c448: c4 09 00 01 ldub [ %g4 + %g1 ], %g2
201c44c: 80 88 a0 ff btst 0xff, %g2
201c450: 02 80 00 19 be 201c4b4 <msdos_filename_unix2dos+0x198>
201c454: 82 10 20 08 mov 8, %g1
break;
dn[i] = msdos_map[c];
201c458: 10 80 00 0d b 201c48c <msdos_filename_unix2dos+0x170>
201c45c: c4 2a 80 01 stb %g2, [ %o2 + %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++) {
201c460: 02 80 00 15 be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c464: 01 00 00 00 nop
201c468: c4 0b 7f f8 ldub [ %o5 + -8 ], %g2
201c46c: 80 a0 a0 00 cmp %g2, 0
201c470: 02 80 00 11 be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c474: 01 00 00 00 nop
if (msdos_map[c] == 0)
201c478: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
201c47c: 80 88 a0 ff btst 0xff, %g2
201c480: 02 80 00 0d be 201c4b4 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
201c484: 01 00 00 00 nop
break;
dn[i] = msdos_map[c];
201c488: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
un++;
unlen--;
201c48c: 92 02 7f ff add %o1, -1, %o1
/*
* 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++) {
201c490: 82 00 60 01 inc %g1
201c494: 84 10 20 01 mov 1, %g2
201c498: 80 a0 60 0a cmp %g1, 0xa
201c49c: 04 80 00 03 ble 201c4a8 <msdos_filename_unix2dos+0x18c>
201c4a0: 9a 00 c0 01 add %g3, %g1, %o5
201c4a4: 84 10 20 00 clr %g2
201c4a8: 80 88 a0 ff btst 0xff, %g2
201c4ac: 12 bf ff ed bne 201c460 <msdos_filename_unix2dos+0x144>
201c4b0: 80 a2 60 00 cmp %o1, 0
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
201c4b4: 81 c3 e0 08 retl
201c4b8: 90 10 20 00 clr %o0
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
201c4bc: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
201c4c0: 22 bf ff fd be,a 201c4b4 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
201c4c4: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
201c4c8: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
201c4cc: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
201c4d0: 12 80 00 05 bne 201c4e4 <msdos_filename_unix2dos+0x1c8> <== NOT EXECUTED
201c4d4: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
201c4d8: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
201c4dc: 02 80 00 0e be 201c514 <msdos_filename_unix2dos+0x1f8> <== NOT EXECUTED
201c4e0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
201c4e4: 32 80 00 08 bne,a 201c504 <msdos_filename_unix2dos+0x1e8><== NOT EXECUTED
201c4e8: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
201c4ec: 30 bf ff f2 b,a 201c4b4 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
201c4f0: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED
201c4f4: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
201c4f8: 12 bf ff 97 bne 201c354 <msdos_filename_unix2dos+0x38> <== NOT EXECUTED
201c4fc: c4 0a 00 00 ldub [ %o0 ], %g2 <== NOT EXECUTED
201c500: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
201c504: 12 bf ff fb bne 201c4f0 <msdos_filename_unix2dos+0x1d4> <== NOT EXECUTED
201c508: 90 02 20 01 inc %o0 <== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
201c50c: 81 c3 e0 08 retl <== NOT EXECUTED
201c510: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
201c514: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
201c518: 10 bf ff e7 b 201c4b4 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
201c51c: c2 2a a0 01 stb %g1, [ %o2 + 1 ] <== NOT EXECUTED
0201aa40 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
201aa40: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
201aa44: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
201aa48: ba 07 bf e0 add %fp, -32, %i5
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
201aa4c: f6 00 60 08 ld [ %g1 + 8 ], %i3
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
201aa50: 94 10 00 1d mov %i5, %o2
201aa54: 92 10 00 1a mov %i2, %o1
201aa58: 96 10 20 0b mov 0xb, %o3
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;
201aa5c: c0 27 bf cc clr [ %fp + -52 ]
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
201aa60: c0 27 bf e0 clr [ %fp + -32 ]
201aa64: c0 27 bf e4 clr [ %fp + -28 ]
201aa68: c0 27 bf e8 clr [ %fp + -24 ]
201aa6c: c0 27 bf ec clr [ %fp + -20 ]
201aa70: c0 27 bf f0 clr [ %fp + -16 ]
201aa74: c0 27 bf f4 clr [ %fp + -12 ]
201aa78: c0 27 bf f8 clr [ %fp + -8 ]
201aa7c: c0 27 bf fc clr [ %fp + -4 ]
name_type = msdos_long_to_short (name,
201aa80: 7f ff fa 18 call 20192e0 <msdos_long_to_short>
201aa84: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
201aa88: b8 10 00 18 mov %i0, %i4
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,
201aa8c: 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,
201aa90: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
201aa94: 90 10 00 18 mov %i0, %o0
201aa98: 92 10 20 00 clr %o1
201aa9c: 94 10 00 19 mov %i1, %o2
201aaa0: 96 10 00 1a mov %i2, %o3
201aaa4: 7f ff ff a6 call 201a93c <msdos_get_name_node>
201aaa8: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
201aaac: b0 92 20 00 orcc %o0, 0, %i0
201aab0: 12 80 00 23 bne 201ab3c <msdos_find_name+0xfc>
201aab4: c2 0f bf eb ldub [ %fp + -21 ], %g1
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
201aab8: 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) ||
201aabc: 84 08 60 08 and %g1, 8, %g2
201aac0: 80 88 a0 ff btst 0xff, %g2
201aac4: 12 80 00 1e bne 201ab3c <msdos_find_name+0xfc> <== NEVER TAKEN
201aac8: b0 16 21 01 or %i0, 0x101, %i0
201aacc: 82 08 60 3f and %g1, 0x3f, %g1
201aad0: 80 a0 60 0f cmp %g1, 0xf
201aad4: 02 80 00 1a be 201ab3c <msdos_find_name+0xfc> <== NEVER TAKEN
201aad8: 90 10 00 1b mov %i3, %o0
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
201aadc: 92 07 bf d0 add %fp, -48, %o1
201aae0: 7f ff e1 53 call 201302c <fat_file_open>
201aae4: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
201aae8: b0 92 20 00 orcc %o0, 0, %i0
201aaec: 12 80 00 14 bne 201ab3c <msdos_find_name+0xfc> <== NEVER TAKEN
201aaf0: fa 07 bf cc ld [ %fp + -52 ], %i5
return rc;
fat_fd->dir_pos = dir_pos;
201aaf4: c4 07 bf d0 ld [ %fp + -48 ], %g2
* 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)
201aaf8: c2 07 60 08 ld [ %i5 + 8 ], %g1
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
201aafc: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
201ab00: c4 07 bf d4 ld [ %fp + -44 ], %g2
* 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)
201ab04: 80 a0 60 01 cmp %g1, 1
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
201ab08: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
201ab0c: c4 07 bf d8 ld [ %fp + -40 ], %g2
201ab10: c4 27 60 28 st %g2, [ %i5 + 0x28 ]
201ab14: c4 07 bf dc ld [ %fp + -36 ], %g2
* 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)
201ab18: 02 80 00 0b be 201ab44 <msdos_find_name+0x104>
201ab1c: c4 27 60 2c st %g2, [ %i5 + 0x2c ]
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
201ab20: d2 07 20 08 ld [ %i4 + 8 ], %o1
201ab24: 7f ff e2 bc call 2013614 <fat_file_close>
201ab28: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
201ab2c: b0 92 20 00 orcc %o0, 0, %i0
201ab30: 12 80 00 45 bne 201ac44 <msdos_find_name+0x204> <== NEVER TAKEN
201ab34: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
201ab38: c2 27 20 08 st %g1, [ %i4 + 8 ]
return rc;
}
201ab3c: 81 c7 e0 08 ret
201ab40: 81 e8 00 00 restore
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));
201ab44: c2 17 bf f6 lduh [ %fp + -10 ], %g1
* 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);
201ab48: c8 17 bf f4 lduh [ %fp + -12 ], %g4
201ab4c: c6 17 bf fa lduh [ %fp + -6 ], %g3
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));
201ab50: c4 17 bf f8 lduh [ %fp + -8 ], %g2
201ab54: 83 28 60 10 sll %g1, 0x10, %g1
* 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);
201ab58: 89 29 20 10 sll %g4, 0x10, %g4
201ab5c: 87 28 e0 10 sll %g3, 0x10, %g3
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));
201ab60: 85 28 a0 10 sll %g2, 0x10, %g2
* 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);
201ab64: b1 31 20 18 srl %g4, 0x18, %i0
201ab68: b3 30 e0 18 srl %g3, 0x18, %i1
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));
201ab6c: 91 30 a0 18 srl %g2, 0x18, %o0
201ab70: 93 30 60 18 srl %g1, 0x18, %o1
201ab74: b5 30 60 08 srl %g1, 8, %i2
* 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);
201ab78: 89 31 20 08 srl %g4, 8, %g4
201ab7c: 87 30 e0 08 srl %g3, 8, %g3
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));
201ab80: 85 30 a0 08 srl %g2, 8, %g2
* 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);
201ab84: 03 00 00 3f sethi %hi(0xfc00), %g1
201ab88: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
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));
201ab8c: 84 08 80 01 and %g2, %g1, %g2
* 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);
201ab90: 88 09 00 01 and %g4, %g1, %g4
201ab94: 86 08 c0 01 and %g3, %g1, %g3
201ab98: 88 16 00 04 or %i0, %g4, %g4
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));
201ab9c: 82 0e 80 01 and %i2, %g1, %g1
* 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);
201aba0: 89 29 20 10 sll %g4, 0x10, %g4
201aba4: 86 16 40 03 or %i1, %g3, %g3
201aba8: 86 11 00 03 or %g4, %g3, %g3
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));
201abac: 92 12 40 01 or %o1, %g1, %o1
* 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);
201abb0: c6 27 60 1c st %g3, [ %i5 + 0x1c ]
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));
201abb4: 40 00 05 8c call 201c1e4 <msdos_date_dos2unix>
201abb8: 90 12 00 02 or %o0, %g2, %o0
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
201abbc: c2 0f bf eb ldub [ %fp + -21 ], %g1
201abc0: 82 08 60 10 and %g1, 0x10, %g1
201abc4: 80 88 60 ff btst 0xff, %g1
201abc8: 12 80 00 27 bne 201ac64 <msdos_find_name+0x224>
201abcc: d0 27 60 40 st %o0, [ %i5 + 0x40 ]
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
201abd0: c4 07 bf fc ld [ %fp + -4 ], %g2
201abd4: c2 07 bf cc ld [ %fp + -52 ], %g1
201abd8: bb 28 a0 18 sll %g2, 0x18, %i5
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
201abdc: 89 30 a0 18 srl %g2, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
201abe0: 87 30 a0 08 srl %g2, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201abe4: 88 17 40 04 or %i5, %g4, %g4
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
201abe8: 86 08 e0 ff and %g3, 0xff, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201abec: 87 28 e0 10 sll %g3, 0x10, %g3
201abf0: 86 11 00 03 or %g4, %g3, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
201abf4: 85 30 a0 10 srl %g2, 0x10, %g2
201abf8: 84 08 a0 ff and %g2, 0xff, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201abfc: 85 28 a0 08 sll %g2, 8, %g2
201ac00: 84 10 c0 02 or %g3, %g2, %g2
fat_fd->fat_file_type = FAT_FILE;
201ac04: 86 10 20 04 mov 4, %g3
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
201ac08: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
201ac0c: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
201ac10: 86 10 3f ff mov -1, %g3
201ac14: c6 20 60 14 st %g3, [ %g1 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
201ac18: c6 00 60 1c ld [ %g1 + 0x1c ], %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;
201ac1c: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
201ac20: 80 a0 a0 00 cmp %g2, 0
201ac24: 02 80 00 0d be 201ac58 <msdos_find_name+0x218>
201ac28: c6 20 60 38 st %g3, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
201ac2c: 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) &&
201ac30: 80 a1 00 02 cmp %g4, %g2
201ac34: 0a 80 00 0a bcs 201ac5c <msdos_find_name+0x21c>
201ac38: 84 10 3f ff mov -1, %g2
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
{
fat_fd->map.last_cln = fat_fd->cln;
201ac3c: 10 bf ff b9 b 201ab20 <msdos_find_name+0xe0>
201ac40: c6 20 60 3c st %g3, [ %g1 + 0x3c ]
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
201ac44: d2 07 bf cc ld [ %fp + -52 ], %o1 <== NOT EXECUTED
201ac48: 7f ff e2 73 call 2013614 <fat_file_close> <== NOT EXECUTED
201ac4c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201ac50: 81 c7 e0 08 ret <== NOT EXECUTED
201ac54: 81 e8 00 00 restore <== NOT EXECUTED
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
201ac58: 84 10 3f ff mov -1, %g2
201ac5c: 10 bf ff b1 b 201ab20 <msdos_find_name+0xe0>
201ac60: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
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;
201ac64: d2 07 bf cc ld [ %fp + -52 ], %o1
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
201ac68: 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;
201ac6c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
201ac70: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
201ac74: 7f ff e4 24 call 2013d04 <fat_file_size>
201ac78: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
201ac7c: b0 92 20 00 orcc %o0, 0, %i0
201ac80: 12 bf ff f1 bne 201ac44 <msdos_find_name+0x204> <== NEVER TAKEN
201ac84: c2 07 bf cc ld [ %fp + -52 ], %g1
201ac88: 10 bf ff e4 b 201ac18 <msdos_find_name+0x1d8>
201ac8c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
02019ac0 <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
)
{
2019ac0: 9d e3 bf 80 save %sp, -128, %sp
2019ac4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2019ac8: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
2019acc: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2019ad0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
2019ad4: 80 a7 20 00 cmp %i4, 0
2019ad8: 04 80 02 73 ble 201a4a4 <msdos_find_name_in_fat_file+0x9e4><== NEVER TAKEN
2019adc: ea 06 20 08 ld [ %i0 + 8 ], %l5
* 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))
2019ae0: c4 07 a0 58 ld [ %fp + 0x58 ], %g2
2019ae4: 82 18 a0 01 xor %g2, 1, %g1
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
2019ae8: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
2019aec: 80 a0 00 01 cmp %g0, %g1
2019af0: c0 20 80 00 clr [ %g2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2019af4: 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;
2019af8: c0 20 a0 04 clr [ %g2 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2019afc: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2019b00: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2019b04: c2 27 bf fc st %g1, [ %fp + -4 ]
* 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))
2019b08: b2 60 3f ff subx %g0, -1, %i1
2019b0c: 80 a6 60 00 cmp %i1, 0
2019b10: 02 80 00 80 be 2019d10 <msdos_find_name_in_fat_file+0x250>
2019b14: c2 27 bf f8 st %g1, [ %fp + -8 ]
2019b18: 80 a6 a0 00 cmp %i2, 0
2019b1c: 02 80 00 7d be 2019d10 <msdos_find_name_in_fat_file+0x250>
2019b20: c0 27 bf e4 clr [ %fp + -28 ]
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) &&
2019b24: c4 07 a0 48 ld [ %fp + 0x48 ], %g2
2019b28: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
2019b2c: 80 a0 60 01 cmp %g1, 1
2019b30: 22 80 01 79 be,a 201a114 <msdos_find_name_in_fat_file+0x654>
2019b34: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
2019b38: e4 15 60 06 lduh [ %l5 + 6 ], %l2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2019b3c: c2 07 bf e4 ld [ %fp + -28 ], %g1
2019b40: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
2019b44: 82 00 60 01 inc %g1
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
2019b48: c0 27 bf e8 clr [ %fp + -24 ]
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;
2019b4c: a8 10 20 00 clr %l4
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;
2019b50: a2 10 20 00 clr %l1
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;
2019b54: a6 10 20 00 clr %l3
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;
2019b58: b6 10 20 00 clr %i3
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;
2019b5c: ac 10 20 00 clr %l6
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;
2019b60: b8 10 20 00 clr %i4
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;
2019b64: 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;
2019b68: ae 10 20 00 clr %l7
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2019b6c: c2 27 bf ec st %g1, [ %fp + -20 ]
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
2019b70: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
2019b74: d4 07 bf e8 ld [ %fp + -24 ], %o2
2019b78: 90 10 00 15 mov %l5, %o0
2019b7c: 7f ff e5 e0 call 20132fc <fat_file_read>
2019b80: 96 10 00 12 mov %l2, %o3
2019b84: 80 a2 20 00 cmp %o0, 0
2019b88: 02 80 00 5c be 2019cf8 <msdos_find_name_in_fat_file+0x238>
2019b8c: 80 a2 20 1f cmp %o0, 0x1f
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)
2019b90: 04 80 01 77 ble 201a16c <msdos_find_name_in_fat_file+0x6ac><== NEVER TAKEN
2019b94: 80 a2 00 12 cmp %o0, %l2
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
2019b98: 12 80 02 3b bne 201a484 <msdos_find_name_in_fat_file+0x9c4><== NEVER TAKEN
2019b9c: a0 10 20 00 clr %l0
2019ba0: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
2019ba4: ba 10 00 0c mov %o4, %i5
* 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)
2019ba8: 80 a4 60 00 cmp %l1, 0
2019bac: 12 80 00 04 bne 2019bbc <msdos_find_name_in_fat_file+0xfc>
2019bb0: de 0f 40 00 ldub [ %i5 ], %o7
2019bb4: a6 10 00 10 mov %l0, %l3
2019bb8: b6 10 00 17 mov %l7, %i3
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
2019bbc: 96 8b e0 ff andcc %o7, 0xff, %o3
2019bc0: 02 80 00 e0 be 2019f40 <msdos_find_name_in_fat_file+0x480>
2019bc4: 80 a2 e0 e5 cmp %o3, 0xe5
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
2019bc8: 02 80 00 6c be 2019d78 <msdos_find_name_in_fat_file+0x2b8>
2019bcc: 96 1d 20 01 xor %l4, 1, %o3
* 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)
2019bd0: 80 8a e0 ff btst 0xff, %o3
2019bd4: 02 80 00 07 be 2019bf0 <msdos_find_name_in_fat_file+0x130><== NEVER TAKEN
2019bd8: d6 0f 60 0b ldub [ %i5 + 0xb ], %o3
2019bdc: 80 a6 a0 00 cmp %i2, 0
2019be0: 02 80 00 04 be 2019bf0 <msdos_find_name_in_fat_file+0x130>
2019be4: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
2019be8: a2 10 20 00 clr %l1 ! 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;
2019bec: a6 10 20 00 clr %l3
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
2019bf0: 96 0a e0 3f and %o3, 0x3f, %o3
2019bf4: 80 a2 e0 0f cmp %o3, 0xf
2019bf8: 02 80 00 6a be 2019da0 <msdos_find_name_in_fat_file+0x2e0>
2019bfc: 80 8e 20 ff btst 0xff, %i0
* 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)
2019c00: 02 80 00 50 be 2019d40 <msdos_find_name_in_fat_file+0x280>
2019c04: 80 a6 60 00 cmp %i1, 0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2019c08: 92 07 60 0a add %i5, 0xa, %o1
2019c0c: 96 10 00 1d mov %i5, %o3
2019c10: 94 10 20 00 clr %o2
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;
2019c14: 10 80 00 09 b 2019c38 <msdos_find_name_in_fat_file+0x178>
2019c18: b0 10 20 00 clr %i0
2019c1c: 9e 0b e0 01 and %o7, 1, %o7
2019c20: 80 a0 00 0f cmp %g0, %o7
2019c24: de 0a e0 01 ldub [ %o3 + 1 ], %o7
2019c28: b0 40 3f ff addx %g0, -1, %i0
2019c2c: 96 02 e0 01 inc %o3
2019c30: b0 0e 20 80 and %i0, 0x80, %i0
2019c34: b0 06 3f 80 add %i0, -128, %i0
2019c38: 94 0a a0 ff and %o2, 0xff, %o2
2019c3c: 95 32 a0 01 srl %o2, 1, %o2
2019c40: 9e 06 00 0f add %i0, %o7, %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++)
2019c44: 80 a2 c0 09 cmp %o3, %o1
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
2019c48: 9e 03 c0 0a add %o7, %o2, %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++)
2019c4c: 12 bf ff f4 bne 2019c1c <msdos_find_name_in_fat_file+0x15c>
2019c50: 94 10 00 0f mov %o7, %o2
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
2019c54: 94 1f 00 0a xor %i4, %o2, %o2
2019c58: 80 8a a0 ff btst 0xff, %o2
2019c5c: 12 80 00 39 bne 2019d40 <msdos_find_name_in_fat_file+0x280><== NEVER TAKEN
2019c60: 80 a6 60 00 cmp %i1, 0
2019c64: 80 a5 a0 00 cmp %l6, 0
2019c68: 12 80 00 36 bne 2019d40 <msdos_find_name_in_fat_file+0x280><== NEVER TAKEN
2019c6c: 80 a6 60 00 cmp %i1, 0
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2019c70: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
2019c74: d6 07 bf e8 ld [ %fp + -24 ], %o3
2019c78: d8 07 a0 5c ld [ %fp + 0x5c ], %o4
2019c7c: 90 10 00 15 mov %l5, %o0
2019c80: 7f ff e6 93 call 20136cc <fat_file_ioctl>
2019c84: 94 10 20 01 mov 1, %o2
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
2019c88: b0 92 20 00 orcc %o0, 0, %i0
2019c8c: 12 80 00 19 bne 2019cf0 <msdos_find_name_in_fat_file+0x230><== NEVER TAKEN
2019c90: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
2019c94: d2 07 bf f8 ld [ %fp + -8 ], %o1
2019c98: 80 a2 7f ff cmp %o1, -1
2019c9c: 02 80 01 29 be 201a140 <msdos_find_name_in_fat_file+0x680>
2019ca0: e0 20 60 04 st %l0, [ %g1 + 4 ]
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2019ca4: 7f ff a2 3a call 200258c <.umul>
2019ca8: 90 10 00 12 mov %l2, %o0
2019cac: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
2019cb0: 96 10 00 08 mov %o0, %o3
2019cb4: 94 10 20 01 mov 1, %o2
2019cb8: 90 10 00 15 mov %l5, %o0
2019cbc: 7f ff e6 84 call 20136cc <fat_file_ioctl>
2019cc0: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
2019cc4: 80 a2 20 00 cmp %o0, 0
2019cc8: 12 80 01 1c bne 201a138 <msdos_find_name_in_fat_file+0x678><== NEVER TAKEN
2019ccc: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2019cd0: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
2019cd4: d0 07 a0 60 ld [ %fp + 0x60 ], %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2019cd8: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
2019cdc: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
2019ce0: 92 10 00 1d mov %i5, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
2019ce4: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
memcpy(name_dir_entry, entry,
2019ce8: 40 00 0f b8 call 201dbc8 <memcpy>
2019cec: 94 10 20 20 mov 0x20, %o2
2019cf0: 81 c7 e0 08 ret
2019cf4: 81 e8 00 00 restore
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
2019cf8: 31 00 00 1f sethi %hi(0x7c00), %i0
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
2019cfc: 80 a6 a0 00 cmp %i2, 0
2019d00: 12 80 00 99 bne 2019f64 <msdos_find_name_in_fat_file+0x4a4>
2019d04: b0 16 21 01 or %i0, 0x101, %i0
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
2019d08: 81 c7 e0 08 ret
2019d0c: 81 e8 00 00 restore
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
2019d10: c4 07 a0 54 ld [ %fp + 0x54 ], %g2
2019d14: 92 10 20 0d mov 0xd, %o1
2019d18: 7f ff a2 59 call 200267c <.div>
2019d1c: 90 00 a0 0c add %g2, 0xc, %o0
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
2019d20: c4 07 a0 48 ld [ %fp + 0x48 ], %g2
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
2019d24: d0 27 bf e4 st %o0, [ %fp + -28 ]
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
2019d28: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
2019d2c: 80 a0 60 01 cmp %g1, 1
2019d30: 32 bf ff 83 bne,a 2019b3c <msdos_find_name_in_fat_file+0x7c>
2019d34: e4 15 60 06 lduh [ %l5 + 6 ], %l2
2019d38: 10 80 00 f7 b 201a114 <msdos_find_name_in_fat_file+0x654>
2019d3c: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1
* 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 ||
2019d40: 12 80 00 5d bne 2019eb4 <msdos_find_name_in_fat_file+0x3f4>
2019d44: f0 07 bf f8 ld [ %fp + -8 ], %i0
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
2019d48: 82 10 3f ff mov -1, %g1
lfn_matched = false;
2019d4c: b0 10 20 00 clr %i0
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
2019d50: c2 27 bf f8 st %g1, [ %fp + -8 ]
2019d54: a0 04 20 20 add %l0, 0x20, %l0
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;
2019d58: 80 a4 80 10 cmp %l2, %l0
2019d5c: 18 bf ff 93 bgu 2019ba8 <msdos_find_name_in_fat_file+0xe8>
2019d60: ba 07 60 20 add %i5, 0x20, %i5
2019d64: c4 07 bf e8 ld [ %fp + -24 ], %g2
}
if (remainder_empty)
break;
dir_offset++;
2019d68: ae 05 e0 01 inc %l7
2019d6c: 84 00 80 12 add %g2, %l2, %g2
2019d70: 10 bf ff 80 b 2019b70 <msdos_find_name_in_fat_file+0xb0>
2019d74: c4 27 bf e8 st %g2, [ %fp + -24 ]
}
break;
}
else if (entry_empty)
{
if (create_node)
2019d78: 80 a6 a0 00 cmp %i2, 0
2019d7c: 22 bf ff f7 be,a 2019d58 <msdos_find_name_in_fat_file+0x298>
2019d80: a0 04 20 20 add %l0, 0x20, %l0
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2019d84: c4 07 bf ec ld [ %fp + -20 ], %g2
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
2019d88: a2 04 60 01 inc %l1
if (empty_space_count == (lfn_entries + 1))
2019d8c: 80 a0 80 11 cmp %g2, %l1
2019d90: 22 bf ff f1 be,a 2019d54 <msdos_find_name_in_fat_file+0x294>
2019d94: a8 10 20 01 mov 1, %l4
2019d98: 10 bf ff f0 b 2019d58 <msdos_find_name_in_fat_file+0x298>
2019d9c: a0 04 20 20 add %l0, 0x20, %l0
#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)
2019da0: d6 07 bf f8 ld [ %fp + -8 ], %o3
2019da4: 80 a2 ff ff cmp %o3, -1
2019da8: 02 80 00 50 be 2019ee8 <msdos_find_name_in_fat_file+0x428>
2019dac: 96 0b e0 40 and %o7, 0x40, %o3
* 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) &
2019db0: 9e 0b e0 3f and %o7, 0x3f, %o7
2019db4: 80 a3 c0 16 cmp %o7, %l6
2019db8: 22 80 00 05 be,a 2019dcc <msdos_find_name_in_fat_file+0x30c><== ALWAYS TAKEN
2019dbc: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
2019dc0: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
continue;
2019dc4: 10 bf ff e4 b 2019d54 <msdos_find_name_in_fat_file+0x294> <== NOT EXECUTED
2019dc8: c4 27 bf f8 st %g2, [ %fp + -8 ] <== NOT EXECUTED
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
2019dcc: 96 0f 20 ff and %i4, 0xff, %o3
2019dd0: 94 08 60 ff and %g1, 0xff, %o2
2019dd4: 80 a2 80 0b cmp %o2, %o3
2019dd8: 12 bf ff fb bne 2019dc4 <msdos_find_name_in_fat_file+0x304><== NEVER TAKEN
2019ddc: 84 10 3f ff mov -1, %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(
2019de0: 96 07 60 01 add %i5, 1, %o3
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
2019de4: da 4a c0 00 ldsb [ %o3 ], %o5
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
2019de8: ac 05 bf ff add %l6, -1, %l6
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2019dec: b1 2d a0 02 sll %l6, 2, %i0
2019df0: 93 2d a0 04 sll %l6, 4, %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(
2019df4: 94 10 20 01 mov 1, %o2
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2019df8: 92 22 40 18 sub %o1, %i0, %o1
{
#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')
2019dfc: 80 a3 60 00 cmp %o5, 0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2019e00: b0 10 20 00 clr %i0
{
#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')
2019e04: 02 80 00 18 be 2019e64 <msdos_find_name_in_fat_file+0x3a4><== NEVER TAKEN
2019e08: 92 02 40 16 add %o1, %l6, %o1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
2019e0c: c4 07 a0 54 ld [ %fp + 0x54 ], %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(
2019e10: 90 06 00 09 add %i0, %o1, %o0
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
2019e14: 80 a0 80 08 cmp %g2, %o0
2019e18: 04 80 00 1c ble 2019e88 <msdos_find_name_in_fat_file+0x3c8>
2019e1c: c4 07 a0 50 ld [ %fp + 0x50 ], %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(
2019e20: 90 00 80 09 add %g2, %o1, %o0
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
2019e24: d0 4a 00 18 ldsb [ %o0 + %i0 ], %o0
2019e28: 80 a3 40 08 cmp %o5, %o0
2019e2c: 12 80 00 17 bne 2019e88 <msdos_find_name_in_fat_file+0x3c8>
2019e30: 80 a6 20 04 cmp %i0, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
2019e34: 02 80 00 3f be 2019f30 <msdos_find_name_in_fat_file+0x470>
2019e38: 80 a6 20 0a cmp %i0, 0xa
2019e3c: 02 80 00 39 be 2019f20 <msdos_find_name_in_fat_file+0x460>
2019e40: 80 a2 a0 0d cmp %o2, 0xd
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++)
2019e44: 02 80 00 13 be 2019e90 <msdos_find_name_in_fat_file+0x3d0>
2019e48: 96 02 e0 02 add %o3, 2, %o3
2019e4c: b0 06 20 01 inc %i0
2019e50: 94 02 a0 01 inc %o2
{
#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')
2019e54: da 4a c0 00 ldsb [ %o3 ], %o5
2019e58: 80 a3 60 00 cmp %o5, 0
2019e5c: 12 bf ff ed bne 2019e10 <msdos_find_name_in_fat_file+0x350>
2019e60: c4 07 a0 54 ld [ %fp + 0x54 ], %g2
/*
* 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) &&
2019e64: c4 07 bf e4 ld [ %fp + -28 ], %g2
2019e68: 80 a0 80 0f cmp %g2, %o7
2019e6c: 12 80 00 0a bne 2019e94 <msdos_find_name_in_fat_file+0x3d4><== NEVER TAKEN
2019e70: 80 a5 a0 00 cmp %l6, 0
2019e74: c4 07 a0 54 ld [ %fp + 0x54 ], %g2
((o + i) != name_len))
2019e78: b0 02 40 18 add %o1, %i0, %i0
/*
* 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) &&
2019e7c: 80 a6 00 02 cmp %i0, %g2
2019e80: 02 80 00 05 be 2019e94 <msdos_find_name_in_fat_file+0x3d4><== ALWAYS TAKEN
2019e84: 80 a5 a0 00 cmp %l6, 0
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
2019e88: 84 10 3f ff mov -1, %g2
2019e8c: c4 27 bf f8 st %g2, [ %fp + -8 ]
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
2019e90: 80 a5 a0 00 cmp %l6, 0
2019e94: 12 80 00 06 bne 2019eac <msdos_find_name_in_fat_file+0x3ec>
2019e98: b0 10 20 00 clr %i0
2019e9c: f0 07 bf f8 ld [ %fp + -8 ], %i0
2019ea0: b0 38 00 18 xnor %g0, %i0, %i0
2019ea4: 80 a0 00 18 cmp %g0, %i0
2019ea8: b0 40 20 00 addx %g0, 0, %i0
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
2019eac: 10 bf ff aa b 2019d54 <msdos_find_name_in_fat_file+0x294>
2019eb0: b8 10 00 01 mov %g1, %i4
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
2019eb4: 80 a6 3f ff cmp %i0, -1
2019eb8: 12 bf ff a5 bne 2019d4c <msdos_find_name_in_fat_file+0x28c><== NEVER TAKEN
2019ebc: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
2019ec0: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
2019ec4: d8 27 bf e0 st %o4, [ %fp + -32 ]
2019ec8: 90 10 00 1d mov %i5, %o0
2019ecc: 40 00 0f 15 call 201db20 <memcmp>
2019ed0: 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) &&
2019ed4: 80 a2 20 00 cmp %o0, 0
2019ed8: 12 bf ff 9c bne 2019d48 <msdos_find_name_in_fat_file+0x288>
2019edc: d8 07 bf e0 ld [ %fp + -32 ], %o4
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2019ee0: 10 bf ff 65 b 2019c74 <msdos_find_name_in_fat_file+0x1b4>
2019ee4: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
2019ee8: 80 8a e0 ff btst 0xff, %o3
2019eec: 02 bf ff 9a be 2019d54 <msdos_find_name_in_fat_file+0x294>
2019ef0: b0 10 20 00 clr %i0
* 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) &
2019ef4: c2 07 bf e4 ld [ %fp + -28 ], %g1
2019ef8: 9e 0b e0 3f and %o7, 0x3f, %o7
2019efc: 80 a3 c0 01 cmp %o7, %g1
2019f00: 32 bf ff 96 bne,a 2019d58 <msdos_find_name_in_fat_file+0x298>
2019f04: a0 04 20 20 add %l0, 0x20, %l0
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
2019f08: ee 27 bf f8 st %l7, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
2019f0c: e0 27 bf fc st %l0, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
2019f10: ac 10 00 01 mov %g1, %l6
2019f14: f8 0f 60 0d ldub [ %i5 + 0xd ], %i4
2019f18: 10 bf ff a6 b 2019db0 <msdos_find_name_in_fat_file+0x2f0>
2019f1c: de 0f 40 00 ldub [ %i5 ], %o7
{
case 4:
p += 5;
break;
case 10:
p += 4;
2019f20: 96 02 e0 04 add %o3, 4, %o3
2019f24: b0 06 20 01 inc %i0
2019f28: 10 bf ff cb b 2019e54 <msdos_find_name_in_fat_file+0x394>
2019f2c: 94 02 a0 01 inc %o2
}
switch (i)
{
case 4:
p += 5;
2019f30: 96 02 e0 05 add %o3, 5, %o3
2019f34: b0 06 20 01 inc %i0
2019f38: 10 bf ff c7 b 2019e54 <msdos_find_name_in_fat_file+0x394>
2019f3c: 94 02 a0 01 inc %o2
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
2019f40: 80 a6 a0 00 cmp %i2, 0
2019f44: 02 80 01 17 be 201a3a0 <msdos_find_name_in_fat_file+0x8e0>
2019f48: 80 8d 20 ff btst 0xff, %l4
* 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)
2019f4c: 12 80 00 07 bne 2019f68 <msdos_find_name_in_fat_file+0x4a8>
2019f50: c2 07 a0 58 ld [ %fp + 0x58 ], %g1
(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;
2019f54: 87 34 a0 05 srl %l2, 5, %g3
* 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);
2019f58: a1 34 20 05 srl %l0, 5, %l0
2019f5c: a2 04 40 03 add %l1, %g3, %l1
* 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 +=
2019f60: a2 24 40 10 sub %l1, %l0, %l1
* 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)
2019f64: c2 07 a0 58 ld [ %fp + 0x58 ], %g1
2019f68: 80 a0 60 02 cmp %g1, 2
2019f6c: 02 80 01 17 be 201a3c8 <msdos_find_name_in_fat_file+0x908>
2019f70: 90 10 00 1b mov %i3, %o0
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)
2019f74: c2 07 bf e4 ld [ %fp + -28 ], %g1
2019f78: 80 a0 60 00 cmp %g1, 0
2019f7c: 02 80 00 15 be 2019fd0 <msdos_find_name_in_fat_file+0x510>
2019f80: b4 10 20 00 clr %i2
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2019f84: c4 07 a0 60 ld [ %fp + 0x60 ], %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 =
2019f88: 86 10 20 00 clr %g3
* 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(
2019f8c: ba 00 a0 0b add %g2, 0xb, %i5
2019f90: 10 80 00 07 b 2019fac <msdos_find_name_in_fat_file+0x4ec>
2019f94: 88 10 00 02 mov %g2, %g4
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 =
2019f98: 86 08 e0 01 and %g3, 1, %g3
2019f9c: 80 a0 00 03 cmp %g0, %g3
2019fa0: 86 40 3f ff addx %g0, -1, %g3
2019fa4: 86 08 e0 80 and %g3, 0x80, %g3
2019fa8: 86 00 ff 80 add %g3, -128, %g3
2019fac: f0 09 00 00 ldub [ %g4 ], %i0
2019fb0: b8 0e a0 ff and %i2, 0xff, %i4
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
2019fb4: 88 01 20 01 inc %g4
lfn_checksum =
2019fb8: b9 37 20 01 srl %i4, 1, %i4
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
2019fbc: 80 a1 00 1d cmp %g4, %i5
lfn_checksum =
2019fc0: b8 06 00 1c add %i0, %i4, %i4
2019fc4: 86 07 00 03 add %i4, %g3, %g3
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
2019fc8: 12 bf ff f4 bne 2019f98 <msdos_find_name_in_fat_file+0x4d8>
2019fcc: b4 10 00 03 mov %g3, %i2
* 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)
2019fd0: 80 a4 60 00 cmp %l1, 0
2019fd4: 22 80 00 b2 be,a 201a29c <msdos_find_name_in_fat_file+0x7dc>
2019fd8: b6 10 00 17 mov %l7, %i3
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;
2019fdc: 82 1d c0 1b xor %l7, %i3, %g1
2019fe0: 80 a0 00 01 cmp %g0, %g1
2019fe4: ba 40 20 00 addx %g0, 0, %i5
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
2019fe8: c4 07 bf e4 ld [ %fp + -28 ], %g2
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2019fec: 82 10 3f ff mov -1, %g1
2019ff0: c2 27 bf fc st %g1, [ %fp + -4 ]
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
2019ff4: 80 a0 a0 00 cmp %g2, 0
2019ff8: 06 80 00 a7 bl 201a294 <msdos_find_name_in_fat_file+0x7d4><== NEVER TAKEN
2019ffc: c2 27 bf f8 st %g1, [ %fp + -8 ]
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
201a000: b8 00 a0 01 add %g2, 1, %i4
201a004: 90 10 00 1b mov %i3, %o0
201a008: 92 10 00 12 mov %l2, %o1
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
201a00c: 7f ff a1 60 call 200258c <.umul>
201a010: a2 10 20 00 clr %l1
201a014: b0 10 00 1c mov %i4, %i0
201a018: a0 10 00 08 mov %o0, %l0
*/
while (lfn_entry < (lfn_entries + 1))
{
int length = 0;
if (read_cluster)
201a01c: 80 8f 60 ff btst 0xff, %i5
201a020: 32 80 00 b2 bne,a 201a2e8 <msdos_find_name_in_fat_file+0x828>
201a024: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
201a028: 80 a4 80 13 cmp %l2, %l3
201a02c: 08 80 00 e4 bleu 201a3bc <msdos_find_name_in_fat_file+0x8fc><== NEVER TAKEN
201a030: ac 04 60 01 add %l1, 1, %l6
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
201a034: e8 05 60 a0 ld [ %l5 + 0xa0 ], %l4
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
201a038: 80 a7 00 16 cmp %i4, %l6
201a03c: 02 80 00 dd be 201a3b0 <msdos_find_name_in_fat_file+0x8f0>
201a040: a8 05 00 13 add %l4, %l3, %l4
* 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(
201a044: c4 07 bf e4 ld [ %fp + -28 ], %g2
201a048: 82 38 00 11 xnor %g0, %l1, %g1
201a04c: 82 00 40 02 add %g1, %g2, %g1
201a050: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
201a054: 87 28 60 02 sll %g1, 2, %g3
201a058: 89 28 60 04 sll %g1, 4, %g4
201a05c: ae 10 00 13 mov %l3, %l7
201a060: 86 21 00 03 sub %g4, %g3, %g3
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
201a064: ba 10 20 20 mov 0x20, %i5
* 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(
201a068: 82 00 c0 01 add %g3, %g1, %g1
201a06c: a2 00 80 01 add %g2, %g1, %l1
* 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)
201a070: c2 07 bf f8 ld [ %fp + -8 ], %g1
201a074: 80 a0 7f ff cmp %g1, -1
201a078: 22 80 00 8f be,a 201a2b4 <msdos_find_name_in_fat_file+0x7f4>
201a07c: f6 27 bf f8 st %i3, [ %fp + -8 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
201a080: 90 10 00 14 mov %l4, %o0
201a084: 92 10 20 00 clr %o1
201a088: 40 00 0f 0d call 201dcbc <memset>
201a08c: 94 10 20 20 mov 0x20, %o2
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
201a090: 88 10 00 11 mov %l1, %g4
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
201a094: f4 2d 20 0d stb %i2, [ %l4 + 0xd ]
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
201a098: da 49 00 00 ldsb [ %g4 ], %o5
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
201a09c: 86 10 20 01 mov 1, %g3
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
201a0a0: 82 05 20 01 add %l4, 1, %g1
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
201a0a4: 98 10 20 00 clr %o4
* 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(
201a0a8: 9e 00 ff ff add %g3, -1, %o7
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
201a0ac: 80 a3 60 00 cmp %o5, 0
201a0b0: 02 80 00 11 be 201a0f4 <msdos_find_name_in_fat_file+0x634><== NEVER TAKEN
201a0b4: d6 09 00 00 ldub [ %g4 ], %o3
{
*p = *n;
201a0b8: d6 28 40 00 stb %o3, [ %g1 ]
p [0] = fill;
p [1] = fill;
fill = 0xff;
}
switch (i)
201a0bc: 80 a3 e0 04 cmp %o7, 4
201a0c0: 02 80 00 12 be 201a108 <msdos_find_name_in_fat_file+0x648>
201a0c4: 88 01 20 01 inc %g4
201a0c8: 80 a3 e0 0a cmp %o7, 0xa
201a0cc: 02 80 00 77 be 201a2a8 <msdos_find_name_in_fat_file+0x7e8>
201a0d0: 80 a0 e0 0d cmp %g3, 0xd
*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++)
201a0d4: 02 80 00 2c be 201a184 <msdos_find_name_in_fat_file+0x6c4>
201a0d8: 82 00 60 02 add %g1, 2, %g1
201a0dc: 86 00 e0 01 inc %g3
{
if (*n != 0)
201a0e0: da 49 00 00 ldsb [ %g4 ], %o5
* 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(
201a0e4: 9e 00 ff ff add %g3, -1, %o7
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
201a0e8: 80 a3 60 00 cmp %o5, 0
201a0ec: 12 bf ff f3 bne 201a0b8 <msdos_find_name_in_fat_file+0x5f8>
201a0f0: d6 09 00 00 ldub [ %g4 ], %o3
*p = *n;
n++;
}
else
{
p [0] = fill;
201a0f4: d8 28 40 00 stb %o4, [ %g1 ]
p [1] = fill;
201a0f8: d8 28 60 01 stb %o4, [ %g1 + 1 ]
fill = 0xff;
}
switch (i)
201a0fc: 80 a3 e0 04 cmp %o7, 4
201a100: 12 bf ff f2 bne 201a0c8 <msdos_find_name_in_fat_file+0x608>
201a104: 98 10 3f ff mov -1, %o4
{
case 4:
p += 5;
201a108: 82 00 60 05 add %g1, 5, %g1
201a10c: 10 bf ff f5 b 201a0e0 <msdos_find_name_in_fat_file+0x620>
201a110: 86 00 e0 01 inc %g3
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) &&
201a114: 80 a0 60 00 cmp %g1, 0
201a118: 32 bf fe 89 bne,a 2019b3c <msdos_find_name_in_fat_file+0x7c><== NEVER TAKEN
201a11c: e4 15 60 06 lduh [ %l5 + 6 ], %l2 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
201a120: c2 0d 60 0e ldub [ %l5 + 0xe ], %g1
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
201a124: 80 88 60 03 btst 3, %g1
201a128: 22 bf fe 85 be,a 2019b3c <msdos_find_name_in_fat_file+0x7c>
201a12c: e4 15 60 06 lduh [ %l5 + 6 ], %l2
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
201a130: 10 bf fe 83 b 2019b3c <msdos_find_name_in_fat_file+0x7c>
201a134: e4 00 a0 18 ld [ %g2 + 0x18 ], %l2
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
201a138: 81 c7 e0 08 ret <== NOT EXECUTED
201a13c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
201a140: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
201a144: 82 10 3f ff mov -1, %g1
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
201a148: d0 07 a0 60 ld [ %fp + 0x60 ], %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
201a14c: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
201a150: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
201a154: 92 10 00 1d mov %i5, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
201a158: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
memcpy(name_dir_entry, entry,
201a15c: 40 00 0e 9b call 201dbc8 <memcpy>
201a160: 94 10 20 20 mov 0x20, %o2
201a164: 81 c7 e0 08 ret
201a168: 81 e8 00 00 restore
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
201a16c: 40 00 0b d8 call 201d0cc <__errno> <== NOT EXECUTED
201a170: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201a174: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201a178: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201a17c: 81 c7 e0 08 ret <== NOT EXECUTED
201a180: 81 e8 00 00 restore <== 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(
201a184: 82 26 00 16 sub %i0, %l6, %g1
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
201a188: 80 a5 a0 01 cmp %l6, 1
201a18c: 02 80 00 4c be 201a2bc <msdos_find_name_in_fat_file+0x7fc>
201a190: c2 2d 00 00 stb %g1, [ %l4 ]
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
201a194: c2 0d 20 0b ldub [ %l4 + 0xb ], %g1
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)
201a198: ae 05 e0 20 add %l7, 0x20, %l7
}
*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;
201a19c: 82 10 60 0f or %g1, 0xf, %g1
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
201a1a0: 80 a4 80 17 cmp %l2, %l7
201a1a4: 08 80 00 4e bleu 201a2dc <msdos_find_name_in_fat_file+0x81c><== NEVER TAKEN
201a1a8: c2 2d 20 0b stb %g1, [ %l4 + 0xb ]
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
201a1ac: e8 05 60 a0 ld [ %l5 + 0xa0 ], %l4
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
201a1b0: ac 05 a0 01 inc %l6
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;
201a1b4: a8 05 00 17 add %l4, %l7, %l4
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
201a1b8: ba 07 60 20 add %i5, 0x20, %i5
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
201a1bc: 80 a7 00 16 cmp %i4, %l6
201a1c0: 12 bf ff ac bne 201a070 <msdos_find_name_in_fat_file+0x5b0>
201a1c4: a2 04 7f f3 add %l1, -13, %l1
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
201a1c8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
201a1cc: d8 07 a0 5c ld [ %fp + 0x5c ], %o4
201a1d0: 90 10 00 15 mov %l5, %o0
201a1d4: 94 10 20 01 mov 1, %o2
201a1d8: 7f ff e5 3d call 20136cc <fat_file_ioctl>
201a1dc: 96 10 00 10 mov %l0, %o3
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
201a1e0: 80 a2 20 00 cmp %o0, 0
201a1e4: 12 bf ff d5 bne 201a138 <msdos_find_name_in_fat_file+0x678><== NEVER TAKEN
201a1e8: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
201a1ec: d2 07 bf f8 ld [ %fp + -8 ], %o1
201a1f0: 80 a2 7f ff cmp %o1, -1
201a1f4: 02 80 00 69 be 201a398 <msdos_find_name_in_fat_file+0x8d8>
201a1f8: ee 20 60 04 st %l7, [ %g1 + 4 ]
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
201a1fc: 7f ff a0 e4 call 200258c <.umul>
201a200: 90 10 00 12 mov %l2, %o0
201a204: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
201a208: 96 10 00 08 mov %o0, %o3
201a20c: 94 10 20 01 mov 1, %o2
201a210: 90 10 00 15 mov %l5, %o0
201a214: 7f ff e5 2e call 20136cc <fat_file_ioctl>
201a218: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
201a21c: 80 a2 20 00 cmp %o0, 0
201a220: 12 bf ff c6 bne 201a138 <msdos_find_name_in_fat_file+0x678><== NEVER TAKEN
201a224: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
201a228: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
201a22c: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
201a230: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
201a234: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
201a238: 90 10 00 14 mov %l4, %o0
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
201a23c: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
201a240: 40 00 0e 62 call 201dbc8 <memcpy>
201a244: 94 10 20 20 mov 0x20, %o2
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
201a248: a2 10 00 16 mov %l6, %l1
201a24c: 96 10 00 1d mov %i5, %o3
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(&fs_info->fat, fat_fd,
201a250: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
201a254: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
201a258: 90 10 00 15 mov %l5, %o0
201a25c: 94 04 00 13 add %l0, %l3, %o2
201a260: 7f ff e5 e5 call 20139f4 <fat_file_write>
201a264: 98 03 00 13 add %o4, %l3, %o4
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
201a268: 80 a2 3f ff cmp %o0, -1
201a26c: 02 80 00 96 be 201a4c4 <msdos_find_name_in_fat_file+0xa04><== NEVER TAKEN
201a270: 80 a2 00 1d cmp %o0, %i5
return ret;
else if (ret != length)
201a274: 12 bf ff be bne 201a16c <msdos_find_name_in_fat_file+0x6ac><== NEVER TAKEN
201a278: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
201a27c: b6 06 e0 01 inc %i3
201a280: a0 04 00 12 add %l0, %l2, %l0
empty_space_entry = 0;
201a284: a6 10 20 00 clr %l3
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
201a288: 80 a0 40 11 cmp %g1, %l1
201a28c: 16 bf ff 64 bge 201a01c <msdos_find_name_in_fat_file+0x55c><== NEVER TAKEN
201a290: ba 10 20 01 mov 1, %i5
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
201a294: 81 c7 e0 08 ret
201a298: 91 e8 20 00 restore %g0, 0, %o0
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
{
read_cluster = true;
201a29c: ba 10 20 01 mov 1, %i5
empty_space_offset = dir_offset;
empty_space_entry = 0;
201a2a0: 10 bf ff 52 b 2019fe8 <msdos_find_name_in_fat_file+0x528>
201a2a4: a6 10 20 00 clr %l3
{
case 4:
p += 5;
break;
case 10:
p += 4;
201a2a8: 82 00 60 04 add %g1, 4, %g1
201a2ac: 10 bf ff 8d b 201a0e0 <msdos_find_name_in_fat_file+0x620>
201a2b0: 86 00 e0 01 inc %g3
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_start.cln = empty_space_offset;
lfn_start.ofs = dir_entry;
201a2b4: 10 bf ff 73 b 201a080 <msdos_find_name_in_fat_file+0x5c0>
201a2b8: ee 27 bf fc st %l7, [ %fp + -4 ]
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
201a2bc: 82 10 60 40 or %g1, 0x40, %g1
201a2c0: c2 2d 00 00 stb %g1, [ %l4 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
201a2c4: c2 0d 20 0b ldub [ %l4 + 0xb ], %g1
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)
201a2c8: ae 05 e0 20 add %l7, 0x20, %l7
}
*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;
201a2cc: 82 10 60 0f or %g1, 0xf, %g1
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
201a2d0: 80 a4 80 17 cmp %l2, %l7
201a2d4: 18 bf ff b6 bgu 201a1ac <msdos_find_name_in_fat_file+0x6ec><== ALWAYS TAKEN
201a2d8: c2 2d 20 0b stb %g1, [ %l4 + 0xb ]
201a2dc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
201a2e0: 10 bf ff dc b 201a250 <msdos_find_name_in_fat_file+0x790> <== NOT EXECUTED
201a2e4: a2 10 00 16 mov %l6, %l1 <== NOT EXECUTED
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(&fs_info->fat, fat_fd,
201a2e8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
201a2ec: 90 10 00 15 mov %l5, %o0
201a2f0: 94 10 00 10 mov %l0, %o2
201a2f4: 7f ff e4 02 call 20132fc <fat_file_read>
201a2f8: 96 10 00 12 mov %l2, %o3
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
201a2fc: 80 a2 00 12 cmp %o0, %l2
201a300: 02 bf ff 4a be 201a028 <msdos_find_name_in_fat_file+0x568><== NEVER TAKEN
201a304: 80 a2 20 00 cmp %o0, 0
{
if (ret != FAT_EOF)
201a308: 12 80 00 1d bne 201a37c <msdos_find_name_in_fat_file+0x8bc><== NEVER TAKEN
201a30c: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
rtems_set_errno_and_return_minus_one(EIO);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (&fs_info->fat, fat_fd, false,
201a310: 90 10 00 15 mov %l5, %o0
201a314: 94 10 20 00 clr %o2
201a318: 96 10 00 10 mov %l0, %o3
201a31c: 7f ff e5 21 call 20137a0 <fat_file_extend>
201a320: 98 07 bf f4 add %fp, -12, %o4
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
201a324: 82 92 20 00 orcc %o0, 0, %g1
201a328: 12 80 00 1a bne 201a390 <msdos_find_name_in_fat_file+0x8d0><== NEVER TAKEN
201a32c: 01 00 00 00 nop
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))
201a330: c2 07 bf f4 ld [ %fp + -12 ], %g1
201a334: 80 a0 40 10 cmp %g1, %l0
201a338: 12 80 00 11 bne 201a37c <msdos_find_name_in_fat_file+0x8bc><== NEVER TAKEN
201a33c: 92 10 20 00 clr %o1
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
201a340: d0 05 60 a0 ld [ %l5 + 0xa0 ], %o0
201a344: 40 00 0e 5e call 201dcbc <memset>
201a348: 94 10 00 12 mov %l2, %o2
ret = fat_file_write(&fs_info->fat, fat_fd,
201a34c: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
201a350: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
201a354: 90 10 00 15 mov %l5, %o0
201a358: 94 10 00 10 mov %l0, %o2
201a35c: 7f ff e5 a6 call 20139f4 <fat_file_write>
201a360: 96 10 00 12 mov %l2, %o3
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)
201a364: 80 a2 3f ff cmp %o0, -1
201a368: 02 80 00 0a be 201a390 <msdos_find_name_in_fat_file+0x8d0><== ALWAYS TAKEN
201a36c: 82 10 00 08 mov %o0, %g1
return ret;
else if (ret != bts2rd)
201a370: 80 a2 00 12 cmp %o0, %l2 <== NOT EXECUTED
201a374: 02 bf ff 2e be 201a02c <msdos_find_name_in_fat_file+0x56c><== NOT EXECUTED
201a378: 80 a4 80 13 cmp %l2, %l3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
201a37c: 40 00 0b 54 call 201d0cc <__errno> <== NOT EXECUTED
201a380: 01 00 00 00 nop <== NOT EXECUTED
201a384: 84 10 20 05 mov 5, %g2 ! 5 <PROM_START+0x5> <== NOT EXECUTED
201a388: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
201a38c: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
201a390: 81 c7 e0 08 ret
201a394: 91 e8 00 01 restore %g0, %g1, %o0
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
201a398: 10 bf ff a4 b 201a228 <msdos_find_name_in_fat_file+0x768>
201a39c: 82 10 3f ff mov -1, %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;
201a3a0: 31 00 00 1f sethi %hi(0x7c00), %i0
201a3a4: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
201a3a8: 81 c7 e0 08 ret
201a3ac: 81 e8 00 00 restore
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
201a3b0: ae 10 00 13 mov %l3, %l7
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
201a3b4: 10 bf ff 85 b 201a1c8 <msdos_find_name_in_fat_file+0x708>
201a3b8: ba 10 20 20 mov 0x20, %i5
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
201a3bc: 96 10 20 00 clr %o3 <== NOT EXECUTED
201a3c0: 10 bf ff a4 b 201a250 <msdos_find_name_in_fat_file+0x790> <== NOT EXECUTED
201a3c4: ba 10 20 00 clr %i5 <== NOT EXECUTED
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
201a3c8: 7f ff a0 71 call 200258c <.umul>
201a3cc: 92 10 00 12 mov %l2, %o1
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
201a3d0: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
201a3d4: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
201a3d8: c6 48 80 00 ldsb [ %g2 ], %g3
*/
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;
201a3dc: 88 00 60 01 add %g1, 1, %g4
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
201a3e0: 90 02 00 13 add %o0, %l3, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
201a3e4: 80 a0 e0 2e cmp %g3, 0x2e
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
201a3e8: b9 32 20 05 srl %o0, 5, %i4
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
201a3ec: 02 80 00 06 be 201a404 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
201a3f0: b8 01 00 1c add %g4, %i4, %i4
201a3f4: 80 a0 e0 20 cmp %g3, 0x20
201a3f8: 12 80 00 06 bne 201a410 <msdos_find_name_in_fat_file+0x950>
201a3fc: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
*c = '_';
201a400: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
201a404: 86 10 20 5f mov 0x5f, %g3
201a408: c6 28 80 00 stb %g3, [ %g2 ]
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
201a40c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
201a410: c6 48 60 01 ldsb [ %g1 + 1 ], %g3
201a414: 80 a0 e0 2e cmp %g3, 0x2e
201a418: 02 80 00 06 be 201a430 <msdos_find_name_in_fat_file+0x970><== NEVER TAKEN
201a41c: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
201a420: 80 a0 e0 20 cmp %g3, 0x20
201a424: 12 80 00 06 bne 201a43c <msdos_find_name_in_fat_file+0x97c>
201a428: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
*c = '_';
201a42c: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
201a430: 86 10 20 5f mov 0x5f, %g3
201a434: c6 28 a0 01 stb %g3, [ %g2 + 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++)
201a438: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
201a43c: 3b 00 80 b3 sethi %hi(0x202cc00), %i5
201a440: 88 00 60 02 add %g1, 2, %g4
201a444: 86 10 20 0c mov 0xc, %g3
201a448: ba 17 62 90 or %i5, 0x290, %i5
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
201a44c: b5 3f 00 03 sra %i4, %g3, %i2
201a450: b4 0e a0 0f and %i2, 0xf, %i2
201a454: f4 0f 40 1a ldub [ %i5 + %i2 ], %i2
201a458: 86 00 ff fc add %g3, -4, %g3
201a45c: f4 29 00 00 stb %i2, [ %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++)
201a460: 80 a0 ff fc cmp %g3, -4
201a464: 12 bf ff fa bne 201a44c <msdos_find_name_in_fat_file+0x98c>
201a468: 88 01 20 01 inc %g4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
201a46c: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
201a470: 86 10 20 7e mov 0x7e, %g3
201a474: c6 28 a0 06 stb %g3, [ %g2 + 6 ]
*c++ = '1';
201a478: 86 10 20 31 mov 0x31, %g3
201a47c: 10 bf fe be b 2019f74 <msdos_find_name_in_fat_file+0x4b4>
201a480: c6 28 a0 07 stb %g3, [ %g2 + 7 ]
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
201a484: 11 00 80 b5 sethi %hi(0x202d400), %o0 <== NOT EXECUTED
201a488: 15 00 80 b5 sethi %hi(0x202d400), %o2 <== NOT EXECUTED
201a48c: 17 00 80 b5 sethi %hi(0x202d400), %o3 <== NOT EXECUTED
201a490: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
201a494: 92 10 23 f9 mov 0x3f9, %o1 <== NOT EXECUTED
201a498: 94 12 a3 c8 or %o2, 0x3c8, %o2 <== NOT EXECUTED
201a49c: 7f ff ed 45 call 20159b0 <__assert_func> <== NOT EXECUTED
201a4a0: 96 12 e3 98 or %o3, 0x398, %o3 <== NOT EXECUTED
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
201a4a4: 11 00 80 b5 sethi %hi(0x202d400), %o0 <== NOT EXECUTED
201a4a8: 15 00 80 b5 sethi %hi(0x202d400), %o2 <== NOT EXECUTED
201a4ac: 17 00 80 b5 sethi %hi(0x202d400), %o3 <== NOT EXECUTED
201a4b0: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
201a4b4: 92 10 23 c9 mov 0x3c9, %o1 <== NOT EXECUTED
201a4b8: 94 12 a3 c8 or %o2, 0x3c8, %o2 <== NOT EXECUTED
201a4bc: 7f ff ed 3d call 20159b0 <__assert_func> <== NOT EXECUTED
201a4c0: 96 12 e3 88 or %o3, 0x388, %o3 <== NOT EXECUTED
}
ret = fat_file_write(&fs_info->fat, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
201a4c4: 81 c7 e0 08 ret <== NOT EXECUTED
201a4c8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
0201a4cc <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
)
{
201a4cc: 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) &&
201a4d0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
201a4d4: 80 a0 60 01 cmp %g1, 1
201a4d8: 02 80 00 36 be 201a5b0 <msdos_find_node_by_cluster_num_in_fat_file+0xe4><== NEVER TAKEN
201a4dc: e4 06 20 08 ld [ %i0 + 8 ], %l2
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
201a4e0: e2 14 a0 06 lduh [ %l2 + 6 ], %l1
201a4e4: d8 04 a0 a0 ld [ %l2 + 0xa0 ], %o4
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)
201a4e8: 31 00 00 3f sethi %hi(0xfc00), %i0
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
201a4ec: a6 10 20 00 clr %l3
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)
201a4f0: b0 16 23 ff or %i0, 0x3ff, %i0
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
201a4f4: 90 10 00 12 mov %l2, %o0
201a4f8: 92 10 00 19 mov %i1, %o1
201a4fc: 94 10 00 13 mov %l3, %o2
201a500: 7f ff e3 7f call 20132fc <fat_file_read>
201a504: 96 10 00 11 mov %l1, %o3
201a508: 80 a2 20 00 cmp %o0, 0
201a50c: 02 80 00 25 be 201a5a0 <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
201a510: 80 a2 20 1f cmp %o0, 0x1f
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
201a514: 04 80 00 42 ble 201a61c <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NEVER TAKEN
201a518: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
201a51c: 12 80 00 46 bne 201a634 <msdos_find_node_by_cluster_num_in_fat_file+0x168><== NEVER TAKEN
201a520: a0 10 20 00 clr %l0
201a524: d8 04 a0 a0 ld [ %l2 + 0xa0 ], %o4
201a528: ba 10 00 0c mov %o4, %i5
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
201a52c: c2 0f 40 00 ldub [ %i5 ], %g1
201a530: 80 a0 60 00 cmp %g1, 0
201a534: 02 80 00 1b be 201a5a0 <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
201a538: 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)) ==
201a53c: 22 80 00 14 be,a 201a58c <msdos_find_node_by_cluster_num_in_fat_file+0xc0><== NEVER TAKEN
201a540: a0 04 20 20 add %l0, 0x20, %l0 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
201a544: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
201a548: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
201a54c: 83 28 60 10 sll %g1, 0x10, %g1
201a550: 85 28 a0 10 sll %g2, 0x10, %g2
201a554: 89 30 60 18 srl %g1, 0x18, %g4
201a558: 9f 30 a0 18 srl %g2, 0x18, %o7
201a55c: 87 30 60 08 srl %g1, 8, %g3
201a560: 85 30 a0 08 srl %g2, 8, %g2
201a564: 86 08 c0 18 and %g3, %i0, %g3
201a568: 84 08 80 18 and %g2, %i0, %g2
201a56c: 86 11 00 03 or %g4, %g3, %g3
201a570: 82 13 c0 02 or %o7, %g2, %g1
201a574: 83 28 60 10 sll %g1, 0x10, %g1
201a578: 82 10 40 03 or %g1, %g3, %g1
201a57c: 80 a0 40 1a cmp %g1, %i2
201a580: 22 80 00 16 be,a 201a5d8 <msdos_find_node_by_cluster_num_in_fat_file+0x10c>
201a584: 90 10 00 12 mov %l2, %o0
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)
201a588: a0 04 20 20 add %l0, 0x20, %l0
201a58c: 80 a4 00 11 cmp %l0, %l1
201a590: 0a bf ff e7 bcs 201a52c <msdos_find_node_by_cluster_num_in_fat_file+0x60><== ALWAYS TAKEN
201a594: ba 07 60 20 add %i5, 0x20, %i5
201a598: 10 bf ff d7 b 201a4f4 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
201a59c: a6 04 c0 11 add %l3, %l1, %l3 <== 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;
201a5a0: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
201a5a4: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
201a5a8: 81 c7 e0 08 ret <== NOT EXECUTED
201a5ac: 81 e8 00 00 restore <== 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) &&
201a5b0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
201a5b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201a5b8: 32 bf ff cb bne,a 201a4e4 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
201a5bc: e2 14 a0 06 lduh [ %l2 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
201a5c0: c2 0c a0 0e ldub [ %l2 + 0xe ], %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) &&
201a5c4: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
201a5c8: 22 bf ff c7 be,a 201a4e4 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
201a5cc: e2 14 a0 06 lduh [ %l2 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
201a5d0: 10 bf ff c5 b 201a4e4 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
201a5d4: e2 06 60 18 ld [ %i1 + 0x18 ], %l1 <== NOT EXECUTED
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
201a5d8: 92 10 00 19 mov %i1, %o1
201a5dc: 94 10 20 01 mov 1, %o2
201a5e0: 96 10 00 13 mov %l3, %o3
201a5e4: 7f ff e4 3a call 20136cc <fat_file_ioctl>
201a5e8: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
201a5ec: b0 92 20 00 orcc %o0, 0, %i0
201a5f0: 12 bf ff ee bne 201a5a8 <msdos_find_node_by_cluster_num_in_fat_file+0xdc><== NEVER TAKEN
201a5f4: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
201a5f8: e0 26 e0 04 st %l0, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
201a5fc: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
201a600: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
201a604: 90 10 00 1c mov %i4, %o0
201a608: 92 10 00 1d mov %i5, %o1
201a60c: 40 00 0d 6f call 201dbc8 <memcpy>
201a610: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
201a614: 81 c7 e0 08 ret
201a618: 81 e8 00 00 restore
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
201a61c: 40 00 0a ac call 201d0cc <__errno> <== NOT EXECUTED
201a620: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201a624: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201a628: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201a62c: 81 c7 e0 08 ret <== NOT EXECUTED
201a630: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
201a634: 11 00 80 b5 sethi %hi(0x202d400), %o0 <== NOT EXECUTED
201a638: 15 00 80 b5 sethi %hi(0x202d400), %o2 <== NOT EXECUTED
201a63c: 17 00 80 b5 sethi %hi(0x202d400), %o3 <== NOT EXECUTED
201a640: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
201a644: 92 10 26 4e mov 0x64e, %o1 <== NOT EXECUTED
201a648: 94 12 a3 e8 or %o2, 0x3e8, %o2 <== NOT EXECUTED
201a64c: 7f ff ec d9 call 20159b0 <__assert_func> <== NOT EXECUTED
201a650: 96 12 e3 98 or %o3, 0x398, %o3 <== NOT EXECUTED
0200e1cc <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200e1cc: 9d e3 bc d0 save %sp, -816, %sp
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
200e1d0: 92 10 20 02 mov 2, %o1
200e1d4: 90 10 00 19 mov %i1, %o0
200e1d8: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e1dc: 7f ff ff 41 call 200dee0 <msdos_format_printf>
200e1e0: 94 12 a0 90 or %o2, 0x90, %o2 ! 202d090 <_CPU_Trap_slot_template+0x68>
fd = open(devname, O_RDWR);
200e1e4: 90 10 00 18 mov %i0, %o0
200e1e8: 92 10 20 02 mov 2, %o1
200e1ec: 7f ff e0 26 call 2006284 <open>
200e1f0: ba 10 00 18 mov %i0, %i5
if (fd == -1) {
200e1f4: 80 a2 3f ff cmp %o0, -1
200e1f8: 02 80 01 8a be 200e820 <msdos_format+0x654> <== NEVER TAKEN
200e1fc: b6 10 00 08 mov %o0, %i3
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e200: 96 10 00 18 mov %i0, %o3
200e204: 92 10 20 02 mov 2, %o1
200e208: 90 10 00 19 mov %i1, %o0
200e20c: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e210: 7f ff ff 34 call 200dee0 <msdos_format_printf>
200e214: 94 12 a1 68 or %o2, 0x168, %o2 ! 202d168 <_CPU_Trap_slot_template+0x140>
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
200e218: 92 07 bd 60 add %fp, -672, %o1
200e21c: 7f ff dc ba call 2005504 <fstat>
200e220: 90 10 00 1b mov %i3, %o0
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200e224: 92 10 20 01 mov 1, %o1
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
200e228: b0 10 00 08 mov %o0, %i0
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200e22c: 96 10 00 1d mov %i5, %o3
200e230: 90 10 00 19 mov %i1, %o0
200e234: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e238: 7f ff ff 2a call 200dee0 <msdos_format_printf>
200e23c: 94 12 a1 78 or %o2, 0x178, %o2 ! 202d178 <_CPU_Trap_slot_template+0x150>
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
200e240: 80 a6 20 00 cmp %i0, 0
200e244: 12 80 00 0c bne 200e274 <msdos_format+0xa8> <== NEVER TAKEN
200e248: c4 07 bd 6c ld [ %fp + -660 ], %g2
200e24c: 03 00 00 3c sethi %hi(0xf000), %g1
200e250: 84 08 80 01 and %g2, %g1, %g2
200e254: 03 00 00 18 sethi %hi(0x6000), %g1
200e258: 80 a0 80 01 cmp %g2, %g1
200e25c: 02 80 00 15 be 200e2b0 <msdos_format+0xe4> <== ALWAYS TAKEN
200e260: 92 10 20 00 clr %o1
errno = ENOTTY;
200e264: 40 00 3b 9a call 201d0cc <__errno> <== NOT EXECUTED
200e268: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200e26c: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
200e270: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200e274: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
200e278: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
200e27c: c2 2f bd 4f stb %g1, [ %fp + -689 ] <== NOT EXECUTED
}
/*
* create master boot record
*/
if (ret_val == 0) {
200e280: 80 a6 20 00 cmp %i0, 0
200e284: 02 80 00 7f be 200e480 <msdos_format+0x2b4>
200e288: 90 10 00 19 mov %i1, %o0
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
200e28c: 80 a6 ff ff cmp %i3, -1
200e290: 02 80 00 06 be 200e2a8 <msdos_format+0xdc> <== NEVER TAKEN
200e294: 01 00 00 00 nop
close(fd);
200e298: 7f ff db b5 call 200516c <close>
200e29c: 90 10 00 1b mov %i3, %o0
200e2a0: 81 c7 e0 08 ret
200e2a4: 81 e8 00 00 restore
}
return ret_val;
}
200e2a8: 81 c7 e0 08 ret <== NOT EXECUTED
200e2ac: 81 e8 00 00 restore <== NOT EXECUTED
uint64_t total_size = 0;
uint32_t data_clusters_cnt;
uint8_t iteration_cnt = 0;
uint8_t fat_type = UINT8_MAX;
memset(fmt_params,0,sizeof(*fmt_params));
200e2b0: 94 10 20 54 mov 0x54, %o2
200e2b4: 40 00 3e 82 call 201dcbc <memset>
200e2b8: 90 07 bd ac add %fp, -596, %o0
static inline int rtems_disk_fd_get_media_block_size(
int fd,
uint32_t *media_block_size
)
{
return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);
200e2bc: 90 10 00 1b mov %i3, %o0
200e2c0: 3b 10 01 10 sethi %hi(0x40044000), %i5
200e2c4: 94 07 bd ac add %fp, -596, %o2
200e2c8: 40 00 1e 91 call 2015d0c <ioctl>
200e2cc: 92 17 62 02 or %i5, 0x202, %o1
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_media_block_size(fd, &fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
200e2d0: 84 92 20 00 orcc %o0, 0, %g2
200e2d4: 02 80 01 62 be 200e85c <msdos_format+0x690> <== ALWAYS TAKEN
200e2d8: 90 10 00 1b mov %i3, %o0
200e2dc: e6 07 bd b0 ld [ %fp + -592 ], %l3
200e2e0: 80 a0 00 19 cmp %g0, %i1
200e2e4: 82 40 20 00 addx %g0, 0, %g1
200e2e8: c2 2f bd 4f stb %g1, [ %fp + -689 ]
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
200e2ec: 80 a4 e0 00 cmp %l3, 0
200e2f0: 02 80 01 c7 be 200ea0c <msdos_format+0x840> <== NEVER TAKEN
200e2f4: 01 00 00 00 nop
200e2f8: b0 10 00 02 mov %g2, %i0
200e2fc: fa 07 bd b4 ld [ %fp + -588 ], %i5
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
200e300: b8 10 20 00 clr %i4
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
200e304: f4 07 bd c8 ld [ %fp + -568 ], %i2
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
200e308: d0 0f bd dc ldub [ %fp + -548 ], %o0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
200e30c: 80 a6 a0 00 cmp %i2, 0
200e310: 02 80 01 c4 be 200ea20 <msdos_format+0x854>
200e314: d2 07 bd bc ld [ %fp + -580 ], %o1
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
200e318: 7f ff d0 9d call 200258c <.umul>
200e31c: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
200e320: f4 27 bd d0 st %i2, [ %fp + -560 ]
* 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);
200e324: 90 07 40 08 add %i5, %o0, %o0
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
200e328: d0 27 bd cc st %o0, [ %fp + -564 ]
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
200e32c: 80 a6 20 00 cmp %i0, 0
200e330: 12 80 00 46 bne 200e448 <msdos_format+0x27c>
200e334: 80 8f 20 ff btst 0xff, %i4
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
200e338: 80 a6 60 00 cmp %i1, 0
200e33c: 02 80 03 8a be 200f164 <msdos_format+0xf98>
200e340: 09 00 80 b4 sethi %hi(0x202d000), %g4
(rqdata->OEMName != NULL)) {
200e344: c8 06 40 00 ld [ %i1 ], %g4
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) &&
200e348: 80 a1 20 00 cmp %g4, 0
200e34c: 22 80 03 86 be,a 200f164 <msdos_format+0xf98>
200e350: 09 00 80 b4 sethi %hi(0x202d000), %g4
200e354: 03 00 80 ba sethi %hi(0x202e800), %g1
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
200e358: 84 10 20 08 mov 8, %g2
200e35c: f4 00 62 d8 ld [ %g1 + 0x2d8 ], %i2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e360: 9e 10 20 20 mov 0x20, %o7
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
200e364: 10 80 00 07 b 200e380 <msdos_format+0x1b4>
200e368: 82 07 bd df add %fp, -545, %g1
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
200e36c: 82 00 60 01 inc %g1
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
200e370: c0 28 40 00 clrb [ %g1 ]
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
200e374: 84 80 bf ff addcc %g2, -1, %g2
200e378: 02 80 00 0e be 200e3b0 <msdos_format+0x1e4> <== NEVER TAKEN
200e37c: 88 01 20 01 inc %g4
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200e380: c6 09 00 00 ldub [ %g4 ], %g3
200e384: ba 08 e0 ff and %g3, 0xff, %i5
200e388: ba 06 80 1d add %i2, %i5, %i5
200e38c: fa 4f 60 01 ldsb [ %i5 + 1 ], %i5
200e390: 80 8f 60 97 btst 0x97, %i5
200e394: 32 bf ff f6 bne,a 200e36c <msdos_format+0x1a0>
200e398: c6 28 40 00 stb %g3, [ %g1 ]
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e39c: de 28 40 00 stb %o7, [ %g1 ]
200e3a0: 82 00 60 01 inc %g1
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
200e3a4: 84 80 bf ff addcc %g2, -1, %g2
200e3a8: 12 bf ff f6 bne 200e380 <msdos_format+0x1b4>
200e3ac: c0 28 40 00 clrb [ %g1 ]
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) &&
200e3b0: 80 a6 60 00 cmp %i1, 0
200e3b4: 02 80 03 6e be 200f16c <msdos_format+0xfa0>
200e3b8: 09 00 80 b1 sethi %hi(0x202c400), %g4
(rqdata->VolLabel != NULL)) {
200e3bc: c8 06 60 04 ld [ %i1 + 4 ], %g4
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) &&
200e3c0: 80 a1 20 00 cmp %g4, 0
200e3c4: 22 80 03 6a be,a 200f16c <msdos_format+0xfa0>
200e3c8: 09 00 80 b1 sethi %hi(0x202c400), %g4
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
200e3cc: 82 10 20 01 mov 1, %g1
200e3d0: c2 2f bd f4 stb %g1, [ %fp + -524 ]
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
200e3d4: 84 10 20 0b mov 0xb, %g2
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
200e3d8: 82 07 bd e8 add %fp, -536, %g1
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e3dc: 10 80 00 07 b 200e3f8 <msdos_format+0x22c>
200e3e0: 9e 10 20 20 mov 0x20, %o7
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
200e3e4: 82 00 60 01 inc %g1
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
200e3e8: c0 28 40 00 clrb [ %g1 ]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
200e3ec: 84 80 bf ff addcc %g2, -1, %g2
200e3f0: 02 80 00 0e be 200e428 <msdos_format+0x25c> <== NEVER TAKEN
200e3f4: 88 01 20 01 inc %g4
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200e3f8: c6 09 00 00 ldub [ %g4 ], %g3
200e3fc: ba 08 e0 ff and %g3, 0xff, %i5
200e400: ba 06 80 1d add %i2, %i5, %i5
200e404: fa 4f 60 01 ldsb [ %i5 + 1 ], %i5
200e408: 80 8f 60 97 btst 0x97, %i5
200e40c: 32 bf ff f6 bne,a 200e3e4 <msdos_format+0x218>
200e410: c6 28 40 00 stb %g3, [ %g1 ]
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e414: de 28 40 00 stb %o7, [ %g1 ]
200e418: 82 00 60 01 inc %g1
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
200e41c: 84 80 bf ff addcc %g2, -1, %g2
200e420: 12 bf ff f6 bne 200e3f8 <msdos_format+0x22c>
200e424: c0 28 40 00 clrb [ %g1 ]
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
200e428: 40 00 22 97 call 2016e84 <rtems_clock_get_tod_timeval>
200e42c: 90 07 be 00 add %fp, -512, %o0
if (rc == RTEMS_SUCCESSFUL) {
200e430: 80 a2 20 00 cmp %o0, 0
200e434: 12 80 03 3a bne 200f11c <msdos_format+0xf50> <== ALWAYS TAKEN
200e438: c2 07 be 00 ld [ %fp + -512 ], %g1
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
200e43c: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
200e440: c2 27 bd f8 st %g1, [ %fp + -520 ] <== 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) &&
200e444: 80 8f 20 ff btst 0xff, %i4
200e448: 02 bf ff 8f be 200e284 <msdos_format+0xb8>
200e44c: 80 a6 20 00 cmp %i0, 0
(rqdata != NULL) &&
200e450: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
200e454: 80 a0 60 00 cmp %g1, 0
200e458: 12 80 00 0a bne 200e480 <msdos_format+0x2b4>
200e45c: 90 10 00 19 mov %i1, %o0
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
200e460: d6 07 bd b0 ld [ %fp + -592 ], %o3
200e464: d8 07 bd ac ld [ %fp + -596 ], %o4
200e468: 92 10 00 1b mov %i3, %o1
200e46c: 94 10 20 00 clr %o2
200e470: 7f ff fe c9 call 200df94 <msdos_format_fill_sectors>
200e474: 9a 10 3f e5 mov -27, %o5
200e478: 10 bf ff 82 b 200e280 <msdos_format+0xb4>
200e47c: b0 10 00 08 mov %o0, %i0
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e480: 92 10 20 02 mov 2, %o1
200e484: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e488: 7f ff fe 96 call 200dee0 <msdos_format_printf>
200e48c: 94 12 a1 18 or %o2, 0x118, %o2 ! 202d118 <_CPU_Trap_slot_template+0xf0>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
200e490: 90 10 00 1b mov %i3, %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,
200e494: fa 07 bd ac ld [ %fp + -596 ], %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)) {
200e498: 92 10 20 00 clr %o1
200e49c: 94 10 20 00 clr %o2
200e4a0: 40 00 1e 3c call 2015d90 <lseek>
200e4a4: 96 10 20 00 clr %o3
200e4a8: 80 a2 20 00 cmp %o0, 0
200e4ac: 06 80 01 16 bl 200e904 <msdos_format+0x738> <== NEVER TAKEN
200e4b0: 90 10 00 1b mov %i3, %o0
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
200e4b4: 92 07 be 00 add %fp, -512, %o1
200e4b8: 40 00 1f 0c call 20160e8 <read>
200e4bc: 94 10 00 1d mov %i5, %o2
200e4c0: 80 a2 20 00 cmp %o0, 0
200e4c4: 06 80 01 10 bl 200e904 <msdos_format+0x738> <== NEVER TAKEN
200e4c8: 90 10 00 19 mov %i1, %o0
ret_val = msdos_format_read_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e4cc: 92 10 20 02 mov 2, %o1
200e4d0: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e4d4: 7f ff fe 83 call 200dee0 <msdos_format_printf>
200e4d8: 94 12 a1 88 or %o2, 0x188, %o2 ! 202d188 <_CPU_Trap_slot_template+0x160>
{
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) {
200e4dc: c2 07 bd b0 ld [ %fp + -592 ], %g1
200e4e0: 05 00 00 3f sethi %hi(0xfc00), %g2
200e4e4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
200e4e8: 80 a0 40 02 cmp %g1, %g2
200e4ec: 08 80 02 f9 bleu 200f0d0 <msdos_format+0xf04>
200e4f0: b0 10 00 01 mov %g1, %i0
200e4f4: 84 08 40 02 and %g1, %g2, %g2
200e4f8: a8 10 00 01 mov %g1, %l4
200e4fc: a7 30 a0 08 srl %g2, 8, %l3
200e500: a5 30 60 10 srl %g1, 0x10, %l2
200e504: a3 30 60 18 srl %g1, 0x18, %l1
200e508: a0 10 20 00 clr %l0
200e50c: b0 10 20 00 clr %i0
* 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);
200e510: 92 10 20 00 clr %o1
200e514: 94 10 21 be mov 0x1be, %o2
200e518: 40 00 3d e9 call 201dcbc <memset>
200e51c: 90 07 be 00 add %fp, -512, %o0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
200e520: 90 07 be 03 add %fp, -509, %o0
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
200e524: c0 37 bf fe clrh [ %fp + -2 ]
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
200e528: 92 07 bd df add %fp, -545, %o1
200e52c: 40 00 3d a7 call 201dbc8 <memcpy>
200e530: 94 10 20 08 mov 8, %o2
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);
200e534: c4 07 bd c4 ld [ %fp + -572 ], %g2
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
200e538: c8 07 bd ac ld [ %fp + -596 ], %g4
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);
200e53c: 83 30 a0 08 srl %g2, 8, %g1
200e540: c2 2f be 12 stb %g1, [ %fp + -494 ]
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
200e544: c2 0f bd dd ldub [ %fp + -547 ], %g1
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);
200e548: c6 07 bd b4 ld [ %fp + -588 ], %g3
* 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);
200e54c: 9b 31 20 08 srl %g4, 8, %o5
200e550: c8 2f be 0b stb %g4, [ %fp + -501 ]
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
200e554: c8 07 bd b8 ld [ %fp + -584 ], %g4
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
200e558: fa 0f bd de ldub [ %fp + -546 ], %i5
/* 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);
200e55c: c2 2f be 15 stb %g1, [ %fp + -491 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
200e560: 82 10 3f ff mov -1, %g1
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);
200e564: 9f 30 e0 08 srl %g3, 8, %o7
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
200e568: b4 10 20 02 mov 2, %i2
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... */
200e56c: b8 10 20 01 mov 1, %i4
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
200e570: c2 2f be 18 stb %g1, [ %fp + -488 ]
* 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);
200e574: da 2f be 0c stb %o5, [ %fp + -500 ]
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... */
200e578: 82 10 20 06 mov 6, %g1
*/
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);
200e57c: c8 2f be 0d stb %g4, [ %fp + -499 ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
200e580: c6 2f be 0e stb %g3, [ %fp + -498 ]
200e584: de 2f be 0f stb %o7, [ %fp + -497 ]
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
200e588: f4 2f be 10 stb %i2, [ %fp + -496 ]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
200e58c: c4 2f be 11 stb %g2, [ %fp + -495 ]
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
200e590: f0 2f be 13 stb %i0, [ %fp + -493 ]
200e594: e0 2f be 14 stb %l0, [ %fp + -492 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
200e598: c2 2f be 1a stb %g1, [ %fp + -486 ]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
200e59c: f8 2f be 1c stb %i4, [ %fp + -484 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
200e5a0: e8 2f be 20 stb %l4, [ %fp + -480 ]
200e5a4: e6 2f be 21 stb %l3, [ %fp + -479 ]
200e5a8: e4 2f be 22 stb %l2, [ %fp + -478 ]
if (fmt_params->fattype != FAT_FAT32) {
200e5ac: 80 a7 60 04 cmp %i5, 4
200e5b0: 02 80 02 f4 be 200f180 <msdos_format+0xfb4>
200e5b4: e2 2f be 23 stb %l1, [ %fp + -477 ]
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 */
200e5b8: c2 07 bd f8 ld [ %fp + -520 ], %g1
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
200e5bc: c4 07 bd bc ld [ %fp + -580 ], %g2
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 */
200e5c0: 89 30 60 10 srl %g1, 0x10, %g4
200e5c4: 87 30 60 18 srl %g1, 0x18, %g3
200e5c8: b9 30 60 08 srl %g1, 8, %i4
200e5cc: c2 2f be 27 stb %g1, [ %fp + -473 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
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);
200e5d0: 82 10 20 29 mov 0x29, %g1
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
200e5d4: b5 30 a0 08 srl %g2, 8, %i2
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);
200e5d8: c2 2f be 26 stb %g1, [ %fp + -474 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
200e5dc: c4 2f be 16 stb %g2, [ %fp + -490 ]
200e5e0: f4 2f be 17 stb %i2, [ %fp + -489 ]
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
200e5e4: f8 2f be 28 stb %i4, [ %fp + -472 ]
200e5e8: c8 2f be 29 stb %g4, [ %fp + -471 ]
200e5ec: c6 2f be 2a stb %g3, [ %fp + -470 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
200e5f0: 90 07 be 2b add %fp, -469, %o0
200e5f4: 92 07 bd e8 add %fp, -536, %o1
200e5f8: 40 00 3d 74 call 201dbc8 <memcpy>
200e5fc: 94 10 20 0b mov 0xb, %o2
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
200e600: 03 00 80 b4 sethi %hi(0x202d000), %g1
200e604: 80 a7 60 01 cmp %i5, 1
200e608: 02 80 02 c2 be 200f110 <msdos_format+0xf44>
200e60c: 82 10 60 78 or %g1, 0x78, %g1
200e610: c4 10 40 00 lduh [ %g1 ], %g2
200e614: c4 37 be 36 sth %g2, [ %fp + -458 ]
200e618: c4 10 60 02 lduh [ %g1 + 2 ], %g2
200e61c: c4 37 be 38 sth %g2, [ %fp + -456 ]
200e620: c4 10 60 04 lduh [ %g1 + 4 ], %g2
200e624: c4 37 be 3a sth %g2, [ %fp + -454 ]
200e628: c2 10 60 06 lduh [ %g1 + 6 ], %g1
200e62c: c2 37 be 3c sth %g1, [ %fp + -452 ]
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
200e630: 82 10 20 55 mov 0x55, %g1
200e634: c2 2f bf fe stb %g1, [ %fp + -2 ]
200e638: 82 10 3f aa mov -86, %g1
200e63c: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
200e640: 82 10 3f eb mov -21, %g1
200e644: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(mbr,1,0x3c);
200e648: 82 10 20 3c mov 0x3c, %g1
200e64c: c2 2f be 01 stb %g1, [ %fp + -511 ]
FAT_SET_VAL8(mbr,2,0x90);
200e650: 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,
200e654: 92 10 20 02 mov 2, %o1
200e658: 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);
200e65c: c2 2f be 02 stb %g1, [ %fp + -510 ]
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e660: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e664: 7f ff fe 1f call 200dee0 <msdos_format_printf>
200e668: 94 12 a1 30 or %o2, 0x130, %o2 ! 202d130 <_CPU_Trap_slot_template+0x108>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
200e66c: d4 07 bd ac ld [ %fp + -596 ], %o2
200e670: 90 10 00 1b mov %i3, %o0
200e674: 92 10 20 00 clr %o1
200e678: 7f ff fe 2f call 200df34 <msdos_format_write_sec>
200e67c: 96 07 be 00 add %fp, -512, %o3
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
200e680: b0 92 20 00 orcc %o0, 0, %i0
200e684: 12 bf ff 02 bne 200e28c <msdos_format+0xc0> <== NEVER TAKEN
200e688: c2 07 bd d4 ld [ %fp + -556 ], %g1
200e68c: 80 a0 60 00 cmp %g1, 0
200e690: 12 80 02 a7 bne 200f12c <msdos_format+0xf60>
200e694: 92 10 20 02 mov 2, %o1
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
200e698: fa 07 bd d8 ld [ %fp + -552 ], %i5
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
200e69c: 80 a7 60 00 cmp %i5, 0
200e6a0: 12 80 00 9b bne 200e90c <msdos_format+0x740>
200e6a4: d2 07 bd bc ld [ %fp + -580 ], %o1
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
(rqdata,
200e6a8: d0 0f bd dc ldub [ %fp + -548 ], %o0
200e6ac: 7f ff cf b8 call 200258c <.umul>
200e6b0: fa 07 bd b4 ld [ %fp + -588 ], %i5
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
200e6b4: d8 07 bd ac ld [ %fp + -596 ], %o4
(rqdata,
200e6b8: 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
200e6bc: 92 10 00 1b mov %i3, %o1
200e6c0: 90 10 00 19 mov %i1, %o0
200e6c4: 94 10 00 1d mov %i5, %o2
200e6c8: 7f ff fe 33 call 200df94 <msdos_format_fill_sectors>
200e6cc: 9a 10 20 00 clr %o5
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
200e6d0: b0 92 20 00 orcc %o0, 0, %i0
200e6d4: 12 bf fe ee bne 200e28c <msdos_format+0xc0> <== NEVER TAKEN
200e6d8: d4 07 bd cc ld [ %fp + -564 ], %o2
ret_val = msdos_format_fill_sectors
200e6dc: d6 07 bd d0 ld [ %fp + -560 ], %o3
200e6e0: d8 07 bd ac ld [ %fp + -596 ], %o4
200e6e4: 90 10 00 19 mov %i1, %o0
200e6e8: 92 10 00 1b mov %i3, %o1
200e6ec: 7f ff fe 2a call 200df94 <msdos_format_fill_sectors>
200e6f0: 9a 10 20 00 clr %o5
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
200e6f4: b0 92 20 00 orcc %o0, 0, %i0
200e6f8: 12 bf fe e5 bne 200e28c <msdos_format+0xc0> <== NEVER TAKEN
200e6fc: c2 0f bd f4 ldub [ %fp + -524 ], %g1
200e700: 80 a0 60 00 cmp %g1, 0
200e704: 12 80 00 a9 bne 200e9a8 <msdos_format+0x7dc>
200e708: 92 10 20 00 clr %o1
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
200e70c: 90 07 be 00 add %fp, -512, %o0
200e710: 92 10 20 00 clr %o1
200e714: 40 00 3d 6a call 201dcbc <memset>
200e718: 94 10 22 00 mov 0x200, %o2
switch(fmt_params.fattype) {
200e71c: c2 0f bd de ldub [ %fp + -546 ], %g1
200e720: 80 a0 60 02 cmp %g1, 2
200e724: 02 80 00 e2 be 200eaac <msdos_format+0x8e0>
200e728: 80 a0 60 04 cmp %g1, 4
200e72c: 02 80 00 c4 be 200ea3c <msdos_format+0x870>
200e730: 80 a0 60 01 cmp %g1, 1
200e734: 02 80 00 d7 be 200ea90 <msdos_format+0x8c4> <== ALWAYS TAKEN
200e738: c2 0f bd dd ldub [ %fp + -547 ], %g1
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
200e73c: 40 00 3a 64 call 201d0cc <__errno> <== NOT EXECUTED
200e740: 01 00 00 00 nop <== NOT EXECUTED
200e744: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
200e748: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
200e74c: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
200e750: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
200e754: 02 80 00 c7 be 200ea70 <msdos_format+0x8a4> <== NOT EXECUTED
200e758: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200e75c: c2 0f bd fc ldub [ %fp + -516 ], %g1
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
200e760: f8 07 bd b4 ld [ %fp + -588 ], %i4
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200e764: 80 a0 60 00 cmp %g1, 0
200e768: 12 80 00 06 bne 200e780 <msdos_format+0x5b4>
200e76c: c4 07 bd b8 ld [ %fp + -584 ], %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
200e770: b8 07 00 02 add %i4, %g2, %i4
200e774: 84 20 00 02 neg %g2
200e778: b8 07 3f ff add %i4, -1, %i4
200e77c: b8 0f 00 02 and %i4, %g2, %i4
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
200e780: c2 0f bd dc ldub [ %fp + -548 ], %g1
200e784: 80 a0 60 00 cmp %g1, 0
200e788: 02 80 02 ad be 200f23c <msdos_format+0x1070> <== NEVER TAKEN
200e78c: 80 a2 20 00 cmp %o0, 0
(i < fmt_params.fat_num) && (ret_val == 0);
200e790: 12 80 00 5a bne 200e8f8 <msdos_format+0x72c> <== NEVER TAKEN
200e794: d0 07 bd bc ld [ %fp + -580 ], %o0
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
200e798: 10 80 00 05 b 200e7ac <msdos_format+0x5e0>
200e79c: ba 10 20 00 clr %i5
(i < fmt_params.fat_num) && (ret_val == 0);
200e7a0: 32 bf fe bb bne,a 200e28c <msdos_format+0xc0> <== NEVER TAKEN
200e7a4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
200e7a8: d0 07 bd bc ld [ %fp + -580 ], %o0
i++) {
ret_val = msdos_format_write_sec
(fd,
start_sector
+ (i * fmt_params.sectors_per_fat),
200e7ac: 7f ff cf 78 call 200258c <.umul>
200e7b0: 92 10 00 1d mov %i5, %o1
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
200e7b4: d4 07 bd ac ld [ %fp + -596 ], %o2
(fd,
200e7b8: 92 02 00 1c add %o0, %i4, %o1
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
200e7bc: 96 07 be 00 add %fp, -512, %o3
200e7c0: 7f ff fd dd call 200df34 <msdos_format_write_sec>
200e7c4: 90 10 00 1b mov %i3, %o0
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
200e7c8: c2 0f bd dc ldub [ %fp + -548 ], %g1
i++) {
200e7cc: ba 07 60 01 inc %i5
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
200e7d0: 80 a0 40 1d cmp %g1, %i5
200e7d4: 14 bf ff f3 bg 200e7a0 <msdos_format+0x5d4>
200e7d8: 80 a2 20 00 cmp %o0, 0
200e7dc: c4 0f bd 4f ldub [ %fp + -689 ], %g2
200e7e0: 80 a0 00 08 cmp %g0, %o0
200e7e4: 82 60 3f ff subx %g0, -1, %g1
200e7e8: 82 08 40 02 and %g1, %g2, %g1
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
200e7ec: 80 88 60 ff btst 0xff, %g1
200e7f0: 22 bf fe a7 be,a 200e28c <msdos_format+0xc0>
200e7f4: b0 10 00 08 mov %o0, %i0
200e7f8: c2 0e 60 17 ldub [ %i1 + 0x17 ], %g1
200e7fc: 80 a0 60 00 cmp %g1, 0
200e800: 02 bf fe a4 be 200e290 <msdos_format+0xc4>
200e804: 80 a6 ff ff cmp %i3, -1
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
200e808: 90 10 00 1b mov %i3, %o0
200e80c: 13 08 00 10 sethi %hi(0x20004000), %o1
200e810: 40 00 1d 3f call 2015d0c <ioctl>
200e814: 92 12 62 06 or %o1, 0x206, %o1 ! 20004206 <RAM_END+0x1dc04206>
200e818: 10 bf fe 9d b 200e28c <msdos_format+0xc0>
200e81c: b0 10 00 08 mov %o0, %i0
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e820: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
200e824: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200e828: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
200e82c: 15 00 80 b4 sethi %hi(0x202d000), %o2 <== NOT EXECUTED
200e830: 7f ff fd ac call 200dee0 <msdos_format_printf> <== NOT EXECUTED
200e834: 94 12 a1 68 or %o2, 0x168, %o2 ! 202d168 <_CPU_Trap_slot_template+0x140><== NOT EXECUTED
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200e838: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
200e83c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200e840: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
200e844: 15 00 80 b4 sethi %hi(0x202d000), %o2 <== NOT EXECUTED
200e848: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200e84c: 7f ff fd a5 call 200dee0 <msdos_format_printf> <== NOT EXECUTED
200e850: 94 12 a1 78 or %o2, 0x178, %o2 <== NOT EXECUTED
200e854: 10 bf fe 89 b 200e278 <msdos_format+0xac> <== NOT EXECUTED
200e858: 80 a0 00 19 cmp %g0, %i1 <== 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);
200e85c: 92 17 62 05 or %i5, 0x205, %o1
200e860: 40 00 1d 2b call 2015d0c <ioctl>
200e864: 94 07 bd b0 add %fp, -592, %o2
ret_val = rtems_disk_fd_get_media_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) {
200e868: 84 92 20 00 orcc %o0, 0, %g2
200e86c: 12 bf fe 9c bne 200e2dc <msdos_format+0x110> <== NEVER TAKEN
200e870: f0 07 bd ac ld [ %fp + -596 ], %i0
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
200e874: f4 07 bd b0 ld [ %fp + -592 ], %i2
200e878: 92 10 00 18 mov %i0, %o1
200e87c: 7f ff cf 44 call 200258c <.umul>
200e880: 90 10 00 1a mov %i2, %o0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e884: 9a 10 20 00 clr %o5
}
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
}
if (ret_val == 0) {
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
200e888: ba 10 00 08 mov %o0, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e88c: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
}
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
}
if (ret_val == 0) {
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
200e890: b8 10 20 00 clr %i4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e894: 92 10 20 02 mov 2, %o1
200e898: f8 3f bd 58 std %i4, [ %fp + -680 ]
200e89c: 90 10 00 19 mov %i1, %o0
200e8a0: 96 10 00 18 mov %i0, %o3
200e8a4: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e8a8: 98 10 00 1a mov %i2, %o4
200e8ac: 7f ff fd 8d call 200dee0 <msdos_format_printf>
200e8b0: 94 12 a0 a0 or %o2, 0xa0, %o2
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
200e8b4: 80 a6 60 00 cmp %i1, 0
200e8b8: 02 80 02 66 be 200f250 <msdos_format+0x1084>
200e8bc: 82 10 20 02 mov 2, %g1
(rqdata->fat_num == 0)) {
200e8c0: d6 06 60 0c ld [ %i1 + 0xc ], %o3
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
200e8c4: 80 a2 e0 00 cmp %o3, 0
200e8c8: 22 80 00 82 be,a 200ead0 <msdos_format+0x904>
200e8cc: 15 00 80 b4 sethi %hi(0x202d000), %o2
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
200e8d0: 80 a2 e0 06 cmp %o3, 6
200e8d4: 18 80 02 09 bgu 200f0f8 <msdos_format+0xf2c>
200e8d8: 90 10 00 19 mov %i1, %o0
fmt_params->fat_num = rqdata->fat_num;
200e8dc: d6 2f bd dc stb %o3, [ %fp + -548 ]
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e8e0: 92 10 20 02 mov 2, %o1
200e8e4: 15 00 80 b4 sethi %hi(0x202d000), %o2
200e8e8: 7f ff fd 7e call 200dee0 <msdos_format_printf>
200e8ec: 94 12 a0 e0 or %o2, 0xe0, %o2 ! 202d0e0 <_CPU_Trap_slot_template+0xb8>
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
200e8f0: 10 80 00 7f b 200eaec <msdos_format+0x920>
200e8f4: c2 06 60 08 ld [ %i1 + 8 ], %g1
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
200e8f8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
200e8fc: 10 bf fe 64 b 200e28c <msdos_format+0xc0> <== NOT EXECUTED
200e900: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
200e904: 10 bf fe 62 b 200e28c <msdos_format+0xc0> <== NOT EXECUTED
200e908: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
200e90c: 92 10 20 00 clr %o1
200e910: 94 10 22 00 mov 0x200, %o2
200e914: 40 00 3c ea call 201dcbc <memset>
200e918: 90 07 be 00 add %fp, -512, %o0
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
200e91c: 84 10 20 61 mov 0x61, %g2
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
200e920: d4 07 bd ac ld [ %fp + -596 ], %o2
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
200e924: c4 2f be 02 stb %g2, [ %fp + -510 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200e928: c4 2f bf e7 stb %g2, [ %fp + -25 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200e92c: 84 10 20 55 mov 0x55, %g2
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
200e930: 82 10 3f ff mov -1, %g1
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
200e934: 86 10 20 41 mov 0x41, %g3
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200e938: 88 10 20 72 mov 0x72, %g4
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200e93c: c4 2f bf fe stb %g2, [ %fp + -2 ]
200e940: 84 10 3f aa mov -86, %g2
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
200e944: b8 10 20 52 mov 0x52, %i4
200e948: c6 2f be 03 stb %g3, [ %fp + -509 ]
200e94c: f8 2f be 00 stb %i4, [ %fp + -512 ]
200e950: f8 2f be 01 stb %i4, [ %fp + -511 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200e954: c8 2f bf e4 stb %g4, [ %fp + -28 ]
200e958: c8 2f bf e5 stb %g4, [ %fp + -27 ]
200e95c: c6 2f bf e6 stb %g3, [ %fp + -26 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200e960: c4 2f bf ff stb %g2, [ %fp + -1 ]
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
200e964: c2 2f bf e8 stb %g1, [ %fp + -24 ]
200e968: c2 2f bf e9 stb %g1, [ %fp + -23 ]
200e96c: c2 2f bf ea stb %g1, [ %fp + -22 ]
200e970: c2 2f bf eb stb %g1, [ %fp + -21 ]
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
200e974: c2 2f bf ec stb %g1, [ %fp + -20 ]
200e978: c2 2f bf ed stb %g1, [ %fp + -19 ]
200e97c: c2 2f bf ee stb %g1, [ %fp + -18 ]
200e980: c2 2f bf ef stb %g1, [ %fp + -17 ]
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
200e984: 90 10 00 1b mov %i3, %o0
200e988: 92 10 00 1d mov %i5, %o1
200e98c: 7f ff fd 6a call 200df34 <msdos_format_write_sec>
200e990: 96 07 be 00 add %fp, -512, %o3
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
200e994: b0 92 20 00 orcc %o0, 0, %i0
200e998: 12 bf fe 3e bne 200e290 <msdos_format+0xc4> <== NEVER TAKEN
200e99c: 80 a6 ff ff cmp %i3, -1
ret_val = msdos_format_fill_sectors
(rqdata,
200e9a0: 10 bf ff 42 b 200e6a8 <msdos_format+0x4dc>
200e9a4: d2 07 bd bc ld [ %fp + -580 ], %o1
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
200e9a8: 94 10 22 00 mov 0x200, %o2
200e9ac: 40 00 3c c4 call 201dcbc <memset>
200e9b0: 90 07 be 00 add %fp, -512, %o0
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
200e9b4: c2 0f bd f2 ldub [ %fp + -526 ], %g1
200e9b8: c6 07 bd ec ld [ %fp + -532 ], %g3
200e9bc: c4 17 bd f0 lduh [ %fp + -528 ], %g2
200e9c0: c8 07 bd e8 ld [ %fp + -536 ], %g4
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
200e9c4: d2 07 bd cc ld [ %fp + -564 ], %o1
200e9c8: d4 07 bd ac ld [ %fp + -596 ], %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);
200e9cc: c2 2f be 0a stb %g1, [ %fp + -502 ]
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
200e9d0: 82 10 20 08 mov 8, %g1
/*
* 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);
200e9d4: c8 27 be 00 st %g4, [ %fp + -512 ]
200e9d8: c6 27 be 04 st %g3, [ %fp + -508 ]
200e9dc: c4 37 be 08 sth %g2, [ %fp + -504 ]
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
200e9e0: 90 10 00 1b mov %i3, %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;
200e9e4: c2 2f be 0b stb %g1, [ %fp + -501 ]
ret_val = msdos_format_write_sec
200e9e8: 7f ff fd 53 call 200df34 <msdos_format_write_sec>
200e9ec: 96 07 be 00 add %fp, -512, %o3
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if (ret_val == 0) {
200e9f0: 80 a2 20 00 cmp %o0, 0
200e9f4: 22 bf ff 47 be,a 200e710 <msdos_format+0x544> <== ALWAYS TAKEN
200e9f8: 90 07 be 00 add %fp, -512, %o0
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
200e9fc: 10 bf fe 24 b 200e28c <msdos_format+0xc0> <== NOT EXECUTED
200ea00: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
200ea04: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
200ea08: c2 2f bd 4f stb %g1, [ %fp + -689 ] <== NOT EXECUTED
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
200ea0c: 40 00 39 b0 call 201d0cc <__errno> <== NOT EXECUTED
200ea10: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200ea14: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200ea18: 10 bf fe 39 b 200e2fc <msdos_format+0x130> <== NOT EXECUTED
200ea1c: c2 22 00 00 st %g1, [ %o0 ] <== 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);
200ea20: 7f ff ce db call 200258c <.umul>
200ea24: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
200ea28: c2 07 bd b8 ld [ %fp + -584 ], %g1
/*
* 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);
200ea2c: 90 07 40 08 add %i5, %o0, %o0
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
200ea30: c2 27 bd d0 st %g1, [ %fp + -560 ]
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
200ea34: 10 bf fe 3e b 200e32c <msdos_format+0x160>
200ea38: d0 27 bd cc st %o0, [ %fp + -564 ]
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);
200ea3c: c4 0f bd dd ldub [ %fp + -547 ], %g2
200ea40: 82 10 3f ff mov -1, %g1
200ea44: c4 2f be 00 stb %g2, [ %fp + -512 ]
200ea48: c2 2f be 01 stb %g1, [ %fp + -511 ]
200ea4c: c2 2f be 02 stb %g1, [ %fp + -510 ]
200ea50: c2 2f be 03 stb %g1, [ %fp + -509 ]
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
200ea54: 84 10 3f f8 mov -8, %g2
200ea58: c2 2f be 05 stb %g1, [ %fp + -507 ]
200ea5c: c2 2f be 06 stb %g1, [ %fp + -506 ]
200ea60: c4 2f be 04 stb %g2, [ %fp + -508 ]
200ea64: 82 10 20 0f mov 0xf, %g1
200ea68: 90 10 20 00 clr %o0
200ea6c: c2 2f be 07 stb %g1, [ %fp + -505 ]
/*
* 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);
200ea70: 82 10 3f ff mov -1, %g1
200ea74: 84 10 3f f8 mov -8, %g2
200ea78: c2 2f be 09 stb %g1, [ %fp + -503 ]
200ea7c: c2 2f be 0a stb %g1, [ %fp + -502 ]
200ea80: c4 2f be 08 stb %g2, [ %fp + -504 ]
200ea84: 82 10 20 0f mov 0xf, %g1
200ea88: 10 bf ff 35 b 200e75c <msdos_format+0x590>
200ea8c: c2 2f be 0b stb %g1, [ %fp + -501 ]
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
200ea90: 90 10 20 00 clr %o0
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
200ea94: c2 2f be 00 stb %g1, [ %fp + -512 ]
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
200ea98: 82 10 3f 8f mov -113, %g1
200ea9c: c2 2f be 01 stb %g1, [ %fp + -511 ]
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
200eaa0: 82 10 3f ff mov -1, %g1
200eaa4: 10 bf ff 2e b 200e75c <msdos_format+0x590>
200eaa8: c2 2f be 02 stb %g1, [ %fp + -510 ]
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
200eaac: c4 0f bd dd ldub [ %fp + -547 ], %g2
FAT_SET_VAL8(tmp_sec,1,0xff);
200eab0: 82 10 3f ff mov -1, %g1
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);
200eab4: c4 2f be 00 stb %g2, [ %fp + -512 ]
FAT_SET_VAL8(tmp_sec,1,0xff);
200eab8: c2 2f be 01 stb %g1, [ %fp + -511 ]
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
200eabc: 84 10 3f f8 mov -8, %g2
200eac0: c2 2f be 03 stb %g1, [ %fp + -509 ]
200eac4: c4 2f be 02 stb %g2, [ %fp + -510 ]
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
200eac8: 10 bf ff 25 b 200e75c <msdos_format+0x590>
200eacc: 90 10 20 00 clr %o0
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
200ead0: c2 2f bd dc stb %g1, [ %fp + -548 ]
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200ead4: 90 10 00 19 mov %i1, %o0
200ead8: 92 10 20 02 mov 2, %o1
200eadc: 94 12 a0 e0 or %o2, 0xe0, %o2
200eae0: 7f ff fd 00 call 200dee0 <msdos_format_printf>
200eae4: 96 10 20 02 mov 2, %o3
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
200eae8: c2 06 60 08 ld [ %i1 + 8 ], %g1
200eaec: 80 a0 60 00 cmp %g1, 0
200eaf0: 02 80 01 75 be 200f0c4 <msdos_format+0xef8>
200eaf4: 07 00 00 1f sethi %hi(0x7c00), %g3
200eaf8: 85 28 60 02 sll %g1, 2, %g2
200eafc: 87 28 60 0a sll %g1, 0xa, %g3
200eb00: 86 20 c0 02 sub %g3, %g2, %g3
200eb04: 86 00 c0 01 add %g3, %g1, %g3
200eb08: 87 28 e0 02 sll %g3, 2, %g3
200eb0c: 86 00 c0 01 add %g3, %g1, %g3
fat12_sect_per_clust = rqdata->sectors_per_cluster;
fat16_sect_per_clust = rqdata->sectors_per_cluster;
}
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
200eb10: c4 07 bd b0 ld [ %fp + -592 ], %g2
200eb14: 80 a0 80 03 cmp %g2, %g3
200eb18: 1a 80 01 4f bcc 200f054 <msdos_format+0xe88>
200eb1c: 87 28 60 02 sll %g1, 2, %g3
fmt_params->fattype = FAT_FAT12;
200eb20: 82 10 20 01 mov 1, %g1
200eb24: c2 2f bd de stb %g1, [ %fp + -546 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
200eb28: 82 10 20 02 mov 2, %g1
200eb2c: c2 27 bd b8 st %g1, [ %fp + -584 ]
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
200eb30: 90 10 00 19 mov %i1, %o0
200eb34: 7f ff fd 85 call 200e148 <msdos_set_sectors_per_cluster_from_request>
200eb38: 92 07 bd ac add %fp, -596, %o1
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
200eb3c: b0 92 20 00 orcc %o0, 0, %i0
200eb40: 12 80 01 d4 bne 200f290 <msdos_format+0x10c4> <== NEVER TAKEN
200eb44: c2 0f bd de ldub [ %fp + -546 ], %g1
&& fmt_params->fattype != fat_type
200eb48: 80 a0 60 ff cmp %g1, 0xff
200eb4c: 02 80 01 cc be 200f27c <msdos_format+0x10b0> <== NEVER TAKEN
200eb50: c2 07 bd b0 ld [ %fp + -592 ], %g1
&& fmt_params->totl_sector_cnt > 0 ) {
200eb54: 80 a0 60 00 cmp %g1, 0
200eb58: 02 bf ff ab be 200ea04 <msdos_format+0x838> <== NEVER TAKEN
200eb5c: 80 a0 00 19 cmp %g0, %i1
200eb60: 84 40 20 00 addx %g0, 0, %g2
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
200eb64: 98 10 20 00 clr %o4
200eb68: c4 2f bd 4f stb %g2, [ %fp + -689 ]
200eb6c: 1b 10 00 00 sethi %hi(0x40000000), %o5
200eb70: 86 87 40 0d addcc %i5, %o5, %g3
200eb74: 84 47 00 0c addx %i4, %o4, %g2
200eb78: 89 28 a0 02 sll %g2, 2, %g4
200eb7c: 85 30 e0 1e srl %g3, 0x1e, %g2
200eb80: 84 11 00 02 or %g4, %g2, %g2
200eb84: c4 27 bd 40 st %g2, [ %fp + -704 ]
200eb88: c4 0f bd 4f ldub [ %fp + -689 ], %g2
200eb8c: ac 10 20 00 clr %l6
200eb90: c4 27 bd 50 st %g2, [ %fp + -688 ]
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
200eb94: c6 07 bd 50 ld [ %fp + -688 ], %g3
200eb98: 80 a0 e0 00 cmp %g3, 0
200eb9c: 02 80 00 05 be 200ebb0 <msdos_format+0x9e4>
200eba0: d6 07 bd b8 ld [ %fp + -584 ], %o3
fmt_params->skip_alignment = rqdata->skip_alignment;
200eba4: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
200eba8: c2 2f bd fc stb %g1, [ %fp + -516 ]
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200ebac: d6 07 bd b8 ld [ %fp + -584 ], %o3
200ebb0: 90 10 00 19 mov %i1, %o0
200ebb4: 92 10 20 02 mov 2, %o1
200ebb8: 15 00 80 b4 sethi %hi(0x202d000), %o2
200ebbc: 7f ff fc c9 call 200dee0 <msdos_format_printf>
200ebc0: 94 12 a0 f8 or %o2, 0xf8, %o2 ! 202d0f8 <_CPU_Trap_slot_template+0xd0>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
200ebc4: fa 0f bd de ldub [ %fp + -546 ], %i5
200ebc8: 80 a7 60 04 cmp %i5, 4
200ebcc: 02 80 01 13 be 200f018 <msdos_format+0xe4c>
200ebd0: c4 07 bd 50 ld [ %fp + -688 ], %g2
fmt_params->fsinfo_sec = 1;
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
200ebd4: 82 10 20 01 mov 1, %g1
/* 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) &&
200ebd8: 80 a0 a0 00 cmp %g2, 0
200ebdc: 02 80 01 09 be 200f000 <msdos_format+0xe34>
200ebe0: c2 27 bd b4 st %g1, [ %fp + -588 ]
(rqdata->files_per_root_dir > 0)) {
200ebe4: d0 06 60 10 ld [ %i1 + 0x10 ], %o0
/* 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) &&
200ebe8: 80 a2 20 00 cmp %o0, 0
200ebec: 02 80 01 06 be 200f004 <msdos_format+0xe38>
200ebf0: 82 1f 60 02 xor %i5, 2, %g1
200ebf4: 90 02 3f ff add %o0, -1, %o0
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
200ebf8: f4 07 bd ac ld [ %fp + -596 ], %i2
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
200ebfc: b8 10 20 01 mov 1, %i4
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
200ec00: 93 2e a0 01 sll %i2, 1, %o1
200ec04: 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 +
200ec08: a0 02 00 09 add %o0, %o1, %l0
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
200ec0c: 40 00 6e 7a call 202a5f4 <.urem>
200ec10: 90 10 00 10 mov %l0, %o0
200ec14: 90 24 00 08 sub %l0, %o0, %o0
200ec18: d0 27 bd c4 st %o0, [ %fp + -572 ]
200ec1c: 91 2a 20 05 sll %o0, 5, %o0
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
200ec20: 92 10 00 1a mov %i2, %o1
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
200ec24: aa 06 bf ff add %i2, -1, %l5
/ fmt_params->bytes_per_sector);
200ec28: 7f ff ce 93 call 2002674 <.udiv>
200ec2c: 90 05 40 08 add %l5, %o0, %o0
if (ret_val == 0) {
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
200ec30: ee 07 bd b8 ld [ %fp + -584 ], %l7
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
200ec34: d0 27 bd 44 st %o0, [ %fp + -700 ]
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 =
200ec38: d0 27 bd c8 st %o0, [ %fp + -568 ]
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
200ec3c: 92 10 00 1a mov %i2, %o1
200ec40: 7f ff ce 8d call 2002674 <.udiv>
200ec44: 11 00 00 20 sethi %hi(0x8000), %o0
if (ret_val == 0) {
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
200ec48: e6 07 bd b0 ld [ %fp + -592 ], %l3
200ec4c: e8 0f bd dc ldub [ %fp + -548 ], %l4
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
200ec50: 80 a5 c0 08 cmp %l7, %o0
200ec54: 08 80 00 06 bleu 200ec6c <msdos_format+0xaa0> <== ALWAYS TAKEN
200ec58: e0 0f bd fc ldub [ %fp + -516 ], %l0
sectors_per_cluster /= 2;
200ec5c: af 35 e0 01 srl %l7, 1, %l7 <== NOT EXECUTED
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
200ec60: 80 a2 00 17 cmp %o0, %l7 <== NOT EXECUTED
200ec64: 2a bf ff ff bcs,a 200ec60 <msdos_format+0xa94> <== NOT EXECUTED
200ec68: af 35 e0 01 srl %l7, 1, %l7 <== NOT EXECUTED
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ec6c: c2 07 bd 44 ld [ %fp + -700 ], %g1
* 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_sect_cnt = total_sector_cnt
200ec70: 86 24 c0 1c sub %l3, %i4, %g3
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ec74: 82 00 7f ff add %g1, -1, %g1
200ec78: b8 07 3f ff add %i4, -1, %i4
200ec7c: a8 0d 20 ff and %l4, 0xff, %l4
200ec80: a0 0c 20 ff and %l0, 0xff, %l0
* 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_sect_cnt = total_sector_cnt
200ec84: c6 27 bd 38 st %g3, [ %fp + -712 ]
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ec88: f8 27 bd 54 st %i4, [ %fp + -684 ]
200ec8c: c2 27 bd 3c st %g1, [ %fp + -708 ]
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200ec90: 80 a4 20 00 cmp %l0, 0
200ec94: 02 80 00 0a be 200ecbc <msdos_format+0xaf0>
200ec98: c6 07 bd 54 ld [ %fp + -684 ], %g3
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
200ec9c: 80 a7 60 01 cmp %i5, 1
200eca0: 02 80 01 89 be 200f2c4 <msdos_format+0x10f8>
200eca4: d0 07 bd 38 ld [ %fp + -712 ], %o0
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
200eca8: 80 a7 60 02 cmp %i5, 2
200ecac: 12 80 00 0d bne 200ece0 <msdos_format+0xb14> <== NEVER TAKEN
200ecb0: c4 07 bd 44 ld [ %fp + -700 ], %g2
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
200ecb4: 10 80 00 9f b 200ef30 <msdos_format+0xd64>
200ecb8: 90 22 00 02 sub %o0, %g2, %o0
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ecbc: 84 20 00 17 neg %l7, %g2
200ecc0: 90 00 c0 17 add %g3, %l7, %o0
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
200ecc4: 80 a7 60 01 cmp %i5, 1
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ecc8: 90 08 80 08 and %g2, %o0, %o0
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
200eccc: 02 80 00 8b be 200eef8 <msdos_format+0xd2c>
200ecd0: 90 24 c0 08 sub %l3, %o0, %o0
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
200ecd4: 80 a7 60 02 cmp %i5, 2
200ecd8: 02 80 00 93 be 200ef24 <msdos_format+0xd58>
200ecdc: c2 07 bd 3c ld [ %fp + -708 ], %g1
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
fat_capacity = fatdata_cluster_cnt * 2;
}
else { /* FAT32 */
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
200ece0: 7f ff ce 65 call 2002674 <.udiv>
200ece4: 92 10 00 17 mov %l7, %o1
200ece8: a4 10 00 08 mov %o0, %l2
fat_capacity = fatdata_cluster_cnt * 4;
200ecec: 91 2a 20 02 sll %o0, 2, %o0
}
sectors_per_fat = ((fat_capacity
200ecf0: 92 10 00 1a mov %i2, %o1
200ecf4: 7f ff ce 60 call 2002674 <.udiv>
200ecf8: 90 02 00 15 add %o0, %l5, %o0
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
200ecfc: 7f ff ce 24 call 200258c <.umul>
200ed00: 92 10 00 14 mov %l4, %o1
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200ed04: 80 a4 20 00 cmp %l0, 0
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
200ed08: b8 10 00 08 mov %o0, %i4
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200ed0c: 12 80 00 05 bne 200ed20 <msdos_format+0xb54>
200ed10: 90 05 ff ff add %l7, -1, %o0
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ed14: 84 20 00 17 neg %l7, %g2
200ed18: b8 07 00 08 add %i4, %o0, %i4
200ed1c: b8 0f 00 02 and %i4, %g2, %i4
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
((fat_sectors_cnt
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
200ed20: 90 02 00 1c add %o0, %i4, %o0
200ed24: 7f ff ce 54 call 2002674 <.udiv>
200ed28: 92 10 00 17 mov %l7, %o1
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
200ed2c: 80 a7 60 01 cmp %i5, 1
200ed30: 02 80 00 59 be 200ee94 <msdos_format+0xcc8>
200ed34: a4 24 80 08 sub %l2, %o0, %l2
200ed38: 80 a7 60 02 cmp %i5, 2
200ed3c: 02 80 00 67 be 200eed8 <msdos_format+0xd0c>
200ed40: a2 10 20 01 mov 1, %l1
*/
if (fattype == FAT_FAT12) {
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
finished = true;
}
} else if ((sectors_per_cluster * bytes_per_sector)
200ed44: 90 10 00 17 mov %l7, %o0
200ed48: 7f ff ce 11 call 200258c <.umul>
200ed4c: 92 10 00 1a mov %i2, %o1
200ed50: 03 00 00 20 sethi %hi(0x8000), %g1
200ed54: 80 a2 00 01 cmp %o0, %g1
200ed58: 08 80 00 5c bleu 200eec8 <msdos_format+0xcfc>
200ed5c: 80 8c 60 ff btst 0xff, %l1
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
200ed60: 92 10 00 14 mov %l4, %o1
200ed64: 7f ff ce 44 call 2002674 <.udiv>
200ed68: 90 10 00 1c mov %i4, %o0
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
200ed6c: 05 00 80 b4 sethi %hi(0x202d000), %g2
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
200ed70: d0 27 bd bc st %o0, [ %fp + -580 ]
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
200ed74: d0 00 a1 b0 ld [ %g2 + 0x1b0 ], %o0
200ed78: 92 10 00 1a mov %i2, %o1
200ed7c: 7f ff ce 3e call 2002674 <.udiv>
200ed80: ee 27 bd b8 st %l7, [ %fp + -584 ]
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
if ( number_of_clusters < FAT_FAT12_MAX_CLN
200ed84: 80 a2 00 17 cmp %o0, %l7
200ed88: 1a 80 00 6f bcc 200ef44 <msdos_format+0xd78>
200ed8c: 80 a4 af f4 cmp %l2, 0xff4
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
200ed90: 07 00 80 b4 sethi %hi(0x202d000), %g3
200ed94: d0 00 e1 b4 ld [ %g3 + 0x1b4 ], %o0 ! 202d1b4 <_CPU_Trap_slot_template+0x18c>
200ed98: 7f ff ce 37 call 2002674 <.udiv>
200ed9c: 92 10 00 1a mov %i2, %o1
if ( number_of_clusters < FAT_FAT12_MAX_CLN
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
fattype = FAT_FAT12;
}
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
200eda0: 80 a2 00 17 cmp %o0, %l7
200eda4: 2a 80 00 07 bcs,a 200edc0 <msdos_format+0xbf4>
200eda8: 84 10 20 04 mov 4, %g2
200edac: 03 00 00 3f sethi %hi(0xfc00), %g1
200edb0: 82 10 63 f4 or %g1, 0x3f4, %g1 ! fff4 <PROM_START+0xfff4>
200edb4: 80 a0 40 12 cmp %g1, %l2
200edb8: 0a 80 00 35 bcs 200ee8c <msdos_format+0xcc0>
200edbc: 84 10 20 02 mov 2, %g2
fmt_params->fattype = msdos_get_fat_type(
fmt_params->bytes_per_sector,
fmt_params->sectors_per_cluster,
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
200edc0: 82 08 a0 ff and %g2, 0xff, %g1
200edc4: 80 a7 40 01 cmp %i5, %g1
200edc8: 12 80 00 65 bne 200ef5c <msdos_format+0xd90>
200edcc: c4 2f bd de stb %g2, [ %fp + -546 ]
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
200edd0: 80 a4 e0 00 cmp %l3, 0
200edd4: 02 bf ff 0e be 200ea0c <msdos_format+0x840> <== NEVER TAKEN
200edd8: c2 0f bd de ldub [ %fp + -546 ], %g1
ret_val = -1;
}
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
200eddc: 80 a0 60 04 cmp %g1, 4
200ede0: 02 80 00 e5 be 200f174 <msdos_format+0xfa8>
200ede4: d0 07 bd c8 ld [ %fp + -568 ], %o0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200ede8: f8 0f bd fc ldub [ %fp + -516 ], %i4
200edec: 80 a7 20 00 cmp %i4, 0
200edf0: 12 80 00 06 bne 200ee08 <msdos_format+0xc3c>
200edf4: f4 07 bd b8 ld [ %fp + -584 ], %i2
return (sectors + clustersize - 1) & ~(clustersize - 1);
200edf8: 90 02 00 1a add %o0, %i2, %o0
200edfc: 82 20 00 1a neg %i2, %g1
200ee00: 90 02 3f ff add %o0, -1, %o0
200ee04: 90 0a 00 01 and %o0, %g1, %o0
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
200ee08: d2 07 bd ac ld [ %fp + -596 ], %o1
200ee0c: 7f ff cd e0 call 200258c <.umul>
200ee10: 93 32 60 05 srl %o1, 5, %o1
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
200ee14: d0 27 bd c4 st %o0, [ %fp + -572 ]
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200ee18: 80 a7 20 00 cmp %i4, 0
200ee1c: 12 80 00 06 bne 200ee34 <msdos_format+0xc68>
200ee20: fa 07 bd b4 ld [ %fp + -588 ], %i5
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ee24: ba 07 7f ff add %i5, -1, %i5
200ee28: 82 20 00 1a neg %i2, %g1
200ee2c: ba 07 40 1a add %i5, %i2, %i5
200ee30: ba 0f 40 01 and %i5, %g1, %i5
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
200ee34: 80 a6 60 00 cmp %i1, 0
200ee38: 02 80 00 83 be 200f044 <msdos_format+0xe78>
200ee3c: fa 27 bd b4 st %i5, [ %fp + -588 ]
(rqdata->media != 0)) {
200ee40: f8 0e 60 14 ldub [ %i1 + 0x14 ], %i4
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
200ee44: b4 8f 20 ff andcc %i4, 0xff, %i2
200ee48: 02 80 00 80 be 200f048 <msdos_format+0xe7c>
200ee4c: 82 10 3f f8 mov -8, %g1
(rqdata->media != 0)) {
const char valid_media_codes[] =
200ee50: 94 10 20 09 mov 9, %o2
200ee54: 90 07 be 00 add %fp, -512, %o0
200ee58: 13 00 80 b4 sethi %hi(0x202d000), %o1
200ee5c: 40 00 3b 5b call 201dbc8 <memcpy>
200ee60: 92 12 61 a0 or %o1, 0x1a0, %o1 ! 202d1a0 <_CPU_Trap_slot_template+0x178>
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
200ee64: 90 07 be 00 add %fp, -512, %o0
200ee68: 92 10 00 1a mov %i2, %o1
200ee6c: 40 00 3a e9 call 201da10 <memchr>
200ee70: 94 10 20 09 mov 9, %o2
200ee74: 80 a2 20 00 cmp %o0, 0
200ee78: 02 80 01 0c be 200f2a8 <msdos_format+0x10dc> <== ALWAYS TAKEN
200ee7c: 01 00 00 00 nop
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
200ee80: f8 2f bd dd stb %i4, [ %fp + -547 ] <== NOT EXECUTED
200ee84: 10 bf fd 20 b 200e304 <msdos_format+0x138> <== NOT EXECUTED
200ee88: f8 0f bd 4f ldub [ %fp + -689 ], %i4 <== NOT EXECUTED
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
200ee8c: 10 bf ff cd b 200edc0 <msdos_format+0xbf4>
200ee90: 84 10 20 04 mov 4, %g2
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
200ee94: 80 a4 af f5 cmp %l2, 0xff5
200ee98: 08 80 00 04 bleu 200eea8 <msdos_format+0xcdc>
200ee9c: a2 10 20 01 mov 1, %l1
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
200eea0: af 2d e0 01 sll %l7, 1, %l7
200eea4: a2 10 20 00 clr %l1
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if (fattype == FAT_FAT12) {
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
200eea8: 90 10 00 17 mov %l7, %o0
200eeac: 7f ff cd b8 call 200258c <.umul>
200eeb0: 92 10 00 1a mov %i2, %o1
200eeb4: 07 00 00 04 sethi %hi(0x1000), %g3
200eeb8: 80 a2 00 03 cmp %o0, %g3
200eebc: 38 bf ff aa bgu,a 200ed64 <msdos_format+0xb98>
200eec0: 92 10 00 14 mov %l4, %o1
}
} else if ((sectors_per_cluster * bytes_per_sector)
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
200eec4: 80 8c 60 ff btst 0xff, %l1
200eec8: 02 bf ff 73 be 200ec94 <msdos_format+0xac8>
200eecc: 80 a4 20 00 cmp %l0, 0
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
200eed0: 10 bf ff a5 b 200ed64 <msdos_format+0xb98>
200eed4: 92 10 00 14 mov %l4, %o1
/ sectors_per_cluster));
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
200eed8: 05 00 00 3f sethi %hi(0xfc00), %g2
200eedc: 84 10 a3 f5 or %g2, 0x3f5, %g2 ! fff5 <PROM_START+0xfff5>
200eee0: 80 a4 80 02 cmp %l2, %g2
200eee4: 08 bf ff 99 bleu 200ed48 <msdos_format+0xb7c>
200eee8: 90 10 00 17 mov %l7, %o0
sectors_per_cluster *= 2;
200eeec: af 2d e0 01 sll %l7, 1, %l7
200eef0: 10 bf ff 95 b 200ed44 <msdos_format+0xb78>
200eef4: a2 10 20 00 clr %l1
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200eef8: c2 07 bd 3c ld [ %fp + -708 ], %g1
200eefc: 86 00 40 17 add %g1, %l7, %g3
200ef00: 84 08 c0 02 and %g3, %g2, %g2
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
200ef04: 90 22 00 02 sub %o0, %g2, %o0
200ef08: 7f ff cd db call 2002674 <.udiv>
200ef0c: 92 10 00 17 mov %l7, %o1
200ef10: a4 10 00 08 mov %o0, %l2
fat_capacity = fatdata_cluster_cnt * 3 / 2;
200ef14: 91 2a 20 01 sll %o0, 1, %o0
200ef18: 90 02 00 12 add %o0, %l2, %o0
200ef1c: 10 bf ff 75 b 200ecf0 <msdos_format+0xb24>
200ef20: 91 32 20 01 srl %o0, 1, %o0
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200ef24: 86 00 40 17 add %g1, %l7, %g3
200ef28: 84 08 80 03 and %g2, %g3, %g2
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
200ef2c: 90 22 00 02 sub %o0, %g2, %o0
200ef30: 7f ff cd d1 call 2002674 <.udiv>
200ef34: 92 10 00 17 mov %l7, %o1
200ef38: a4 10 00 08 mov %o0, %l2
fat_capacity = fatdata_cluster_cnt * 2;
200ef3c: 10 bf ff 6d b 200ecf0 <msdos_format+0xb24>
200ef40: 91 2a 20 01 sll %o0, 1, %o0
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
if ( number_of_clusters < FAT_FAT12_MAX_CLN
200ef44: 18 bf ff 93 bgu 200ed90 <msdos_format+0xbc4>
200ef48: 84 10 20 01 mov 1, %g2
fmt_params->fattype = msdos_get_fat_type(
fmt_params->bytes_per_sector,
fmt_params->sectors_per_cluster,
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
200ef4c: 82 08 a0 ff and %g2, 0xff, %g1
200ef50: 80 a7 40 01 cmp %i5, %g1
200ef54: 02 bf ff 9f be 200edd0 <msdos_format+0xc04> <== ALWAYS TAKEN
200ef58: c4 2f bd de stb %g2, [ %fp + -546 ]
msdos_set_default_sectors_per_cluster_for_fattype(
msdos_format_param_t *fmt_params,
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
|| fmt_params->fattype == FAT_FAT16 ) {
200ef5c: 84 00 bf ff add %g2, -1, %g2
static void
msdos_set_default_sectors_per_cluster_for_fattype(
msdos_format_param_t *fmt_params,
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
200ef60: 84 08 a0 ff and %g2, 0xff, %g2
200ef64: 80 a0 a0 01 cmp %g2, 1
200ef68: 18 80 00 06 bgu 200ef80 <msdos_format+0xdb4>
200ef6c: 82 10 20 1f mov 0x1f, %g1
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
200ef70: 10 80 00 af b 200f22c <msdos_format+0x1060>
200ef74: 82 10 20 02 mov 2, %g1
else {
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
int b;
/* scale with the size of disk... */
for ( b = 31; b > 0; b-- ) {
200ef78: 02 80 00 08 be 200ef98 <msdos_format+0xdcc> <== NEVER TAKEN
200ef7c: 84 10 20 01 mov 1, %g2
if ( (gigs & ( 1 << b) ) != 0 )
200ef80: 86 10 20 01 mov 1, %g3
200ef84: 85 28 c0 01 sll %g3, %g1, %g2
200ef88: c6 07 bd 40 ld [ %fp + -704 ], %g3
200ef8c: 80 88 80 03 btst %g2, %g3
200ef90: 02 bf ff fa be 200ef78 <msdos_format+0xdac>
200ef94: 82 80 7f ff addcc %g1, -1, %g1
break;
}
fmt_params->sectors_per_cluster = 1 << b;
200ef98: c4 27 bd b8 st %g2, [ %fp + -584 ]
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
msdos_set_default_sectors_per_cluster_for_fattype( fmt_params,
total_size );
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
200ef9c: 90 10 00 19 mov %i1, %o0
200efa0: 7f ff fc 6a call 200e148 <msdos_set_sectors_per_cluster_from_request>
200efa4: 92 07 bd ac add %fp, -596, %o1
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
200efa8: c2 0f bd de ldub [ %fp + -546 ], %g1
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
msdos_set_default_sectors_per_cluster_for_fattype( fmt_params,
total_size );
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
200efac: 84 10 00 08 mov %o0, %g2
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
200efb0: 86 08 60 ff and %g1, 0xff, %g3
200efb4: 80 a7 40 03 cmp %i5, %g3
200efb8: 02 80 00 08 be 200efd8 <msdos_format+0xe0c> <== NEVER TAKEN
200efbc: e6 07 bd b0 ld [ %fp + -592 ], %l3
200efc0: 86 0d a0 ff and %l6, 0xff, %g3
200efc4: 80 a0 e0 01 cmp %g3, 1
200efc8: 08 80 00 05 bleu 200efdc <msdos_format+0xe10>
200efcc: 80 a0 a0 00 cmp %g2, 0
--fmt_params->totl_sector_cnt;
200efd0: a6 04 ff ff add %l3, -1, %l3
200efd4: e6 27 bd b0 st %l3, [ %fp + -592 ]
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
200efd8: 80 a0 a0 00 cmp %g2, 0
200efdc: 12 bf fc c4 bne 200e2ec <msdos_format+0x120> <== NEVER TAKEN
200efe0: ac 05 a0 01 inc %l6
&& fmt_params->fattype != fat_type
200efe4: 82 08 60 ff and %g1, 0xff, %g1
200efe8: 80 a7 40 01 cmp %i5, %g1
200efec: 02 bf ff 79 be 200edd0 <msdos_format+0xc04> <== NEVER TAKEN
200eff0: 80 a4 e0 00 cmp %l3, 0
&& fmt_params->totl_sector_cnt > 0 ) {
200eff4: 12 bf fe e9 bne 200eb98 <msdos_format+0x9cc> <== ALWAYS TAKEN
200eff8: c6 07 bd 50 ld [ %fp + -688 ], %g3
200effc: 30 bf fe 84 b,a 200ea0c <msdos_format+0x840> <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
200f000: 82 1f 60 02 xor %i5, 2, %g1
200f004: 80 a0 00 01 cmp %g0, %g1
200f008: 90 40 3f ff addx %g0, -1, %o0
200f00c: 90 0a 21 c0 and %o0, 0x1c0, %o0
200f010: 10 bf fe fa b 200ebf8 <msdos_format+0xa2c>
200f014: 90 02 20 3f add %o0, 0x3f, %o0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
200f018: 82 10 20 20 mov 0x20, %g1
/* 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;
200f01c: 84 10 20 06 mov 6, %g2
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
200f020: 86 10 20 01 mov 1, %g3
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
200f024: c2 27 bd b4 st %g1, [ %fp + -588 ]
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
200f028: c0 27 bd c4 clr [ %fp + -572 ]
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
200f02c: c4 27 bd d4 st %g2, [ %fp + -556 ]
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
200f030: c6 27 bd d8 st %g3, [ %fp + -552 ]
200f034: f4 07 bd ac ld [ %fp + -596 ], %i2
200f038: b8 10 20 20 mov 0x20, %i4
200f03c: 10 bf fe f9 b 200ec20 <msdos_format+0xa54>
200f040: 90 10 20 00 clr %o0
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
200f044: 82 10 3f f8 mov -8, %g1
200f048: f8 0f bd 4f ldub [ %fp + -689 ], %i4
200f04c: 10 bf fc ae b 200e304 <msdos_format+0x138>
200f050: c2 2f bd dd stb %g1, [ %fp + -547 ]
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
200f054: 89 28 60 0e sll %g1, 0xe, %g4
200f058: 86 21 00 03 sub %g4, %g3, %g3
200f05c: 86 00 c0 01 add %g3, %g1, %g3
200f060: 87 28 e0 02 sll %g3, 2, %g3
200f064: 82 00 c0 01 add %g3, %g1, %g1
200f068: 80 a0 80 01 cmp %g2, %g1
200f06c: 2a 80 00 1f bcs,a 200f0e8 <msdos_format+0xf1c>
200f070: 82 10 20 02 mov 2, %g1
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
200f074: 82 10 20 04 mov 4, %g1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
200f078: 98 10 20 00 clr %o4
200f07c: 1b 10 00 00 sethi %hi(0x40000000), %o5
200f080: 86 87 40 0d addcc %i5, %o5, %g3
200f084: 84 47 00 0c addx %i4, %o4, %g2
int b;
fmt_params->fattype = FAT_FAT32;
200f088: c2 2f bd de stb %g1, [ %fp + -546 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
200f08c: 89 28 a0 02 sll %g2, 2, %g4
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
200f090: 82 10 20 1f mov 0x1f, %g1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
200f094: 85 30 e0 1e srl %g3, 0x1e, %g2
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
200f098: 86 10 20 01 mov 1, %g3
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
200f09c: 10 80 00 04 b 200f0ac <msdos_format+0xee0>
200f0a0: 88 11 00 02 or %g4, %g2, %g4
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
200f0a4: 02 80 00 64 be 200f234 <msdos_format+0x1068>
200f0a8: 84 10 20 01 mov 1, %g2
if ((gigs & (1 << b)) != 0)
200f0ac: 85 28 c0 01 sll %g3, %g1, %g2
200f0b0: 80 88 80 04 btst %g2, %g4
200f0b4: 02 bf ff fc be 200f0a4 <msdos_format+0xed8>
200f0b8: 82 80 7f ff addcc %g1, -1, %g1
break;
fmt_params->sectors_per_cluster = 1 << b;
200f0bc: 10 bf fe 9d b 200eb30 <msdos_format+0x964>
200f0c0: c4 27 bd b8 st %g2, [ %fp + -584 ]
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
200f0c4: 82 10 20 20 mov 0x20, %g1
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
200f0c8: 10 bf fe 92 b 200eb10 <msdos_format+0x944>
200f0cc: 86 10 e3 a8 or %g3, 0x3a8, %g3
200f0d0: a1 30 60 08 srl %g1, 8, %l0
{
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) {
200f0d4: a2 10 20 00 clr %l1
200f0d8: a4 10 20 00 clr %l2
200f0dc: a6 10 20 00 clr %l3
200f0e0: 10 bf fd 0c b 200e510 <msdos_format+0x344>
200f0e4: a8 10 20 00 clr %l4
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
fmt_params->fattype = FAT_FAT16;
200f0e8: c2 2f bd de stb %g1, [ %fp + -546 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
200f0ec: 82 10 20 02 mov 2, %g1
200f0f0: 10 bf fe 90 b 200eb30 <msdos_format+0x964>
200f0f4: c2 27 bd b8 st %g1, [ %fp + -584 ]
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
errno = EINVAL;
200f0f8: 40 00 37 f5 call 201d0cc <__errno>
200f0fc: 01 00 00 00 nop
200f100: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
ret_val = -1;
200f104: 84 10 3f ff mov -1, %g2
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
errno = EINVAL;
200f108: 10 bf fc 75 b 200e2dc <msdos_format+0x110>
200f10c: c2 22 00 00 st %g1, [ %o0 ]
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
200f110: 03 00 80 b4 sethi %hi(0x202d000), %g1
200f114: 10 bf fd 3f b 200e610 <msdos_format+0x444>
200f118: 82 10 60 68 or %g1, 0x68, %g1 ! 202d068 <_CPU_Trap_slot_template+0x40>
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
}
else {
*volid_ptr = rand();
200f11c: 40 00 3d 73 call 201e6e8 <rand>
200f120: 01 00 00 00 nop
200f124: 10 bf fc c8 b 200e444 <msdos_format+0x278>
200f128: d0 27 bd f8 st %o0, [ %fp + -520 ]
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200f12c: 90 10 00 19 mov %i1, %o0
200f130: 15 00 80 b4 sethi %hi(0x202d000), %o2
200f134: 7f ff fb 6b call 200dee0 <msdos_format_printf>
200f138: 94 12 a1 48 or %o2, 0x148, %o2 ! 202d148 <_CPU_Trap_slot_template+0x120>
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
200f13c: d2 07 bd d4 ld [ %fp + -556 ], %o1
200f140: d4 07 bd ac ld [ %fp + -596 ], %o2
200f144: 90 10 00 1b mov %i3, %o0
200f148: 7f ff fb 7b call 200df34 <msdos_format_write_sec>
200f14c: 96 07 be 00 add %fp, -512, %o3
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
200f150: b0 92 20 00 orcc %o0, 0, %i0
200f154: 02 bf fd 52 be 200e69c <msdos_format+0x4d0> <== ALWAYS TAKEN
200f158: fa 07 bd d8 ld [ %fp + -552 ], %i5
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
200f15c: 10 bf fc 4d b 200e290 <msdos_format+0xc4> <== NOT EXECUTED
200f160: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
200f164: 10 bf fc 7c b 200e354 <msdos_format+0x188>
200f168: 88 11 20 88 or %g4, 0x88, %g4
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
200f16c: 10 bf fc 9a b 200e3d4 <msdos_format+0x208>
200f170: 88 11 22 d8 or %g4, 0x2d8, %g4
200f174: f4 07 bd b8 ld [ %fp + -584 ], %i2
200f178: 10 bf ff 28 b 200ee18 <msdos_format+0xc4c>
200f17c: f8 0f bd fc ldub [ %fp + -516 ], %i4
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
200f180: c2 07 bd bc ld [ %fp + -580 ], %g1
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 */
200f184: c4 07 bd d4 ld [ %fp + -556 ], %g2
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
200f188: b1 30 60 08 srl %g1, 8, %i0
200f18c: bb 30 60 10 srl %g1, 0x10, %i5
200f190: 89 30 60 18 srl %g1, 0x18, %g4
200f194: c2 2f be 24 stb %g1, [ %fp + -476 ]
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);
200f198: 82 10 20 29 mov 0x29, %g1
200f19c: c2 2f be 42 stb %g1, [ %fp + -446 ]
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
200f1a0: 03 00 00 11 sethi %hi(0x4400), %g1
200f1a4: 82 10 62 41 or %g1, 0x241, %g1 ! 4641 <PROM_START+0x4641>
200f1a8: c2 37 be 52 sth %g1, [ %fp + -430 ]
200f1ac: 03 00 00 15 sethi %hi(0x5400), %g1
200f1b0: 82 10 60 33 or %g1, 0x33, %g1 ! 5433 <PROM_START+0x5433>
200f1b4: c2 37 be 54 sth %g1, [ %fp + -428 ]
200f1b8: 03 00 00 0c sethi %hi(0x3000), %g1
200f1bc: 82 10 62 20 or %g1, 0x220, %g1 ! 3220 <PROM_START+0x3220>
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
200f1c0: 87 30 a0 08 srl %g2, 8, %g3
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
200f1c4: c2 37 be 56 sth %g1, [ %fp + -426 ]
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
200f1c8: f0 2f be 25 stb %i0, [ %fp + -475 ]
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
200f1cc: 03 00 00 08 sethi %hi(0x2000), %g1
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
200f1d0: fa 2f be 26 stb %i5, [ %fp + -474 ]
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
200f1d4: 82 10 60 20 or %g1, 0x20, %g1
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
200f1d8: c8 2f be 27 stb %g4, [ %fp + -473 ]
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 */
200f1dc: f4 2f be 2c stb %i2, [ %fp + -468 ]
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
200f1e0: f8 2f be 30 stb %i4, [ %fp + -464 ]
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
200f1e4: c4 2f be 32 stb %g2, [ %fp + -462 ]
200f1e8: c6 2f be 33 stb %g3, [ %fp + -461 ]
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
200f1ec: c0 27 be 34 clr [ %fp + -460 ]
200f1f0: c0 27 be 38 clr [ %fp + -456 ]
200f1f4: c0 27 be 3c clr [ %fp + -452 ]
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
200f1f8: c0 2f be 47 clrb [ %fp + -441 ]
200f1fc: c0 2f be 48 clrb [ %fp + -440 ]
200f200: c0 2f be 49 clrb [ %fp + -439 ]
200f204: c0 2f be 4a clrb [ %fp + -438 ]
200f208: c0 2f be 4b clrb [ %fp + -437 ]
200f20c: c0 2f be 4c clrb [ %fp + -436 ]
200f210: c0 2f be 4d clrb [ %fp + -435 ]
200f214: c0 2f be 4e clrb [ %fp + -434 ]
200f218: c0 2f be 4f clrb [ %fp + -433 ]
200f21c: c0 2f be 50 clrb [ %fp + -432 ]
200f220: c0 2f be 51 clrb [ %fp + -431 ]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
200f224: 10 bf fd 03 b 200e630 <msdos_format+0x464>
200f228: c2 37 be 58 sth %g1, [ %fp + -424 ]
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
200f22c: 10 bf ff 5c b 200ef9c <msdos_format+0xdd0>
200f230: c2 27 bd b8 st %g1, [ %fp + -584 ]
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
200f234: 10 bf fe 3f b 200eb30 <msdos_format+0x964>
200f238: c4 27 bd b8 st %g2, [ %fp + -584 ]
200f23c: c6 0f bd 4f ldub [ %fp + -689 ], %g3 <== NOT EXECUTED
200f240: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
200f244: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
200f248: 10 bf fd 69 b 200e7ec <msdos_format+0x620> <== NOT EXECUTED
200f24c: 82 08 40 03 and %g1, %g3, %g1 <== NOT EXECUTED
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200f250: 90 10 20 00 clr %o0
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
200f254: c2 2f bd dc stb %g1, [ %fp + -548 ]
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200f258: 92 10 20 02 mov 2, %o1
200f25c: 96 10 20 02 mov 2, %o3
200f260: 15 00 80 b4 sethi %hi(0x202d000), %o2
200f264: 7f ff fb 1f call 200dee0 <msdos_format_printf>
200f268: 94 12 a0 e0 or %o2, 0xe0, %o2 ! 202d0e0 <_CPU_Trap_slot_template+0xb8>
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
200f26c: 07 00 00 1f sethi %hi(0x7c00), %g3
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
200f270: 82 10 20 20 mov 0x20, %g1
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
200f274: 10 bf fe 27 b 200eb10 <msdos_format+0x944>
200f278: 86 10 e3 a8 or %g3, 0x3a8, %g3
200f27c: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
200f280: e6 07 bd b0 ld [ %fp + -592 ], %l3 <== NOT EXECUTED
200f284: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
200f288: 10 bf fe d2 b 200edd0 <msdos_format+0xc04> <== NOT EXECUTED
200f28c: c2 2f bd 4f stb %g1, [ %fp + -689 ] <== NOT EXECUTED
200f290: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
200f294: e6 07 bd b0 ld [ %fp + -592 ], %l3 <== NOT EXECUTED
200f298: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
200f29c: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED
200f2a0: 10 bf fc 13 b 200e2ec <msdos_format+0x120> <== NOT EXECUTED
200f2a4: c2 2f bd 4f stb %g1, [ %fp + -689 ] <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
200f2a8: 40 00 37 89 call 201d0cc <__errno>
200f2ac: b8 10 20 00 clr %i4
200f2b0: 82 10 20 16 mov 0x16, %g1
200f2b4: fa 07 bd b4 ld [ %fp + -588 ], %i5
200f2b8: c2 22 00 00 st %g1, [ %o0 ]
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
200f2bc: 10 bf fc 12 b 200e304 <msdos_format+0x138>
200f2c0: b0 10 3f ff mov -1, %i0
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
else
return sectors;
200f2c4: 10 bf ff 10 b 200ef04 <msdos_format+0xd38>
200f2c8: c4 07 bd 44 ld [ %fp + -700 ], %g2
0200df94 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200df94: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
200df98: 90 10 00 1c mov %i4, %o0
200df9c: 7f ff de 83 call 20059a8 <malloc>
200dfa0: a6 10 00 18 mov %i0, %l3
if (fill_buffer == NULL) {
200dfa4: 80 a2 20 00 cmp %o0, 0
200dfa8: 02 80 00 47 be 200e0c4 <msdos_format_fill_sectors+0x130> <== NEVER TAKEN
200dfac: a4 10 00 08 mov %o0, %l2
errno = ENOMEM;
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
200dfb0: 92 10 00 1d mov %i5, %o1
200dfb4: 40 00 3f 42 call 201dcbc <memset>
200dfb8: 94 10 00 1c mov %i4, %o2
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200dfbc: 90 10 00 18 mov %i0, %o0
200dfc0: 92 10 20 02 mov 2, %o1
200dfc4: 15 00 80 b4 sethi %hi(0x202d000), %o2
200dfc8: 7f ff ff c6 call 200dee0 <msdos_format_printf>
200dfcc: 94 12 a0 38 or %o2, 0x38, %o2 ! 202d038 <_CPU_Trap_slot_template+0x10>
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
200dfd0: 80 a6 e0 00 cmp %i3, 0
200dfd4: 02 80 00 56 be 200e12c <msdos_format_fill_sectors+0x198> <== NEVER TAKEN
200dfd8: 83 2e e0 04 sll %i3, 4, %g1
200dfdc: bb 2e e0 02 sll %i3, 2, %i5
(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, ".");
200dfe0: 29 00 80 b3 sethi %hi(0x202cc00), %l4
200dfe4: ba 07 40 01 add %i5, %g1, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
200dfe8: a0 10 00 1b mov %i3, %l0
200dfec: 83 2f 60 02 sll %i5, 2, %g1
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
200dff0: a2 10 3f ff mov -1, %l1
200dff4: ba 07 40 01 add %i5, %g1, %i5
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, ".");
200dff8: 10 80 00 10 b 200e038 <msdos_format_fill_sectors+0xa4>
200dffc: a8 15 21 e0 or %l4, 0x1e0, %l4
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
200e000: 92 10 00 1a mov %i2, %o1
200e004: 90 10 00 19 mov %i1, %o0
200e008: 94 10 00 1c mov %i4, %o2
200e00c: 96 10 00 12 mov %l2, %o3
200e010: 7f ff ff c9 call 200df34 <msdos_format_write_sec>
200e014: a0 04 3f ff add %l0, -1, %l0
start_sector++;
200e018: b4 06 a0 01 inc %i2
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);
200e01c: b0 10 00 08 mov %o0, %i0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
200e020: 80 a2 20 00 cmp %o0, 0
200e024: 12 80 00 1c bne 200e094 <msdos_format_fill_sectors+0x100> <== NEVER TAKEN
200e028: ba 07 7f 9c add %i5, -100, %i5
200e02c: 80 a4 20 00 cmp %l0, 0
200e030: 02 80 00 1a be 200e098 <msdos_format_fill_sectors+0x104>
200e034: 90 10 00 13 mov %l3, %o0
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
200e038: 92 10 00 1b mov %i3, %o1
200e03c: 7f ff d1 8e call 2002674 <.udiv>
200e040: 90 10 00 1d mov %i5, %o0
if (percent != last_percent) {
200e044: 80 a2 00 11 cmp %o0, %l1
200e048: 02 bf ff ee be 200e000 <msdos_format_fill_sectors+0x6c>
200e04c: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
200e050: 12 bf ff ec bne 200e000 <msdos_format_fill_sectors+0x6c>
200e054: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
200e058: 90 10 00 13 mov %l3, %o0
200e05c: 92 10 20 02 mov 2, %o1
200e060: 7f ff ff a0 call 200dee0 <msdos_format_printf>
200e064: 94 10 00 14 mov %l4, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
200e068: 92 10 00 1a mov %i2, %o1
200e06c: 90 10 00 19 mov %i1, %o0
200e070: 94 10 00 1c mov %i4, %o2
200e074: 96 10 00 12 mov %l2, %o3
200e078: 7f ff ff af call 200df34 <msdos_format_write_sec>
200e07c: a0 04 3f ff add %l0, -1, %l0
start_sector++;
200e080: b4 06 a0 01 inc %i2
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);
200e084: b0 10 00 08 mov %o0, %i0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
200e088: 80 a2 20 00 cmp %o0, 0
200e08c: 02 bf ff e8 be 200e02c <msdos_format_fill_sectors+0x98> <== ALWAYS TAKEN
200e090: ba 07 7f 9c add %i5, -100, %i5
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");
200e094: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
200e098: 92 10 20 02 mov 2, %o1
200e09c: 15 00 80 b1 sethi %hi(0x202c400), %o2
200e0a0: 7f ff ff 90 call 200dee0 <msdos_format_printf>
200e0a4: 94 12 a2 28 or %o2, 0x228, %o2 ! 202c628 <__clz_tab+0x478>
if (ret_val)
200e0a8: 80 a6 20 00 cmp %i0, 0
200e0ac: 12 80 00 16 bne 200e104 <msdos_format_fill_sectors+0x170> <== NEVER TAKEN
200e0b0: 90 10 00 13 mov %l3, %o0
/*
* cleanup
*/
if (fill_buffer != NULL) {
free(fill_buffer);
200e0b4: 7f ff dc ea call 200545c <free>
200e0b8: 90 10 00 12 mov %l2, %o0
200e0bc: 81 c7 e0 08 ret
200e0c0: 81 e8 00 00 restore
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
200e0c4: 40 00 3c 02 call 201d0cc <__errno> <== NOT EXECUTED
200e0c8: 01 00 00 00 nop <== NOT EXECUTED
200e0cc: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e0d0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
200e0d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e0d8: 15 00 80 b4 sethi %hi(0x202d000), %o2 <== NOT EXECUTED
200e0dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e0e0: 7f ff ff 80 call 200dee0 <msdos_format_printf> <== NOT EXECUTED
200e0e4: 94 12 a0 38 or %o2, 0x38, %o2 <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
200e0e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e0ec: 15 00 80 b1 sethi %hi(0x202c400), %o2 <== NOT EXECUTED
200e0f0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
ret_val = -1;
200e0f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
200e0f8: 7f ff ff 7a call 200dee0 <msdos_format_printf> <== NOT EXECUTED
200e0fc: 94 12 a2 28 or %o2, 0x228, %o2 <== NOT EXECUTED
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200e100: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
200e104: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
200e108: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
200e10c: 15 00 80 b4 sethi %hi(0x202d000), %o2 <== NOT EXECUTED
200e110: 7f ff ff 74 call 200dee0 <msdos_format_printf> <== NOT EXECUTED
200e114: 94 12 a0 48 or %o2, 0x48, %o2 ! 202d048 <_CPU_Trap_slot_template+0x20><== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
200e118: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
200e11c: 12 bf ff e6 bne 200e0b4 <msdos_format_fill_sectors+0x120> <== NOT EXECUTED
200e120: 01 00 00 00 nop <== NOT EXECUTED
free(fill_buffer);
fill_buffer = NULL;
}
return ret_val;
}
200e124: 81 c7 e0 08 ret <== NOT EXECUTED
200e128: 81 e8 00 00 restore <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
200e12c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e130: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
200e134: b0 10 20 00 clr %i0 <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
200e138: 15 00 80 b1 sethi %hi(0x202c400), %o2 <== NOT EXECUTED
200e13c: 7f ff ff 69 call 200dee0 <msdos_format_printf> <== NOT EXECUTED
200e140: 94 12 a2 28 or %o2, 0x228, %o2 ! 202c628 <__clz_tab+0x478><== NOT EXECUTED
200e144: 30 bf ff dc b,a 200e0b4 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
0200dee0 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
200dee0: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
200dee4: 94 07 a0 50 add %fp, 0x50, %o2
200dee8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
200deec: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
200def0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
200def4: 80 a6 20 00 cmp %i0, 0
200def8: 02 80 00 0d be 200df2c <msdos_format_printf+0x4c>
200defc: d4 27 bf fc st %o2, [ %fp + -4 ]
200df00: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200df04: 80 a0 40 19 cmp %g1, %i1
200df08: 06 80 00 09 bl 200df2c <msdos_format_printf+0x4c> <== ALWAYS TAKEN
200df0c: 3b 00 80 ba sethi %hi(0x202e800), %i5
{
vfprintf (stdout, format, args);
200df10: c2 07 62 e0 ld [ %i5 + 0x2e0 ], %g1 ! 202eae0 <_impure_ptr><== NOT EXECUTED
200df14: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
200df18: 40 00 5e f3 call 2025ae4 <vfprintf> <== NOT EXECUTED
200df1c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
200df20: c2 07 62 e0 ld [ %i5 + 0x2e0 ], %g1 <== NOT EXECUTED
200df24: 40 00 3d 6d call 201d4d8 <fflush> <== NOT EXECUTED
200df28: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
200df2c: 81 c7 e0 08 ret
200df30: 81 e8 00 00 restore
0200df34 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200df34: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
200df38: 94 10 20 00 clr %o2
200df3c: 96 10 00 1a mov %i2, %o3
200df40: 90 10 20 00 clr %o0
200df44: 7f ff d0 75 call 2002118 <__muldi3>
200df48: 92 10 00 19 mov %i1, %o1
200df4c: 84 10 00 08 mov %o0, %g2
200df50: 86 10 00 09 mov %o1, %g3
200df54: 90 10 00 18 mov %i0, %o0
200df58: 92 10 00 02 mov %g2, %o1
200df5c: 94 10 00 03 mov %g3, %o2
200df60: 40 00 1f 8c call 2015d90 <lseek>
200df64: 96 10 20 00 clr %o3
200df68: 80 a2 20 00 cmp %o0, 0
200df6c: 16 80 00 04 bge 200df7c <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
200df70: 90 10 00 18 mov %i0, %o0
200df74: 81 c7 e0 08 ret <== NOT EXECUTED
200df78: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
200df7c: 92 10 00 1b mov %i3, %o1
200df80: 7f ff ed 8c call 20095b0 <write>
200df84: 94 10 00 1a mov %i2, %o2
200df88: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
200df8c: 81 c7 e0 08 ret
200df90: 81 e8 00 00 restore
0201a658 <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
)
{
201a658: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
201a65c: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
201a660: c0 27 bf bc clr [ %fp + -68 ]
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
201a664: 90 10 00 1c mov %i4, %o0
201a668: 92 10 00 1a mov %i2, %o1
201a66c: 7f ff e2 70 call 201302c <fat_file_open>
201a670: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
201a674: ba 92 20 00 orcc %o0, 0, %i5
201a678: 02 80 00 04 be 201a688 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x30><== ALWAYS TAKEN
201a67c: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
201a680: 81 c7 e0 08 ret
201a684: 91 e8 00 1d restore %g0, %i5, %o0
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
201a688: 05 00 08 00 sethi %hi(0x200000), %g2
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
201a68c: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
201a690: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
201a694: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
201a698: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
201a69c: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
201a6a0: 7f ff e5 99 call 2013d04 <fat_file_size>
201a6a4: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
201a6a8: ba 92 20 00 orcc %o0, 0, %i5
201a6ac: 12 80 00 95 bne 201a900 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
201a6b0: 33 00 80 b3 sethi %hi(0x202cc00), %i1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
201a6b4: ba 07 bf c0 add %fp, -64, %i5
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
201a6b8: 94 10 00 1d mov %i5, %o2
201a6bc: 92 10 20 01 mov 1, %o1
201a6c0: 96 10 20 0b mov 0xb, %o3
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
201a6c4: c0 27 bf c0 clr [ %fp + -64 ]
201a6c8: c0 27 bf c4 clr [ %fp + -60 ]
201a6cc: c0 27 bf c8 clr [ %fp + -56 ]
201a6d0: c0 27 bf cc clr [ %fp + -52 ]
201a6d4: c0 27 bf d0 clr [ %fp + -48 ]
201a6d8: c0 27 bf d4 clr [ %fp + -44 ]
201a6dc: c0 27 bf d8 clr [ %fp + -40 ]
201a6e0: c0 27 bf dc clr [ %fp + -36 ]
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
201a6e4: 7f ff fa ff call 20192e0 <msdos_long_to_short>
201a6e8: 90 16 61 e0 or %i1, 0x1e0, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
201a6ec: d2 07 bf bc ld [ %fp + -68 ], %o1
201a6f0: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
201a6f4: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
201a6f8: 90 10 00 18 mov %i0, %o0
201a6fc: 94 10 20 00 clr %o2
201a700: 96 16 61 e0 or %i1, 0x1e0, %o3
201a704: 98 10 20 01 mov 1, %o4
201a708: 7f ff fc ee call 2019ac0 <msdos_find_name_in_fat_file>
201a70c: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
201a710: ba 92 20 00 orcc %o0, 0, %i5
201a714: 12 80 00 7b bne 201a900 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
201a718: 33 00 80 b5 sethi %hi(0x202d400), %i1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
201a71c: ba 07 bf e0 add %fp, -32, %i5
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
201a720: 94 10 00 1d mov %i5, %o2
201a724: 92 10 20 02 mov 2, %o1
201a728: 96 10 20 0b mov 0xb, %o3
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
201a72c: c0 27 bf e0 clr [ %fp + -32 ]
201a730: c0 27 bf e4 clr [ %fp + -28 ]
201a734: c0 27 bf e8 clr [ %fp + -24 ]
201a738: c0 27 bf ec clr [ %fp + -20 ]
201a73c: c0 27 bf f0 clr [ %fp + -16 ]
201a740: c0 27 bf f4 clr [ %fp + -12 ]
201a744: c0 27 bf f8 clr [ %fp + -8 ]
201a748: c0 27 bf fc clr [ %fp + -4 ]
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
201a74c: 7f ff fa e5 call 20192e0 <msdos_long_to_short>
201a750: 90 16 60 a8 or %i1, 0xa8, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
201a754: d2 07 bf bc ld [ %fp + -68 ], %o1
201a758: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
201a75c: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
201a760: 90 10 00 18 mov %i0, %o0
201a764: 94 10 20 00 clr %o2
201a768: 96 16 60 a8 or %i1, 0xa8, %o3
201a76c: 98 10 20 02 mov 2, %o4
201a770: 7f ff fc d4 call 2019ac0 <msdos_find_name_in_fat_file>
201a774: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
201a778: d2 07 bf bc ld [ %fp + -68 ], %o1
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
201a77c: 80 a2 20 00 cmp %o0, 0
201a780: 12 80 00 66 bne 201a918 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
201a784: ba 10 00 08 mov %o0, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
201a788: f2 17 bf da lduh [ %fp + -38 ], %i1
201a78c: e0 17 bf d4 lduh [ %fp + -44 ], %l0
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
201a790: 7f ff e3 a1 call 2013614 <fat_file_close>
201a794: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
201a798: ba 92 20 00 orcc %o0, 0, %i5
201a79c: 12 bf ff b9 bne 201a680 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
201a7a0: c4 17 bf fa lduh [ %fp + -6 ], %g2
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
201a7a4: c6 17 bf f4 lduh [ %fp + -12 ], %g3
201a7a8: 85 28 a0 10 sll %g2, 0x10, %g2
201a7ac: 87 28 e0 10 sll %g3, 0x10, %g3
201a7b0: 89 30 a0 18 srl %g2, 0x18, %g4
201a7b4: bb 30 e0 18 srl %g3, 0x18, %i5
201a7b8: 03 00 00 3f sethi %hi(0xfc00), %g1
201a7bc: 87 30 e0 08 srl %g3, 8, %g3
201a7c0: 82 10 63 ff or %g1, 0x3ff, %g1
201a7c4: 85 30 a0 08 srl %g2, 8, %g2
201a7c8: 86 08 c0 01 and %g3, %g1, %g3
201a7cc: 82 08 80 01 and %g2, %g1, %g1
201a7d0: 86 17 40 03 or %i5, %g3, %g3
201a7d4: 82 11 00 01 or %g4, %g1, %g1
201a7d8: 87 28 e0 10 sll %g3, 0x10, %g3
201a7dc: 80 90 c0 01 orcc %g3, %g1, %g0
201a7e0: 12 80 00 08 bne 201a800 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1a8><== ALWAYS TAKEN
201a7e4: 90 10 00 1c mov %i4, %o0
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
201a7e8: 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;
201a7ec: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
201a7f0: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
201a7f4: 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;
201a7f8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
201a7fc: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
201a800: 92 10 00 1a mov %i2, %o1
201a804: 7f ff e2 0a call 201302c <fat_file_open>
201a808: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
201a80c: ba 92 20 00 orcc %o0, 0, %i5
201a810: 12 bf ff 9c bne 201a680 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
201a814: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
201a818: c8 17 bf fa lduh [ %fp + -6 ], %g4
201a81c: 83 28 60 10 sll %g1, 0x10, %g1
201a820: 07 00 00 3f sethi %hi(0xfc00), %g3
201a824: 85 30 60 18 srl %g1, 0x18, %g2
201a828: 86 10 e3 ff or %g3, 0x3ff, %g3
201a82c: 83 30 60 08 srl %g1, 8, %g1
201a830: 82 08 40 03 and %g1, %g3, %g1
201a834: 89 29 20 10 sll %g4, 0x10, %g4
201a838: 84 10 80 01 or %g2, %g1, %g2
201a83c: bb 31 20 18 srl %g4, 0x18, %i5
201a840: 85 28 a0 10 sll %g2, 0x10, %g2
201a844: 89 31 20 08 srl %g4, 8, %g4
201a848: 86 09 00 03 and %g4, %g3, %g3
201a84c: 82 17 40 03 or %i5, %g3, %g1
201a850: 82 90 80 01 orcc %g2, %g1, %g1
201a854: 12 80 00 35 bne 201a928 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== ALWAYS TAKEN
201a858: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
201a85c: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 <== NOT EXECUTED
201a860: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
201a864: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
201a868: 05 00 08 00 sethi %hi(0x200000), %g2
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;
201a86c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
201a870: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
201a874: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
201a878: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
201a87c: 7f ff e5 22 call 2013d04 <fat_file_size>
201a880: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
201a884: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
201a888: 80 a2 20 00 cmp %o0, 0
201a88c: 12 80 00 23 bne 201a918 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
201a890: ba 10 00 08 mov %o0, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
201a894: a1 2c 20 10 sll %l0, 0x10, %l0
201a898: b3 2e 60 10 sll %i1, 0x10, %i1
201a89c: 95 34 20 18 srl %l0, 0x18, %o2
201a8a0: 85 36 60 18 srl %i1, 0x18, %g2
201a8a4: a1 34 20 08 srl %l0, 8, %l0
201a8a8: b3 36 60 08 srl %i1, 8, %i1
201a8ac: 03 00 00 3f sethi %hi(0xfc00), %g1
201a8b0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
201a8b4: a0 0c 00 01 and %l0, %g1, %l0
201a8b8: 82 0e 40 01 and %i1, %g1, %g1
201a8bc: 82 10 80 01 or %g2, %g1, %g1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
201a8c0: 90 10 00 18 mov %i0, %o0
201a8c4: 96 10 00 1a mov %i2, %o3
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
201a8c8: 94 12 80 10 or %o2, %l0, %o2
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
201a8cc: 98 10 00 1b mov %i3, %o4
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
201a8d0: 95 2a a0 10 sll %o2, 0x10, %o2
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
201a8d4: 7f ff fe fe call 201a4cc <msdos_find_node_by_cluster_num_in_fat_file>
201a8d8: 94 12 80 01 or %o2, %g1, %o2
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
201a8dc: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
201a8e0: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
201a8e4: 80 a7 60 00 cmp %i5, 0
201a8e8: 12 80 00 12 bne 201a930 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d8><== NEVER TAKEN
201a8ec: 90 10 00 1c mov %i4, %o0
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
201a8f0: 7f ff e3 49 call 2013614 <fat_file_close>
201a8f4: 01 00 00 00 nop
201a8f8: 10 bf ff 62 b 201a680 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28>
201a8fc: ba 10 00 08 mov %o0, %i5
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
201a900: d2 07 bf bc ld [ %fp + -68 ], %o1 <== NOT EXECUTED
201a904: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201a908: 7f ff e3 43 call 2013614 <fat_file_close> <== NOT EXECUTED
201a90c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
201a910: 81 c7 e0 08 ret <== NOT EXECUTED
201a914: 81 e8 00 00 restore <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
201a918: 7f ff e3 3f call 2013614 <fat_file_close> <== NOT EXECUTED
201a91c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
201a920: 81 c7 e0 08 ret <== NOT EXECUTED
201a924: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
201a928: 10 bf ff cf b 201a864 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c>
201a92c: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
201a930: 7f ff e3 39 call 2013614 <fat_file_close> <== NOT EXECUTED
201a934: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
201a938: 30 bf ff f6 b,a 201a910 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b8><== NOT EXECUTED
0201a93c <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
201a93c: 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,
201a940: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
201a944: 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
)
{
201a948: 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,
201a94c: 9a 10 00 1c mov %i4, %o5
201a950: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
201a954: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
201a958: 94 10 00 19 mov %i1, %o2
201a95c: 96 10 00 1a mov %i2, %o3
201a960: 7f ff fc 58 call 2019ac0 <msdos_find_name_in_fat_file>
201a964: 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))
201a968: 03 00 00 1f sethi %hi(0x7c00), %g1
201a96c: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
201a970: 80 a2 00 01 cmp %o0, %g1
201a974: 12 80 00 2a bne 201aa1c <msdos_get_name_node+0xe0>
201a978: b8 10 00 08 mov %o0, %i4
return rc;
if (!create_node)
201a97c: 80 a6 60 00 cmp %i1, 0
201a980: 12 80 00 25 bne 201aa14 <msdos_get_name_node+0xd8>
201a984: 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)
201a988: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
201a98c: 80 a7 00 01 cmp %i4, %g1
201a990: 02 80 00 21 be 201aa14 <msdos_get_name_node+0xd8>
201a994: 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)
201a998: 12 80 00 1f bne 201aa14 <msdos_get_name_node+0xd8> <== NEVER TAKEN
201a99c: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
201a9a0: 94 10 20 02 mov 2, %o2
201a9a4: 13 00 80 b5 sethi %hi(0x202d400), %o1
201a9a8: 40 00 12 e3 call 201f534 <strncmp>
201a9ac: 92 12 60 a8 or %o1, 0xa8, %o1 ! 202d4a8 <IMFS_memfile_handlers+0x84>
201a9b0: 80 a2 20 00 cmp %o0, 0
201a9b4: 12 80 00 18 bne 201aa14 <msdos_get_name_node+0xd8>
201a9b8: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
201a9bc: c2 14 20 14 lduh [ %l0 + 0x14 ], %g1
201a9c0: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
201a9c4: 83 28 60 10 sll %g1, 0x10, %g1
201a9c8: b3 30 60 18 srl %g1, 0x18, %i1
201a9cc: 84 10 a3 ff or %g2, 0x3ff, %g2
201a9d0: 83 30 60 08 srl %g1, 8, %g1
201a9d4: 82 08 40 02 and %g1, %g2, %g1
201a9d8: 87 28 e0 10 sll %g3, 0x10, %g3
201a9dc: b2 16 40 01 or %i1, %g1, %i1
201a9e0: 89 30 e0 18 srl %g3, 0x18, %g4
201a9e4: b3 2e 60 10 sll %i1, 0x10, %i1
201a9e8: 87 30 e0 08 srl %g3, 8, %g3
201a9ec: 84 08 c0 02 and %g3, %g2, %g2
201a9f0: 82 11 00 02 or %g4, %g2, %g1
/* are we right under root dir ? */
if (dotdot_cln == 0)
201a9f4: b2 96 40 01 orcc %i1, %g1, %i1
201a9f8: 12 80 00 0e bne 201aa30 <msdos_get_name_node+0xf4>
201a9fc: 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;
201aa00: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
201aa04: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
201aa08: 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;
201aa0c: 82 10 20 01 mov 1, %g1
201aa10: c2 27 40 00 st %g1, [ %i5 ]
}
}
}
}
return rc;
}
201aa14: 81 c7 e0 08 ret
201aa18: 91 e8 00 1c restore %g0, %i4, %o0
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
201aa1c: 80 a2 20 00 cmp %o0, 0
201aa20: 02 bf ff d8 be 201a980 <msdos_get_name_node+0x44>
201aa24: 80 a6 60 00 cmp %i1, 0
}
}
}
}
return rc;
}
201aa28: 81 c7 e0 08 ret
201aa2c: 91 e8 00 1c restore %g0, %i4, %o0
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
201aa30: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
201aa34: b4 10 00 1d mov %i5, %i2
201aa38: 7f ff ff 08 call 201a658 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
201aa3c: 97 e8 00 10 restore %g0, %l0, %o3
0200f368 <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
)
{
200f368: 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));
200f36c: 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;
200f370: c0 27 bf ec clr [ %fp + -20 ]
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
200f374: 7f ff d7 69 call 2005118 <calloc>
200f378: 92 10 20 a4 mov 0xa4, %o1
if (!fs_info)
200f37c: ba 92 20 00 orcc %o0, 0, %i5
200f380: 02 80 00 58 be 200f4e0 <msdos_initialize_support+0x178> <== NEVER TAKEN
200f384: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
200f388: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
200f38c: 40 00 14 42 call 2014494 <fat_init_volume_info>
200f390: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
200f394: b8 92 20 00 orcc %o0, 0, %i4
200f398: 12 80 00 34 bne 200f468 <msdos_initialize_support+0x100> <== NEVER TAKEN
200f39c: 82 10 3f ff mov -1, %g1
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
200f3a0: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
200f3a4: c2 27 bf fc st %g1, [ %fp + -4 ]
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
200f3a8: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
200f3ac: f4 27 60 98 st %i2, [ %i5 + 0x98 ]
fs_info->directory_handlers = directory_handlers;
200f3b0: f6 27 60 94 st %i3, [ %i5 + 0x94 ]
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
200f3b4: c0 27 bf f4 clr [ %fp + -12 ]
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
200f3b8: 90 10 00 1d mov %i5, %o0
/*
* 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;
200f3bc: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
200f3c0: 92 07 bf f0 add %fp, -16, %o1
200f3c4: 40 00 0f 1a call 201302c <fat_file_open>
200f3c8: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
200f3cc: b8 92 20 00 orcc %o0, 0, %i4
200f3d0: 12 80 00 24 bne 200f460 <msdos_initialize_support+0xf8> <== NEVER TAKEN
200f3d4: d2 07 bf ec ld [ %fp + -20 ], %o1
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
200f3d8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
200f3dc: 05 00 08 00 sethi %hi(0x200000), %g2
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
200f3e0: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
200f3e4: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
200f3e8: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
200f3ec: 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 )
200f3f0: 80 a0 60 00 cmp %g1, 0
200f3f4: 12 80 00 24 bne 200f484 <msdos_initialize_support+0x11c>
200f3f8: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
200f3fc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
200f400: d0 17 60 06 lduh [ %i5 + 6 ], %o0
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
200f404: 80 a2 00 01 cmp %o0, %g1
200f408: 0a 80 00 1d bcs 200f47c <msdos_initialize_support+0x114>
200f40c: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
200f410: 7f ff d7 42 call 2005118 <calloc>
200f414: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
200f418: 80 a2 20 00 cmp %o0, 0
200f41c: 02 80 00 2a be 200f4c4 <msdos_initialize_support+0x15c> <== NEVER TAKEN
200f420: d0 27 60 a0 st %o0, [ %i5 + 0xa0 ]
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
sc = rtems_semaphore_create(3,
200f424: 90 10 20 03 mov 3, %o0
200f428: 92 10 20 01 mov 1, %o1
200f42c: 94 10 20 10 mov 0x10, %o2
200f430: 96 10 20 00 clr %o3
200f434: 7f ff e9 a7 call 2009ad0 <rtems_semaphore_create>
200f438: 98 07 60 9c add %i5, 0x9c, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
200f43c: 80 a2 20 00 cmp %o0, 0
200f440: 12 80 00 2d bne 200f4f4 <msdos_initialize_support+0x18c> <== NEVER TAKEN
200f444: c4 07 bf ec ld [ %fp + -20 ], %g2
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
200f448: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
200f44c: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
200f450: c4 20 60 08 st %g2, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
200f454: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
200f458: 81 c7 e0 08 ret
200f45c: 91 e8 00 1c restore %g0, %i4, %o0
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
if (rc != RC_OK)
{
fat_shutdown_drive(&fs_info->fat);
200f460: 40 00 16 5c call 2014dd0 <fat_shutdown_drive> <== NOT EXECUTED
200f464: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200f468: 7f ff d7 fd call 200545c <free> <== NOT EXECUTED
200f46c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
200f470: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
200f474: 81 c7 e0 08 ret <== NOT EXECUTED
200f478: 81 e8 00 00 restore <== NOT EXECUTED
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
200f47c: 10 bf ff e5 b 200f410 <msdos_initialize_support+0xa8>
200f480: 90 10 00 01 mov %g1, %o0
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(&fs_info->fat, fat_fd);
200f484: 40 00 12 20 call 2013d04 <fat_file_size>
200f488: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
200f48c: 82 92 20 00 orcc %o0, 0, %g1
200f490: 12 80 00 04 bne 200f4a0 <msdos_initialize_support+0x138> <== NEVER TAKEN
200f494: d2 07 bf ec ld [ %fp + -20 ], %o1
fat_file_close(&fs_info->fat, fat_fd);
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
200f498: 10 bf ff de b 200f410 <msdos_initialize_support+0xa8>
200f49c: d0 17 60 06 lduh [ %i5 + 6 ], %o0
rc = fat_file_size(&fs_info->fat, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(&fs_info->fat, fat_fd);
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
200f4a0: b8 10 00 01 mov %g1, %i4 <== NOT EXECUTED
else
{
rc = fat_file_size(&fs_info->fat, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(&fs_info->fat, fat_fd);
200f4a4: 40 00 10 5c call 2013614 <fat_file_close> <== NOT EXECUTED
200f4a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200f4ac: 40 00 16 49 call 2014dd0 <fat_shutdown_drive> <== NOT EXECUTED
200f4b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200f4b4: 7f ff d7 ea call 200545c <free> <== NOT EXECUTED
200f4b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
200f4bc: 81 c7 e0 08 ret <== NOT EXECUTED
200f4c0: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
if (fs_info->cl_buf == NULL)
{
fat_file_close(&fs_info->fat, fat_fd);
200f4c4: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
200f4c8: 40 00 10 53 call 2013614 <fat_file_close> <== NOT EXECUTED
200f4cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200f4d0: 40 00 16 40 call 2014dd0 <fat_shutdown_drive> <== NOT EXECUTED
200f4d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200f4d8: 7f ff d7 e1 call 200545c <free> <== NOT EXECUTED
200f4dc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
200f4e0: 40 00 36 fb call 201d0cc <__errno> <== NOT EXECUTED
200f4e4: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
200f4e8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
200f4ec: 10 bf ff e1 b 200f470 <msdos_initialize_support+0x108> <== NOT EXECUTED
200f4f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(&fs_info->fat, fat_fd);
200f4f4: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
200f4f8: 40 00 10 47 call 2013614 <fat_file_close> <== NOT EXECUTED
200f4fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200f500: 40 00 16 34 call 2014dd0 <fat_shutdown_drive> <== NOT EXECUTED
200f504: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
200f508: d0 07 60 a0 ld [ %i5 + 0xa0 ], %o0 <== NOT EXECUTED
200f50c: 7f ff d7 d4 call 200545c <free> <== NOT EXECUTED
200f510: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
free(fs_info);
200f514: 7f ff d7 d2 call 200545c <free> <== NOT EXECUTED
200f518: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
200f51c: 40 00 36 ec call 201d0cc <__errno> <== NOT EXECUTED
200f520: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
200f524: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
200f528: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200f52c: 81 c7 e0 08 ret <== NOT EXECUTED
200f530: 81 e8 00 00 restore <== NOT EXECUTED
0200f330 <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
200f330: 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,
200f334: c2 06 20 08 ld [ %i0 + 8 ], %g1
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
msdos_fs_info_t *fs_info = mt_entry->fs_info;
rtems_status_code sc = rtems_semaphore_obtain(
200f338: 92 10 20 00 clr %o1
200f33c: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
200f340: 7f ff ea 8c call 2009d70 <rtems_semaphore_obtain>
200f344: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
200f348: 80 a2 20 00 cmp %o0, 0
200f34c: 12 80 00 04 bne 200f35c <msdos_lock+0x2c> <== NEVER TAKEN
200f350: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
200f354: 81 c7 e0 08 ret
200f358: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
200f35c: 7f ff ec 78 call 200a53c <rtems_fatal_error_occurred> <== NOT EXECUTED
200f360: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
020192e0 <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)
{
20192e0: 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);
20192e4: 92 10 20 20 mov 0x20, %o1
20192e8: 90 10 00 1a mov %i2, %o0
20192ec: 40 00 12 74 call 201dcbc <memset>
20192f0: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
20192f4: f8 0e 00 00 ldub [ %i0 ], %i4
20192f8: 85 2f 20 18 sll %i4, 0x18, %g2
20192fc: 83 38 a0 18 sra %g2, 0x18, %g1
2019300: 80 a0 60 2e cmp %g1, 0x2e
2019304: 02 80 00 17 be 2019360 <msdos_long_to_short+0x80>
2019308: a0 10 00 18 mov %i0, %l0
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
201930c: 80 a6 60 00 cmp %i1, 0
2019310: 04 80 00 70 ble 20194d0 <msdos_long_to_short+0x1f0> <== NEVER TAKEN
2019314: 83 38 a0 18 sra %g2, 0x18, %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
2019318: 80 a0 60 2e cmp %g1, 0x2e
201931c: 12 80 00 1f bne 2019398 <msdos_long_to_short+0xb8> <== ALWAYS TAKEN
2019320: 80 a0 60 20 cmp %g1, 0x20
2019324: 10 80 00 05 b 2019338 <msdos_long_to_short+0x58> <== NOT EXECUTED
2019328: 82 10 20 00 clr %g1 <== NOT EXECUTED
201932c: 80 a0 e0 2e cmp %g3, 0x2e
2019330: 12 80 00 08 bne 2019350 <msdos_long_to_short+0x70> <== ALWAYS TAKEN
2019334: 80 a0 e0 20 cmp %g3, 0x20
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
2019338: 82 00 60 01 inc %g1
201933c: 80 a0 40 19 cmp %g1, %i1
2019340: 32 bf ff fb bne,a 201932c <msdos_long_to_short+0x4c> <== ALWAYS TAKEN
2019344: c6 4c 00 01 ldsb [ %l0 + %g1 ], %g3
if (type == MSDOS_NAME_INVALID)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
2019348: 81 c7 e0 08 ret <== NOT EXECUTED
201934c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
2019350: 02 bf ff fb be 201933c <msdos_long_to_short+0x5c> <== NEVER TAKEN
2019354: 82 00 60 01 inc %g1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
2019358: 10 80 00 13 b 20193a4 <msdos_long_to_short+0xc4>
201935c: 80 a0 a0 00 cmp %g2, 0
memset (sfn, ' ', sfn_len);
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
2019360: 80 a6 60 01 cmp %i1, 1
2019364: 22 80 00 0b be,a 2019390 <msdos_long_to_short+0xb0>
2019368: c2 2e 80 00 stb %g1, [ %i2 ]
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
201936c: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
2019370: 80 a0 60 2e cmp %g1, 0x2e
2019374: 12 bf ff e7 bne 2019310 <msdos_long_to_short+0x30> <== NEVER TAKEN
2019378: 80 a6 60 00 cmp %i1, 0
201937c: 80 a6 60 02 cmp %i1, 2
2019380: 12 bf ff e4 bne 2019310 <msdos_long_to_short+0x30> <== NEVER TAKEN
2019384: 80 a6 60 00 cmp %i1, 0
{
sfn[0] = sfn[1] = '.';
2019388: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
201938c: c2 2e 80 00 stb %g1, [ %i2 ]
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
2019390: 81 c7 e0 08 ret
2019394: 91 e8 20 01 restore %g0, 1, %o0
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
2019398: 02 bf ff e8 be 2019338 <msdos_long_to_short+0x58>
201939c: 82 10 20 00 clr %g1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
20193a0: 80 a0 a0 00 cmp %g2, 0
20193a4: 02 80 00 44 be 20194b4 <msdos_long_to_short+0x1d4> <== NEVER TAKEN
20193a8: 03 00 80 ba sethi %hi(0x202e800), %g1
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
20193ac: e8 00 62 d8 ld [ %g1 + 0x2d8 ], %l4 ! 202ead8 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
20193b0: 31 00 80 b5 sethi %hi(0x202d400), %i0
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
20193b4: 2b 00 80 b5 sethi %hi(0x202d400), %l5
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
20193b8: a4 10 20 00 clr %l2
20193bc: a6 10 20 00 clr %l3
20193c0: ba 10 20 00 clr %i5
20193c4: a2 10 3f ff mov -1, %l1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
20193c8: b0 16 22 d8 or %i0, 0x2d8, %i0
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
20193cc: aa 15 62 e0 or %l5, 0x2e0, %l5
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
20193d0: b7 38 a0 18 sra %g2, 0x18, %i3
20193d4: 90 10 00 18 mov %i0, %o0
20193d8: 40 00 15 fc call 201ebc8 <strchr>
20193dc: 92 10 00 1b mov %i3, %o1
20193e0: 80 a2 20 00 cmp %o0, 0
20193e4: 02 80 00 09 be 2019408 <msdos_long_to_short+0x128>
20193e8: 82 1e e0 2e xor %i3, 0x2e, %g1
return MSDOS_NAME_LONG;
20193ec: b0 10 20 02 mov 2, %i0
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
20193f0: 90 10 00 10 mov %l0, %o0
20193f4: 92 10 00 19 mov %i1, %o1
20193f8: 40 00 0b c9 call 201c31c <msdos_filename_unix2dos>
20193fc: 94 10 00 1a mov %i2, %o2
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
2019400: 81 c7 e0 08 ret
2019404: 81 e8 00 00 restore
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2019408: 80 a0 00 01 cmp %g0, %g1
201940c: ac 60 3f ff subx %g0, -1, %l6
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2019410: 80 a5 a0 00 cmp %l6, 0
2019414: 12 80 00 3c bne 2019504 <msdos_long_to_short+0x224>
2019418: 82 0f 20 ff and %i4, 0xff, %g1
201941c: 82 05 00 01 add %l4, %g1, %g1
2019420: c2 08 60 01 ldub [ %g1 + 1 ], %g1
2019424: 80 88 60 07 btst 7, %g1
2019428: 12 80 00 07 bne 2019444 <msdos_long_to_short+0x164>
201942c: 90 10 00 15 mov %l5, %o0
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2019430: 40 00 15 e6 call 201ebc8 <strchr>
2019434: 92 10 00 1b mov %i3, %o1
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2019438: 80 a2 20 00 cmp %o0, 0
201943c: 02 bf ff c3 be 2019348 <msdos_long_to_short+0x68> <== NEVER TAKEN
2019440: 01 00 00 00 nop
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
2019444: 80 a4 7f ff cmp %l1, -1
2019448: 02 80 00 27 be 20194e4 <msdos_long_to_short+0x204>
201944c: 82 27 40 11 sub %i5, %l1, %g1
{
if (is_dot || ((count - dot_at) > 3))
2019450: 80 a0 60 03 cmp %g1, 3
2019454: 34 bf ff e7 bg,a 20193f0 <msdos_long_to_short+0x110> <== NEVER TAKEN
2019458: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
201945c: 82 07 3f bf add %i4, -65, %g1
2019460: 82 08 60 ff and %g1, 0xff, %g1
2019464: 80 a0 60 19 cmp %g1, 0x19
2019468: 28 80 00 07 bleu,a 2019484 <msdos_long_to_short+0x1a4>
201946c: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
2019470: b8 07 3f 9f add %i4, -97, %i4
2019474: b8 0f 20 ff and %i4, 0xff, %i4
2019478: 80 a7 20 19 cmp %i4, 0x19
201947c: 28 80 00 02 bleu,a 2019484 <msdos_long_to_short+0x1a4>
2019480: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
2019484: ba 07 60 01 inc %i5
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
2019488: f8 0c 00 1d ldub [ %l0 + %i5 ], %i4
201948c: 85 2f 20 18 sll %i4, 0x18, %g2
2019490: 80 a0 a0 00 cmp %g2, 0
2019494: 02 80 00 04 be 20194a4 <msdos_long_to_short+0x1c4>
2019498: 80 a6 40 1d cmp %i1, %i5
201949c: 34 bf ff ce bg,a 20193d4 <msdos_long_to_short+0xf4>
20194a0: b7 38 a0 18 sra %g2, 0x18, %i3
20194a4: a4 0c c0 12 and %l3, %l2, %l2
count++;
name++;
}
if (lowercase && uppercase)
20194a8: 80 8c a0 ff btst 0xff, %l2
20194ac: 12 bf ff d1 bne 20193f0 <msdos_long_to_short+0x110> <== NEVER TAKEN
20194b0: b0 10 20 02 mov 2, %i0
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
20194b4: b0 10 20 01 mov 1, %i0
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
20194b8: 90 10 00 10 mov %l0, %o0
20194bc: 92 10 00 19 mov %i1, %o1
20194c0: 40 00 0b 97 call 201c31c <msdos_filename_unix2dos>
20194c4: 94 10 00 1a mov %i2, %o2
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
20194c8: 81 c7 e0 08 ret
20194cc: 81 e8 00 00 restore
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
20194d0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
20194d4: 12 bf ff f8 bne 20194b4 <msdos_long_to_short+0x1d4> <== NOT EXECUTED
20194d8: b0 10 20 00 clr %i0 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
20194dc: 81 c7 e0 08 ret <== NOT EXECUTED
20194e0: 81 e8 00 00 restore <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
20194e4: 80 a5 a0 00 cmp %l6, 0
20194e8: 12 bf ff de bne 2019460 <msdos_long_to_short+0x180> <== NEVER TAKEN
20194ec: 82 07 3f bf add %i4, -65, %g1
20194f0: 80 a7 60 08 cmp %i5, 8
20194f4: 12 bf ff dc bne 2019464 <msdos_long_to_short+0x184>
20194f8: 82 08 60 ff and %g1, 0xff, %g1
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
20194fc: 10 bf ff bd b 20193f0 <msdos_long_to_short+0x110>
2019500: b0 10 20 02 mov 2, %i0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
2019504: 80 a4 7f ff cmp %l1, -1
2019508: 32 bf ff ba bne,a 20193f0 <msdos_long_to_short+0x110>
201950c: b0 10 20 02 mov 2, %i0
2019510: 10 bf ff dd b 2019484 <msdos_long_to_short+0x1a4>
2019514: a2 10 00 1d mov %i5, %l1
0200f534 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200f534: 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))
200f538: 03 00 00 3c sethi %hi(0xf000), %g1
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200f53c: b8 10 00 1b mov %i3, %i4
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
200f540: 82 0e c0 01 and %i3, %g1, %g1
200f544: 05 00 00 10 sethi %hi(0x4000), %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200f548: 86 10 00 19 mov %i1, %g3
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
200f54c: 80 a0 40 02 cmp %g1, %g2
200f550: 02 80 00 09 be 200f574 <msdos_mknod+0x40>
200f554: b6 10 00 1a mov %i2, %i3
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
200f558: 05 00 00 20 sethi %hi(0x8000), %g2
200f55c: 80 a0 40 02 cmp %g1, %g2
200f560: 12 80 00 09 bne 200f584 <msdos_mknod+0x50> <== NEVER TAKEN
200f564: b2 10 20 04 mov 4, %i1
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
200f568: b4 10 00 03 mov %g3, %i2
200f56c: 40 00 25 fc call 2018d5c <msdos_creat_node>
200f570: 9b e8 20 00 restore %g0, 0, %o5
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
200f574: 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);
200f578: b4 10 00 03 mov %g3, %i2
200f57c: 40 00 25 f8 call 2018d5c <msdos_creat_node>
200f580: 9b e8 20 00 restore %g0, 0, %o5
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
200f584: 40 00 36 d2 call 201d0cc <__errno> <== NOT EXECUTED
200f588: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200f58c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200f590: 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;
}
200f594: 81 c7 e0 08 ret <== NOT EXECUTED
200f598: 81 e8 00 00 restore <== NOT EXECUTED
0200f5a8 <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
)
{
200f5a8: 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;
200f5ac: 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,
200f5b0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
200f5b4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
200f5b8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
200f5bc: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
200f5c0: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
200f5c4: 40 00 25 e6 call 2018d5c <msdos_creat_node> <== NOT EXECUTED
200f5c8: 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)
200f5cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200f5d0: 02 80 00 04 be 200f5e0 <msdos_rename+0x38> <== NOT EXECUTED
200f5d4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
200f5d8: 81 c7 e0 08 ret <== NOT EXECUTED
200f5dc: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
200f5e0: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
200f5e4: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
200f5e8: 40 00 28 75 call 20197bc <msdos_set_first_char4file_name> <== NOT EXECUTED
200f5ec: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
0200f5f0 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
200f5f0: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
200f5f4: fa 06 60 08 ld [ %i1 + 8 ], %i5
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
200f5f8: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
fat_file_fd_t *fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
200f5fc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200f600: 80 a0 60 00 cmp %g1, 0
200f604: 12 80 00 16 bne 200f65c <msdos_rmnod+0x6c>
200f608: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
200f60c: 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);
200f610: 92 10 00 1d mov %i5, %o1
200f614: 40 00 28 d6 call 201996c <msdos_dir_is_empty>
200f618: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
200f61c: b0 92 20 00 orcc %o0, 0, %i0
200f620: 12 80 00 0d bne 200f654 <msdos_rmnod+0x64> <== NEVER TAKEN
200f624: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
200f628: 80 a0 60 00 cmp %g1, 0
200f62c: 02 80 00 16 be 200f684 <msdos_rmnod+0x94>
200f630: 01 00 00 00 nop
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
200f634: c2 07 60 08 ld [ %i5 + 8 ], %g1
200f638: 80 a0 60 01 cmp %g1, 1
200f63c: 28 80 00 08 bleu,a 200f65c <msdos_rmnod+0x6c> <== ALWAYS TAKEN
200f640: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
200f644: 40 00 36 a2 call 201d0cc <__errno> <== NOT EXECUTED
200f648: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200f64c: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
200f650: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200f654: 81 c7 e0 08 ret <== NOT EXECUTED
200f658: 81 e8 00 00 restore <== NOT EXECUTED
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
200f65c: 92 07 60 20 add %i5, 0x20, %o1
200f660: 40 00 28 57 call 20197bc <msdos_set_first_char4file_name>
200f664: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
200f668: b0 92 20 00 orcc %o0, 0, %i0
200f66c: 12 bf ff fa bne 200f654 <msdos_rmnod+0x64> <== NEVER TAKEN
200f670: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
200f674: 40 00 11 79 call 2013c58 <fat_file_mark_removed>
200f678: 92 10 00 1d mov %i5, %o1
return rc;
}
200f67c: 81 c7 e0 08 ret
200f680: 81 e8 00 00 restore
return rc;
}
if (!is_empty)
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
200f684: 40 00 36 92 call 201d0cc <__errno>
200f688: b0 10 3f ff mov -1, %i0
200f68c: 82 10 20 5a mov 0x5a, %g1
200f690: c2 22 00 00 st %g1, [ %o0 ]
200f694: 81 c7 e0 08 ret
200f698: 81 e8 00 00 restore
02019518 <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
)
{
2019518: 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);
201951c: 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;
2019520: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
2019524: 92 07 bf fe add %fp, -2, %o1
2019528: 40 00 0a d1 call 201c06c <msdos_date_unix2dos>
201952c: 94 07 bf fc add %fp, -4, %o2
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
2019530: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2019534: 80 a0 60 00 cmp %g1, 0
2019538: 32 80 00 07 bne,a 2019554 <msdos_set_dir_wrt_time_and_date+0x3c>
201953c: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
2019540: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
2019544: 80 88 a0 03 btst 3, %g2
2019548: 32 80 00 07 bne,a 2019564 <msdos_set_dir_wrt_time_and_date+0x4c><== ALWAYS TAKEN
201954c: f6 07 60 20 ld [ %i5 + 0x20 ], %i3
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2019550: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
2019554: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
2019558: b6 00 7f fe add %g1, -2, %i3
201955c: b7 2e c0 03 sll %i3, %g3, %i3
2019560: b6 06 c0 02 add %i3, %g2, %i3
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019564: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2019568: f8 17 40 00 lduh [ %i5 ], %i4
time_val = CT_LE_W(time_val);
201956c: c2 17 bf fc lduh [ %fp + -4 ], %g1
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019570: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
/* 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);
2019574: 83 28 60 10 sll %g1, 0x10, %g1
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019578: 87 30 80 03 srl %g2, %g3, %g3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
201957c: b8 07 3f ff add %i4, -1, %i4
2019580: b8 0f 00 02 and %i4, %g2, %i4
time_val = CT_LE_W(time_val);
2019584: 85 30 60 08 srl %g1, 8, %g2
2019588: 83 30 60 18 srl %g1, 0x18, %g1
201958c: 82 10 80 01 or %g2, %g1, %g1
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019590: b6 06 c0 03 add %i3, %g3, %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2019594: 94 07 20 16 add %i4, 0x16, %o2
2019598: 92 10 00 1b mov %i3, %o1
201959c: 96 10 20 02 mov 2, %o3
20195a0: 98 07 bf fc add %fp, -4, %o4
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
20195a4: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
20195a8: 7f ff ea cd call 20140dc <fat_sector_write>
20195ac: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
20195b0: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
20195b4: 94 07 20 18 add %i4, 0x18, %o2
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
20195b8: 83 28 60 10 sll %g1, 0x10, %g1
20195bc: 85 30 60 08 srl %g1, 8, %g2
20195c0: 83 30 60 18 srl %g1, 0x18, %g1
20195c4: 82 10 80 01 or %g2, %g1, %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
20195c8: 96 10 20 02 mov 2, %o3
20195cc: 98 07 bf fe add %fp, -2, %o4
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
20195d0: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
20195d4: 92 10 00 1b mov %i3, %o1
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_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
20195d8: b2 10 00 08 mov %o0, %i1
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
20195dc: 7f ff ea c0 call 20140dc <fat_sector_write>
20195e0: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
20195e4: 92 10 00 1b mov %i3, %o1
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
20195e8: b4 10 00 08 mov %o0, %i2
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
20195ec: 94 07 20 12 add %i4, 0x12, %o2
20195f0: 90 10 00 1d mov %i5, %o0
20195f4: 96 10 20 02 mov 2, %o3
20195f8: 7f ff ea b9 call 20140dc <fat_sector_write>
20195fc: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
2019600: 80 a6 a0 00 cmp %i2, 0
2019604: 06 80 00 08 bl 2019624 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
2019608: 80 a6 60 00 cmp %i1, 0
201960c: 06 80 00 06 bl 2019624 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
2019610: 80 a2 20 00 cmp %o0, 0
2019614: 06 80 00 04 bl 2019624 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
2019618: 01 00 00 00 nop
return -1;
return RC_OK;
}
201961c: 81 c7 e0 08 ret
2019620: 91 e8 20 00 restore %g0, 0, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
return -1;
2019624: 81 c7 e0 08 ret <== NOT EXECUTED
2019628: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02019718 <msdos_set_file_size>:
int
msdos_set_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
2019718: 9d e3 bf 98 save %sp, -104, %sp
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
201971c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2019720: 80 a0 60 00 cmp %g1, 0
2019724: 12 80 00 06 bne 201973c <msdos_set_file_size+0x24>
2019728: d0 06 20 08 ld [ %i0 + 8 ], %o0
201972c: c4 0a 20 0e ldub [ %o0 + 0xe ], %g2
2019730: 80 88 a0 03 btst 3, %g2
2019734: 32 80 00 07 bne,a 2019750 <msdos_set_file_size+0x38> <== ALWAYS TAKEN
2019738: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
201973c: c6 0a 20 05 ldub [ %o0 + 5 ], %g3
2019740: c4 02 20 34 ld [ %o0 + 0x34 ], %g2
2019744: 92 00 7f fe add %g1, -2, %o1
2019748: 93 2a 40 03 sll %o1, %g3, %o1
201974c: 92 02 40 02 add %o1, %g2, %o1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2019750: c6 12 00 00 lduh [ %o0 ], %g3
le_new_length = CT_LE_L((fat_fd->fat_file_size));
2019754: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019758: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
201975c: c8 0a 20 02 ldub [ %o0 + 2 ], %g4
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2019760: 86 00 ff ff add %g3, -1, %g3
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019764: 89 30 80 04 srl %g2, %g4, %g4
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2019768: 94 08 c0 02 and %g3, %g2, %o2
201976c: b9 28 60 18 sll %g1, 0x18, %i4
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
2019770: 87 30 60 18 srl %g1, 0x18, %g3
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
2019774: bb 30 60 08 srl %g1, 8, %i5
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2019778: 86 17 00 03 or %i4, %g3, %g3
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
201977c: ba 0f 60 ff and %i5, 0xff, %i5
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2019780: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
2019784: bb 2f 60 10 sll %i5, 0x10, %i5
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
2019788: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
201978c: 86 10 c0 1d or %g3, %i5, %g3
2019790: 83 28 60 08 sll %g1, 8, %g1
2019794: 86 10 c0 01 or %g3, %g1, %g3
le_new_length = CT_LE_L((fat_fd->fat_file_size));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
2019798: 92 02 40 04 add %o1, %g4, %o1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
le_new_length = CT_LE_L((fat_fd->fat_file_size));
201979c: c6 27 bf fc st %g3, [ %fp + -4 ]
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
20197a0: 94 02 a0 1c add %o2, 0x1c, %o2
20197a4: 96 10 20 04 mov 4, %o3
20197a8: 7f ff ea 4d call 20140dc <fat_sector_write>
20197ac: 98 07 bf fc add %fp, -4, %o4
(char *)(&le_new_length));
if ( ret < 0 )
return -1;
return RC_OK;
}
20197b0: b1 3a 20 1f sra %o0, 0x1f, %i0
20197b4: 81 c7 e0 08 ret
20197b8: 81 e8 00 00 restore
020197bc <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
)
{
20197bc: 9d e3 bf 90 save %sp, -112, %sp
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
20197c0: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
20197c4: f8 06 40 00 ld [ %i1 ], %i4
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
20197c8: c8 06 60 08 ld [ %i1 + 8 ], %g4
20197cc: c6 06 60 0c ld [ %i1 + 0xc ], %g3
fat_pos_t end = dir_pos->sname;
20197d0: c2 06 60 04 ld [ %i1 + 4 ], %g1
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
20197d4: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
20197d8: f4 2f a0 4c stb %i2, [ %fp + 0x4c ]
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
20197dc: c8 27 bf f0 st %g4, [ %fp + -16 ]
20197e0: c6 27 bf f4 st %g3, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
20197e4: f8 27 bf f8 st %i4, [ %fp + -8 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
20197e8: 80 a7 00 02 cmp %i4, %g2
20197ec: 02 80 00 56 be 2019944 <msdos_set_first_char4file_name+0x188><== ALWAYS TAKEN
20197f0: c2 27 bf fc st %g1, [ %fp + -4 ]
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
20197f4: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
20197f8: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
20197fc: 02 80 00 59 be 2019960 <msdos_set_first_char4file_name+0x1a4><== NOT EXECUTED
2019800: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
2019804: c2 07 bf f4 ld [ %fp + -12 ], %g1
2019808: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
201980c: d4 17 40 00 lduh [ %i5 ], %o2
2019810: 10 80 00 1d b 2019884 <msdos_set_first_char4file_name+0xc8>
2019814: d2 07 bf f0 ld [ %fp + -16 ], %o1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2019818: 80 88 e0 03 btst 3, %g3
201981c: 22 80 00 1e be,a 2019894 <msdos_set_first_char4file_name+0xd8><== NEVER TAKEN
2019820: c8 0f 60 05 ldub [ %i5 + 5 ], %g4 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2019824: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
2019828: 85 30 40 02 srl %g1, %g2, %g2
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
201982c: 95 2a a0 10 sll %o2, 0x10, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
2019830: 90 10 00 1d mov %i5, %o0
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
2019834: 95 32 a0 10 srl %o2, 0x10, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
2019838: 92 02 40 02 add %o1, %g2, %o1
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
201983c: 94 02 bf ff add %o2, -1, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
2019840: 96 10 20 01 mov 1, %o3
2019844: 94 08 40 0a and %g1, %o2, %o2
2019848: 7f ff ea 25 call 20140dc <fat_sector_write>
201984c: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
2019850: 80 a2 20 00 cmp %o0, 0
2019854: 06 80 00 22 bl 20198dc <msdos_set_first_char4file_name+0x120><== NEVER TAKEN
2019858: 90 10 3f ff mov -1, %o0
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
201985c: d2 07 bf f0 ld [ %fp + -16 ], %o1
2019860: 80 a7 00 09 cmp %i4, %o1
2019864: 02 80 00 20 be 20198e4 <msdos_set_first_char4file_name+0x128><== ALWAYS TAKEN
2019868: c2 07 bf f4 ld [ %fp + -12 ], %g1
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
201986c: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
2019870: 80 a6 c0 01 cmp %i3, %g1
2019874: 08 80 00 23 bleu 2019900 <msdos_set_first_char4file_name+0x144><== NEVER TAKEN
2019878: c2 27 bf f4 st %g1, [ %fp + -12 ]
201987c: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
2019880: d4 17 40 00 lduh [ %i5 ], %o2
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2019884: 80 a2 60 00 cmp %o1, 0
2019888: 22 bf ff e4 be,a 2019818 <msdos_set_first_char4file_name+0x5c><== ALWAYS TAKEN
201988c: c6 0f 60 0e ldub [ %i5 + 0xe ], %g3
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2019890: c8 0f 60 05 ldub [ %i5 + 5 ], %g4 <== NOT EXECUTED
2019894: c6 07 60 34 ld [ %i5 + 0x34 ], %g3 <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
2019898: 85 30 40 02 srl %g1, %g2, %g2 <== NOT EXECUTED
201989c: 92 02 7f fe add %o1, -2, %o1 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
20198a0: 95 2a a0 10 sll %o2, 0x10, %o2 <== NOT EXECUTED
20198a4: 93 2a 40 04 sll %o1, %g4, %o1 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
20198a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20198ac: 92 02 40 03 add %o1, %g3, %o1 <== NOT EXECUTED
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
20198b0: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
20198b4: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
20198b8: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
20198bc: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
20198c0: 94 08 40 0a and %g1, %o2, %o2 <== NOT EXECUTED
20198c4: 7f ff ea 06 call 20140dc <fat_sector_write> <== NOT EXECUTED
20198c8: 98 07 a0 4c add %fp, 0x4c, %o4 <== NOT EXECUTED
1, &fchar);
if (ret < 0)
20198cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20198d0: 16 bf ff e4 bge 2019860 <msdos_set_first_char4file_name+0xa4><== NOT EXECUTED
20198d4: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
return -1;
20198d8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
20198dc: 81 c7 e0 08 ret <== NOT EXECUTED
20198e0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1, &fchar);
if (ret < 0)
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
20198e4: c4 07 bf fc ld [ %fp + -4 ], %g2
20198e8: 80 a0 40 02 cmp %g1, %g2
20198ec: 32 bf ff e1 bne,a 2019870 <msdos_set_first_char4file_name+0xb4>
20198f0: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
20198f4: 90 10 20 00 clr %o0
}
20198f8: 81 c7 e0 08 ret
20198fc: 91 e8 00 08 restore %g0, %o0, %o0
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
2019900: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
2019904: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2019908: 12 80 00 06 bne 2019920 <msdos_set_first_char4file_name+0x164><== NOT EXECUTED
201990c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2019910: c2 0f 60 0e ldub [ %i5 + 0xe ], %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) &&
2019914: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2019918: 32 bf ff f8 bne,a 20198f8 <msdos_set_first_char4file_name+0x13c><== NOT EXECUTED
201991c: 90 10 20 00 clr %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
2019920: 40 00 05 34 call 201adf0 <fat_get_fat_cluster> <== NOT EXECUTED
2019924: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
2019928: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201992c: 12 bf ff ec bne 20198dc <msdos_set_first_char4file_name+0x120><== NOT EXECUTED
2019930: 82 10 20 00 clr %g1 <== NOT EXECUTED
return rc;
start.ofs = 0;
2019934: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
2019938: d4 17 40 00 lduh [ %i5 ], %o2 <== NOT EXECUTED
201993c: 10 bf ff b5 b 2019810 <msdos_set_first_char4file_name+0x54><== NOT EXECUTED
2019940: c4 0f 60 02 ldub [ %i5 + 2 ], %g2 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2019944: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
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) &&
2019948: 80 88 a0 03 btst 3, %g2
201994c: 02 bf ff ab be 20197f8 <msdos_set_first_char4file_name+0x3c><== NEVER TAKEN
2019950: c4 06 60 08 ld [ %i1 + 8 ], %g2
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
2019954: 80 a0 bf ff cmp %g2, -1
2019958: 12 bf ff ab bne 2019804 <msdos_set_first_char4file_name+0x48>
201995c: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
start = dir_pos->sname;
2019960: f8 27 bf f0 st %i4, [ %fp + -16 ]
2019964: 10 bf ff a8 b 2019804 <msdos_set_first_char4file_name+0x48>
2019968: c2 27 bf f4 st %g1, [ %fp + -12 ]
0201962c <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
)
{
201962c: 9d e3 bf 98 save %sp, -104, %sp
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
2019630: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
2019634: c0 37 bf fe clrh [ %fp + -2 ]
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;
2019638: fa 06 20 08 ld [ %i0 + 8 ], %i5
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
201963c: 80 a0 60 00 cmp %g1, 0
2019640: 12 80 00 06 bne 2019658 <msdos_set_first_cluster_num+0x2c>
2019644: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
2019648: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
201964c: 80 88 a0 03 btst 3, %g2
2019650: 32 80 00 07 bne,a 201966c <msdos_set_first_cluster_num+0x40><== ALWAYS TAKEN
2019654: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2019658: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
201965c: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
2019660: b4 00 7f fe add %g1, -2, %i2
2019664: b5 2e 80 03 sll %i2, %g3, %i2
2019668: b4 06 80 02 add %i2, %g2, %i2
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
201966c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2019670: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2019674: f6 17 40 00 lduh [ %i5 ], %i3
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019678: 85 30 40 02 srl %g1, %g2, %g2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
201967c: b6 06 ff ff add %i3, -1, %i3
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2019680: b4 06 80 02 add %i2, %g2, %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2019684: b6 0e c0 01 and %i3, %g1, %i3
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2019688: 85 2f 20 10 sll %i4, 0x10, %g2
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
201968c: 33 00 00 3f sethi %hi(0xfc00), %i1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2019690: 85 30 a0 18 srl %g2, 0x18, %g2
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2019694: b2 16 63 ff or %i1, 0x3ff, %i1
2019698: 82 0f 00 19 and %i4, %i1, %g1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
201969c: 83 28 60 08 sll %g1, 8, %g1
20196a0: 82 10 40 02 or %g1, %g2, %g1
ret1 = fat_sector_write(&fs_info->fat, sec,
20196a4: 94 06 e0 1a add %i3, 0x1a, %o2
20196a8: 92 10 00 1a mov %i2, %o1
20196ac: 96 10 20 02 mov 2, %o3
20196b0: 98 07 bf fc add %fp, -4, %o4
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
20196b4: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec,
20196b8: 7f ff ea 89 call 20140dc <fat_sector_write>
20196bc: 90 10 00 1d mov %i5, %o0
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
20196c0: b9 37 20 10 srl %i4, 0x10, %i4
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = fat_sector_write(&fs_info->fat, sec,
20196c4: a0 10 00 08 mov %o0, %l0
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
20196c8: b2 0f 00 19 and %i4, %i1, %i1
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = fat_sector_write(&fs_info->fat, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
ret2 = fat_sector_write(&fs_info->fat, sec,
20196cc: 90 10 00 1d mov %i5, %o0
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = fat_sector_write(&fs_info->fat, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
20196d0: b9 37 20 08 srl %i4, 8, %i4
20196d4: b3 2e 60 08 sll %i1, 8, %i1
ret2 = fat_sector_write(&fs_info->fat, sec,
20196d8: 92 10 00 1a mov %i2, %o1
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = fat_sector_write(&fs_info->fat, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
20196dc: b8 16 40 1c or %i1, %i4, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
20196e0: 94 06 e0 14 add %i3, 0x14, %o2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = fat_sector_write(&fs_info->fat, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
20196e4: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec,
20196e8: 96 10 20 02 mov 2, %o3
20196ec: 7f ff ea 7c call 20140dc <fat_sector_write>
20196f0: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
20196f4: 80 a2 20 00 cmp %o0, 0
20196f8: 06 80 00 06 bl 2019710 <msdos_set_first_cluster_num+0xe4> <== NEVER TAKEN
20196fc: 80 a4 20 00 cmp %l0, 0
2019700: 06 80 00 04 bl 2019710 <msdos_set_first_cluster_num+0xe4> <== NEVER TAKEN
2019704: b0 10 20 00 clr %i0
return -1;
return RC_OK;
}
2019708: 81 c7 e0 08 ret
201970c: 81 e8 00 00 restore
2019710: 81 c7 e0 08 ret <== NOT EXECUTED
2019714: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
0200e148 <msdos_set_sectors_per_cluster_from_request>:
static int
msdos_set_sectors_per_cluster_from_request(
const msdos_format_request_param_t *rqdata,
msdos_format_param_t *fmt_params )
{
200e148: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
200e14c: 80 a6 20 00 cmp %i0, 0
200e150: 22 80 00 07 be,a 200e16c <msdos_set_sectors_per_cluster_from_request+0x24>
200e154: c2 06 60 0c ld [ %i1 + 0xc ], %g1
200e158: c2 06 20 08 ld [ %i0 + 8 ], %g1
200e15c: 80 a0 60 00 cmp %g1, 0
200e160: 22 80 00 03 be,a 200e16c <msdos_set_sectors_per_cluster_from_request+0x24>
200e164: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fmt_params->sectors_per_cluster = rqdata->sectors_per_cluster;
200e168: c2 26 60 0c st %g1, [ %i1 + 0xc ]
static int
msdos_set_sectors_per_cluster_from_request(
const msdos_format_request_param_t *rqdata,
msdos_format_param_t *fmt_params )
{
200e16c: b8 10 20 08 mov 8, %i4
200e170: ba 10 20 80 mov 0x80, %i5
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for ( onebit = 128; onebit >= 1; onebit = onebit >> 1 ) {
if ( fmt_params->sectors_per_cluster >= onebit ) {
200e174: 80 a0 40 1d cmp %g1, %i5
200e178: 2a 80 00 0b bcs,a 200e1a4 <msdos_set_sectors_per_cluster_from_request+0x5c>
200e17c: b8 87 3f ff addcc %i4, -1, %i4
fmt_params->sectors_per_cluster = onebit;
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
200e180: d2 06 40 00 ld [ %i1 ], %o1
* 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 ) {
fmt_params->sectors_per_cluster = onebit;
200e184: fa 26 60 0c st %i5, [ %i1 + 0xc ]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
200e188: 7f ff d1 3b call 2002674 <.udiv>
200e18c: 11 00 00 20 sethi %hi(0x8000), %o0
* 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
200e190: 80 a2 00 1d cmp %o0, %i5
200e194: 0a 80 00 04 bcs 200e1a4 <msdos_set_sectors_per_cluster_from_request+0x5c><== NEVER TAKEN
200e198: b8 87 3f ff addcc %i4, -1, %i4
<= 32768L / fmt_params->bytes_per_sector ) {
/* value is small enough so this value is ok */
onebit = 1;
ret_val = 0;
200e19c: 81 c7 e0 08 ret
200e1a0: 91 e8 20 00 restore %g0, 0, %o0
* 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 ) {
200e1a4: 02 80 00 04 be 200e1b4 <msdos_set_sectors_per_cluster_from_request+0x6c><== NEVER TAKEN
200e1a8: bb 37 60 01 srl %i5, 1, %i5
200e1ac: 10 bf ff f2 b 200e174 <msdos_set_sectors_per_cluster_from_request+0x2c>
200e1b0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
}
}
}
if (ret_val != 0) {
errno = EINVAL;
200e1b4: 40 00 3b c6 call 201d0cc <__errno> <== NOT EXECUTED
200e1b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200e1bc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200e1c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return ret_val;
}
200e1c4: 81 c7 e0 08 ret <== NOT EXECUTED
200e1c8: 81 e8 00 00 restore <== NOT EXECUTED
0201ac90 <msdos_sync>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
201ac90: 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;
201ac94: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201ac98: 92 10 20 00 clr %o1
int
msdos_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201ac9c: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201aca0: 94 10 20 00 clr %o2
201aca4: 7f ff bc 33 call 2009d70 <rtems_semaphore_obtain>
201aca8: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201acac: 80 a2 20 00 cmp %o0, 0
201acb0: 12 80 00 09 bne 201acd4 <msdos_sync+0x44> <== NEVER TAKEN
201acb4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_sync(&fs_info->fat);
201acb8: 7f ff e7 fc call 2014ca8 <fat_sync>
201acbc: 90 10 00 1d mov %i5, %o0
201acc0: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
201acc4: 7f ff bc 7a call 2009eac <rtems_semaphore_release>
201acc8: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
201accc: 81 c7 e0 08 ret
201acd0: 81 e8 00 00 restore
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
201acd4: 40 00 08 fe call 201d0cc <__errno> <== NOT EXECUTED
201acd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201acdc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201ace0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201ace4: 81 c7 e0 08 ret <== NOT EXECUTED
201ace8: 81 e8 00 00 restore <== NOT EXECUTED
0200f300 <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
200f300: 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);
200f304: c2 06 20 08 ld [ %i0 + 8 ], %g1
200f308: 7f ff ea e9 call 2009eac <rtems_semaphore_release>
200f30c: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
if (sc != RTEMS_SUCCESSFUL) {
200f310: 80 a2 20 00 cmp %o0, 0
200f314: 12 80 00 04 bne 200f324 <msdos_unlock+0x24> <== NEVER TAKEN
200f318: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
200f31c: 81 c7 e0 08 ret
200f320: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
200f324: 7f ff ec 86 call 200a53c <rtems_fatal_error_occurred> <== NOT EXECUTED
200f328: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
020041dc <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
20041dc: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
20041e0: 03 00 80 76 sethi %hi(0x201d800), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
20041e4: 80 a6 00 19 cmp %i0, %i1
20041e8: 02 80 00 03 be 20041f4 <newlib_delete_hook+0x18>
20041ec: fa 00 61 b0 ld [ %g1 + 0x1b0 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
20041f0: fa 06 61 54 ld [ %i1 + 0x154 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
20041f4: 80 a7 60 00 cmp %i5, 0
20041f8: 02 80 00 0b be 2004224 <newlib_delete_hook+0x48> <== NEVER TAKEN
20041fc: 03 00 80 72 sethi %hi(0x201c800), %g1
2004200: c2 00 63 f8 ld [ %g1 + 0x3f8 ], %g1 ! 201cbf8 <_global_impure_ptr>
2004204: 80 a7 40 01 cmp %i5, %g1
2004208: 02 80 00 07 be 2004224 <newlib_delete_hook+0x48>
200420c: 13 00 80 0f sethi %hi(0x2003c00), %o1
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
2004210: 90 10 00 1d mov %i5, %o0
2004214: 40 00 32 7e call 2010c0c <_fwalk>
2004218: 92 12 63 cc or %o1, 0x3cc, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
200421c: 40 00 1d c6 call 200b934 <_Workspace_Free>
2004220: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
2004224: 80 a6 00 19 cmp %i0, %i1
2004228: 12 80 00 04 bne 2004238 <newlib_delete_hook+0x5c>
200422c: c0 26 61 54 clr [ %i1 + 0x154 ]
_REENT = 0;
2004230: 03 00 80 76 sethi %hi(0x201d800), %g1
2004234: c0 20 61 b0 clr [ %g1 + 0x1b0 ] ! 201d9b0 <_impure_ptr>
2004238: 81 c7 e0 08 ret
200423c: 81 e8 00 00 restore
02003fcc <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
2003fcc: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
2003fd0: 40 00 32 14 call 2010820 <fileno>
2003fd4: 90 10 00 18 mov %i0, %o0
2003fd8: 80 a2 20 02 cmp %o0, 2
2003fdc: 28 80 00 06 bleu,a 2003ff4 <newlib_free_buffers+0x28> <== ALWAYS TAKEN
2003fe0: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
2003fe4: 40 00 31 4f call 2010520 <fclose> <== NOT EXECUTED
2003fe8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
2003fec: 81 c7 e0 08 ret
2003ff0: 91 e8 20 00 restore %g0, 0, %o0
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
2003ff4: 80 88 60 80 btst 0x80, %g1
2003ff8: 02 bf ff fd be 2003fec <newlib_free_buffers+0x20> <== ALWAYS TAKEN
2003ffc: 01 00 00 00 nop
free( fp->_bf._base );
2004000: 7f ff fd 9c call 2003670 <free> <== NOT EXECUTED
2004004: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
2004008: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
200400c: 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;
2004010: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2004014: 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;
2004018: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
200401c: 81 c7 e0 08 ret <== NOT EXECUTED
2004020: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02001cc0 <notify>:
}
void
notify (s)
char *s;
{
2001cc0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
2001cc4: 11 00 80 8f sethi %hi(0x2023c00), %o0 <== NOT EXECUTED
2001cc8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2001ccc: 90 12 22 a8 or %o0, 0x2a8, %o0 <== NOT EXECUTED
2001cd0: 40 00 5d 58 call 2019230 <printf> <== NOT EXECUTED
2001cd4: 31 00 80 8f sethi %hi(0x2023c00), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
2001cd8: 40 00 5d 97 call 2019334 <puts> <== NOT EXECUTED
2001cdc: 91 ee 22 d0 restore %i0, 0x2d0, %o0 <== NOT EXECUTED
02006ffc <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
2006ffc: 81 c3 e0 08 retl <== NOT EXECUTED
2007000: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
0200700c <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
200700c: 81 c3 e0 08 retl <== NOT EXECUTED
02006fd4 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
2006fd4: 81 c3 e0 08 retl <== NOT EXECUTED
2006fd8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006ff4 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
2006ff4: 81 c3 e0 08 retl <== NOT EXECUTED
2006ff8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02007024 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
2007024: 81 c3 e0 08 retl <== NOT EXECUTED
2007028: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
0200702c <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
200702c: 81 c3 e0 08 retl <== NOT EXECUTED
2007030: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006fcc <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
2006fcc: 81 c3 e0 08 retl <== NOT EXECUTED
2006fd0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006000 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
2006000: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
2006004: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
2006008: 80 88 60 01 btst 1, %g1
200600c: 02 80 00 21 be 2006090 <oproc+0x90> <== NEVER TAKEN
2006010: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
2006014: 80 a6 20 09 cmp %i0, 9
2006018: 22 80 00 3d be,a 200610c <oproc+0x10c>
200601c: c6 06 60 28 ld [ %i1 + 0x28 ], %g3
2006020: 08 80 00 22 bleu 20060a8 <oproc+0xa8> <== NEVER TAKEN
2006024: 80 a6 20 08 cmp %i0, 8
2006028: 80 a6 20 0a cmp %i0, 0xa
200602c: 02 80 00 2b be 20060d8 <oproc+0xd8>
2006030: 80 a6 20 0d cmp %i0, 0xd
2006034: 02 80 00 45 be 2006148 <oproc+0x148> <== NEVER TAKEN
2006038: 80 88 60 10 btst 0x10, %g1
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
200603c: 80 88 60 02 btst 2, %g1
c = toupper(c);
2006040: 03 00 80 76 sethi %hi(0x201d800), %g1
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
2006044: 02 80 00 0b be 2006070 <oproc+0x70> <== ALWAYS TAKEN
2006048: c2 00 61 a8 ld [ %g1 + 0x1a8 ], %g1 ! 201d9a8 <__ctype_ptr__>
c = toupper(c);
200604c: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED
2006050: b0 00 40 18 add %g1, %i0, %i0 <== NOT EXECUTED
2006054: c6 0e 20 01 ldub [ %i0 + 1 ], %g3 <== NOT EXECUTED
2006058: 86 08 e0 03 and %g3, 3, %g3 <== NOT EXECUTED
200605c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED
2006060: 22 80 00 02 be,a 2006068 <oproc+0x68> <== NOT EXECUTED
2006064: 84 00 bf e0 add %g2, -32, %g2 <== NOT EXECUTED
2006068: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
200606c: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED
if (!iscntrl(c))
2006070: b0 00 40 18 add %g1, %i0, %i0
2006074: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
2006078: 80 88 60 20 btst 0x20, %g1
200607c: 12 80 00 06 bne 2006094 <oproc+0x94> <== NEVER TAKEN
2006080: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
2006084: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
2006088: 82 00 60 01 inc %g1
200608c: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
2006090: 90 07 a0 44 add %fp, 0x44, %o0
2006094: 92 10 20 01 mov 1, %o1
2006098: 7f ff ff 8a call 2005ec0 <rtems_termios_puts>
200609c: 94 10 00 19 mov %i1, %o2
20060a0: 81 c7 e0 08 ret
20060a4: 81 e8 00 00 restore
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
20060a8: 12 bf ff e6 bne 2006040 <oproc+0x40> <== NOT EXECUTED
20060ac: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
20060b0: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
20060b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20060b8: 04 bf ff f6 ble 2006090 <oproc+0x90> <== NOT EXECUTED
20060bc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
20060c0: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED
tty->column += i;
break;
case '\b':
if (tty->column > 0)
tty->column--;
20060c4: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
20060c8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20060cc: 7f ff ff 7d call 2005ec0 <rtems_termios_puts> <== NOT EXECUTED
20060d0: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
20060d4: 30 80 00 1b b,a 2006140 <oproc+0x140> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
20060d8: 80 88 60 20 btst 0x20, %g1
20060dc: 32 80 00 02 bne,a 20060e4 <oproc+0xe4> <== NEVER TAKEN
20060e0: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
20060e4: 80 88 60 04 btst 4, %g1
20060e8: 22 bf ff eb be,a 2006094 <oproc+0x94> <== NEVER TAKEN
20060ec: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED
rtems_termios_puts ("\r", 1, tty);
20060f0: 92 10 20 01 mov 1, %o1
20060f4: 11 00 80 70 sethi %hi(0x201c000), %o0
20060f8: 94 10 00 19 mov %i1, %o2
20060fc: 7f ff ff 71 call 2005ec0 <rtems_termios_puts>
2006100: 90 12 20 e8 or %o0, 0xe8, %o0
tty->column = 0;
2006104: 10 bf ff e3 b 2006090 <oproc+0x90>
2006108: c0 26 60 28 clr [ %i1 + 0x28 ]
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
200610c: 92 10 20 08 mov 8, %o1
2006110: 88 08 e0 07 and %g3, 7, %g4
2006114: 92 22 40 04 sub %o1, %g4, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
2006118: 86 00 c0 09 add %g3, %o1, %g3
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
200611c: 05 00 00 06 sethi %hi(0x1800), %g2
2006120: 82 08 40 02 and %g1, %g2, %g1
2006124: 80 a0 40 02 cmp %g1, %g2
2006128: 12 bf ff da bne 2006090 <oproc+0x90> <== NEVER TAKEN
200612c: c6 26 60 28 st %g3, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
2006130: 11 00 80 70 sethi %hi(0x201c000), %o0
2006134: 94 10 00 19 mov %i1, %o2
2006138: 7f ff ff 62 call 2005ec0 <rtems_termios_puts>
200613c: 90 12 20 f0 or %o0, 0xf0, %o0
return;
2006140: 81 c7 e0 08 ret
2006144: 81 e8 00 00 restore
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
2006148: 02 80 00 06 be 2006160 <oproc+0x160> <== NOT EXECUTED
200614c: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
2006150: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
2006154: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2006158: 02 bf ff d2 be 20060a0 <oproc+0xa0> <== NOT EXECUTED
200615c: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
2006160: 22 bf ff cc be,a 2006090 <oproc+0x90> <== NOT EXECUTED
2006164: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
2006168: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
200616c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006170: 02 bf ff c8 be 2006090 <oproc+0x90> <== NOT EXECUTED
2006174: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
2006178: 10 bf ff c6 b 2006090 <oproc+0x90> <== NOT EXECUTED
200617c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
02004af8 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
2004af8: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
2004afc: 80 a6 20 00 cmp %i0, 0
2004b00: 02 80 00 11 be 2004b44 <partition_free+0x4c>
2004b04: 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));
2004b08: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
2004b0c: 82 08 60 7f and %g1, 0x7f, %g1
2004b10: 80 a0 60 05 cmp %g1, 5
2004b14: 12 80 00 0a bne 2004b3c <partition_free+0x44> <== ALWAYS TAKEN
2004b18: 01 00 00 00 nop
2004b1c: ba 10 20 00 clr %i5 ! 0 <PROM_START> <== NOT EXECUTED
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
2004b20: 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]);
2004b24: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
2004b28: 7f ff ff f4 call 2004af8 <partition_free> <== NOT EXECUTED
2004b2c: 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;
2004b30: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
2004b34: 12 bf ff fc bne 2004b24 <partition_free+0x2c> <== NOT EXECUTED
2004b38: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
2004b3c: 40 00 04 3b call 2005c28 <free>
2004b40: 81 e8 00 00 restore
2004b44: 81 c7 e0 08 ret
2004b48: 81 e8 00 00 restore
02004e90 <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)
{
2004e90: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
2004e94: 92 10 20 00 clr %o1
2004e98: 90 10 00 18 mov %i0, %o0
2004e9c: 40 00 07 37 call 2006b78 <open>
2004ea0: b8 10 00 18 mov %i0, %i4
if (fd < 0)
{
return RTEMS_INTERNAL_ERROR;
2004ea4: b0 10 20 19 mov 0x19, %i0
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
if (fd < 0)
2004ea8: 80 a2 20 00 cmp %o0, 0
2004eac: 06 80 00 09 bl 2004ed0 <partition_table_get+0x40> <== NEVER TAKEN
2004eb0: ba 10 00 08 mov %o0, %i5
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
2004eb4: 40 00 03 87 call 2005cd0 <fstat>
2004eb8: 92 07 bf b8 add %fp, -72, %o1
if (rc != RTEMS_SUCCESSFUL)
2004ebc: 80 a2 20 00 cmp %o0, 0
2004ec0: 02 80 00 06 be 2004ed8 <partition_table_get+0x48> <== ALWAYS TAKEN
2004ec4: 90 06 60 08 add %i1, 8, %o0
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
2004ec8: 40 00 02 9c call 2005938 <close>
2004ecc: 90 10 00 1d mov %i5, %o0
2004ed0: 81 c7 e0 08 ret
2004ed4: 81 e8 00 00 restore
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
2004ed8: 92 10 00 1c mov %i4, %o1
2004edc: 40 00 4b 6f call 2017c98 <strncpy>
2004ee0: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
2004ee4: c4 1f bf d0 ldd [ %fp + -48 ], %g2
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
2004ee8: c8 07 bf f8 ld [ %fp + -8 ], %g4
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
disk_desc->dev = dev_stat.st_rdev;
2004eec: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
2004ef0: 80 a1 20 00 cmp %g4, 0
2004ef4: 02 80 00 03 be 2004f00 <partition_table_get+0x70> <== ALWAYS TAKEN
2004ef8: 82 10 22 00 mov 0x200, %g1
2004efc: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
2004f00: 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;
2004f04: c0 27 bf b0 clr [ %fp + -80 ]
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
new_off = lseek(fd, off, SEEK_SET);
2004f08: 90 10 00 1d mov %i5, %o0
2004f0c: 92 10 20 00 clr %o1
2004f10: 94 10 20 00 clr %o2
2004f14: 96 10 20 00 clr %o3
2004f18: 40 00 04 68 call 20060b8 <lseek>
2004f1c: b0 10 20 1b mov 0x1b, %i0
if (new_off != off) {
2004f20: 80 92 00 09 orcc %o0, %o1, %g0
2004f24: 02 80 00 09 be 2004f48 <partition_table_get+0xb8> <== ALWAYS TAKEN
2004f28: 90 10 00 1d mov %i5, %o0
/* get MBR sector */
rc = get_sector(fd, 0, §or);
if (rc != RTEMS_SUCCESSFUL)
{
if (sector)
2004f2c: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
2004f30: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004f34: 02 bf ff e5 be 2004ec8 <partition_table_get+0x38> <== NOT EXECUTED
2004f38: 01 00 00 00 nop <== NOT EXECUTED
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
2004f3c: 40 00 03 3b call 2005c28 <free> <== NOT EXECUTED
2004f40: 01 00 00 00 nop <== NOT EXECUTED
2004f44: 30 bf ff e1 b,a 2004ec8 <partition_table_get+0x38> <== NOT EXECUTED
2004f48: 92 10 20 00 clr %o1 ! 0 <PROM_START>
2004f4c: 7f ff ff 0b call 2004b78 <get_sector.part.0>
2004f50: 94 07 bf b0 add %fp, -80, %o2
uint8_t *data;
rtems_status_code rc;
/* get MBR sector */
rc = get_sector(fd, 0, §or);
if (rc != RTEMS_SUCCESSFUL)
2004f54: b0 92 20 00 orcc %o0, 0, %i0
2004f58: 12 bf ff f5 bne 2004f2c <partition_table_get+0x9c> <== NEVER TAKEN
2004f5c: d0 07 bf b0 ld [ %fp + -80 ], %o0
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) &&
2004f60: c2 0a 22 02 ldub [ %o0 + 0x202 ], %g1
2004f64: 80 a0 60 55 cmp %g1, 0x55
2004f68: 22 80 00 05 be,a 2004f7c <partition_table_get+0xec> <== ALWAYS TAKEN
2004f6c: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
}
/* check if the partition table structure is MS-DOS style */
if (!msdos_signature_check(sector))
{
free(sector);
2004f70: 40 00 03 2e call 2005c28 <free> <== NOT EXECUTED
2004f74: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
2004f78: 30 bf ff d4 b,a 2004ec8 <partition_table_get+0x38> <== 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) &&
2004f7c: 80 a0 60 aa cmp %g1, 0xaa
2004f80: 12 bf ff fc bne 2004f70 <partition_table_get+0xe0> <== NEVER TAKEN
2004f84: b4 02 21 c2 add %o0, 0x1c2, %i2
2004f88: b6 10 00 19 mov %i1, %i3
return RTEMS_INTERNAL_ERROR;
}
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
2004f8c: a0 10 00 19 mov %i1, %l0
2004f90: b8 10 20 01 mov 1, %i4
2004f94: 90 10 00 1a mov %i2, %o0
2004f98: 7f ff ff 0f call 2004bd4 <data_to_part_desc.part.1>
2004f9c: 92 07 bf b4 add %fp, -76, %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)
2004fa0: b0 92 20 00 orcc %o0, 0, %i0
2004fa4: 12 80 00 2b bne 2005050 <partition_table_get+0x1c0> <== NEVER TAKEN
2004fa8: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
free(sector);
return rc;
}
if (part_desc != NULL)
2004fac: 80 a0 60 00 cmp %g1, 0
2004fb0: 22 80 00 0a be,a 2004fd8 <partition_table_get+0x148> <== NEVER TAKEN
2004fb4: c0 24 20 28 clr [ %l0 + 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;
2004fb8: c6 00 60 04 ld [ %g1 + 4 ], %g3
2004fbc: c4 00 60 08 ld [ %g1 + 8 ], %g2
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
2004fc0: f8 28 60 02 stb %i4, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
2004fc4: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
2004fc8: 84 00 c0 02 add %g3, %g2, %g2
2004fcc: 84 00 bf ff add %g2, -1, %g2
2004fd0: c4 20 60 0c st %g2, [ %g1 + 0xc ]
disk_desc->partitions[part_num] = part_desc;
2004fd4: c2 24 20 28 st %g1, [ %l0 + 0x28 ]
2004fd8: b8 07 20 01 inc %i4
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
2004fdc: b4 06 a0 10 add %i2, 0x10, %i2
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
2004fe0: 82 0f 20 ff and %i4, 0xff, %g1
2004fe4: 80 a0 60 05 cmp %g1, 5
2004fe8: 12 bf ff eb bne 2004f94 <partition_table_get+0x104>
2004fec: a0 04 20 04 add %l0, 4, %l0
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004ff0: d0 07 bf b0 ld [ %fp + -80 ], %o0
2004ff4: 40 00 03 0d call 2005c28 <free>
2004ff8: b8 10 20 04 mov 4, %i4
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
2004ffc: 82 10 20 04 mov 4, %g1
2005000: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
2005004: d4 06 e0 28 ld [ %i3 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
2005008: 80 a2 a0 00 cmp %o2, 0
200500c: 02 80 00 07 be 2005028 <partition_table_get+0x198> <== NEVER TAKEN
2005010: d4 27 bf b4 st %o2, [ %fp + -76 ]
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2005014: c2 0a a0 01 ldub [ %o2 + 1 ], %g1
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
if (part_desc != NULL && is_extended(part_desc->sys_type))
2005018: 82 08 60 7f and %g1, 0x7f, %g1
200501c: 80 a0 60 05 cmp %g1, 5
2005020: 22 80 00 06 be,a 2005038 <partition_table_get+0x1a8>
2005024: d2 02 a0 04 ld [ %o2 + 4 ], %o1
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;
2005028: b8 87 3f ff addcc %i4, -1, %i4
200502c: 12 bf ff f6 bne 2005004 <partition_table_get+0x174>
2005030: b6 06 e0 04 add %i3, 4, %i3
2005034: 30 bf ff a5 b,a 2004ec8 <partition_table_get+0x38>
part_num++)
{
part_desc = disk_desc->partitions[part_num];
if (part_desc != NULL && is_extended(part_desc->sys_type))
{
read_extended_partition(fd, part_desc->start, part_desc);
2005038: 7f ff ff 34 call 2004d08 <read_extended_partition>
200503c: 90 10 00 1d mov %i5, %o0
free(part_desc);
2005040: 40 00 02 fa call 2005c28 <free>
2005044: d0 07 bf b4 ld [ %fp + -76 ], %o0
disk_desc->partitions[part_num] = NULL;
2005048: 10 bf ff f8 b 2005028 <partition_table_get+0x198>
200504c: c0 26 e0 28 clr [ %i3 + 0x28 ]
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
2005050: 40 00 02 f6 call 2005c28 <free> <== NOT EXECUTED
2005054: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
2005058: 30 bf ff 9c b,a 2004ec8 <partition_table_get+0x38> <== NOT EXECUTED
0200461c <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
200461c: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
2004620: 92 10 20 00 clr %o1
2004624: 7f ff ff 6d call 20043d8 <open>
2004628: 90 10 00 18 mov %i0, %o0
if ( fd == -1 )
200462c: 80 a2 3f ff cmp %o0, -1
2004630: 02 80 00 09 be 2004654 <pathconf+0x38> <== ALWAYS TAKEN
2004634: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
2004638: 40 00 15 a3 call 2009cc4 <fpathconf> <== NOT EXECUTED
200463c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2004640: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
2004644: 40 00 15 72 call 2009c0c <close> <== NOT EXECUTED
2004648: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
200464c: 81 c7 e0 08 ret <== NOT EXECUTED
2004650: 81 e8 00 00 restore <== NOT EXECUTED
}
2004654: 81 c7 e0 08 ret
2004658: 91 e8 3f ff restore %g0, -1, %o0
0200daac <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
200daac: 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)
200dab0: 92 10 21 ff mov 0x1ff, %o1
200dab4: 11 00 80 85 sethi %hi(0x2021400), %o0
200dab8: 40 00 05 c3 call 200f1c4 <rtems_mkdir>
200dabc: 90 12 22 10 or %o0, 0x210, %o0 ! 2021610 <_CPU_Trap_slot_template+0x10>
200dac0: 80 a2 20 00 cmp %o0, 0
200dac4: 12 80 00 49 bne 200dbe8 <pipe_create+0x13c>
200dac8: 03 00 80 8c sethi %hi(0x2023000), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200dacc: d4 10 61 70 lduh [ %g1 + 0x170 ], %o2 ! 2023170 <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);
200dad0: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200dad4: 88 02 a0 01 add %o2, 1, %g4
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
200dad8: 84 10 a1 70 or %g2, 0x170, %g2
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200dadc: c8 30 61 70 sth %g4, [ %g1 + 0x170 ]
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
200dae0: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
200dae4: 03 00 00 19 sethi %hi(0x6400), %g1
200dae8: 86 10 e2 69 or %g3, 0x269, %g3
200daec: 82 10 62 6f or %g1, 0x26f, %g1
200daf0: c4 3f bf f0 std %g2, [ %fp + -16 ]
200daf4: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200daf8: 95 2a a0 10 sll %o2, 0x10, %o2
200dafc: 90 07 bf fa add %fp, -6, %o0
200db00: 95 32 a0 10 srl %o2, 0x10, %o2
200db04: 13 00 80 85 sethi %hi(0x2021400), %o1
200db08: 40 00 14 6b call 2012cb4 <sprintf>
200db0c: 92 12 62 18 or %o1, 0x218, %o1 ! 2021618 <_CPU_Trap_slot_template+0x18>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
200db10: 90 07 bf f0 add %fp, -16, %o0
200db14: 40 00 04 f8 call 200eef4 <mkfifo>
200db18: 92 10 21 80 mov 0x180, %o1
200db1c: 80 a2 20 00 cmp %o0, 0
200db20: 12 80 00 39 bne 200dc04 <pipe_create+0x158> <== NEVER TAKEN
200db24: 90 07 bf f0 add %fp, -16, %o0
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);
200db28: 7f ff dc cb call 2004e54 <open>
200db2c: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
200db30: 80 a2 20 00 cmp %o0, 0
200db34: 06 80 00 20 bl 200dbb4 <pipe_create+0x108>
200db38: d0 26 00 00 st %o0, [ %i0 ]
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]);
200db3c: 03 00 80 8a sethi %hi(0x2022800), %g1
200db40: c4 00 60 84 ld [ %g1 + 0x84 ], %g2 ! 2022884 <rtems_libio_number_iops>
200db44: 80 a2 00 02 cmp %o0, %g2
200db48: 0a 80 00 14 bcs 200db98 <pipe_create+0xec> <== ALWAYS TAKEN
200db4c: 82 10 20 00 clr %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
200db50: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
200db54: 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;
200db58: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
200db5c: 92 10 20 01 mov 1, %o1
200db60: 7f ff dc bd call 2004e54 <open>
200db64: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
200db68: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
200db6c: 80 a2 20 00 cmp %o0, 0
200db70: 06 80 00 18 bl 200dbd0 <pipe_create+0x124>
200db74: ba 10 20 00 clr %i5
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
200db78: 7f ff e9 22 call 2008000 <unlink>
200db7c: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
200db80: b0 10 20 00 clr %i0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
200db84: 80 a7 60 00 cmp %i5, 0
200db88: 12 80 00 1a bne 200dbf0 <pipe_create+0x144>
200db8c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(err);
return 0;
}
200db90: 81 c7 e0 08 ret
200db94: 81 e8 00 00 restore
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]);
200db98: 03 00 80 8c sethi %hi(0x2023000), %g1
200db9c: c2 00 62 ec ld [ %g1 + 0x2ec ], %g1 ! 20232ec <rtems_libio_iops>
200dba0: 85 2a 20 03 sll %o0, 3, %g2
200dba4: 91 2a 20 06 sll %o0, 6, %o0
200dba8: 90 22 00 02 sub %o0, %g2, %o0
200dbac: 10 bf ff e9 b 200db50 <pipe_create+0xa4>
200dbb0: 82 00 40 08 add %g1, %o0, %g1
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
200dbb4: 40 00 10 d5 call 2011f08 <__errno>
200dbb8: b0 10 20 00 clr %i0
200dbbc: fa 02 00 00 ld [ %o0 ], %i5
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
200dbc0: 7f ff e9 10 call 2008000 <unlink>
200dbc4: 90 07 bf f0 add %fp, -16, %o0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
200dbc8: 10 bf ff f0 b 200db88 <pipe_create+0xdc>
200dbcc: 80 a7 60 00 cmp %i5, 0
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
200dbd0: 40 00 10 ce call 2011f08 <__errno>
200dbd4: 01 00 00 00 nop
200dbd8: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
200dbdc: 7f ff d8 80 call 2003ddc <close>
200dbe0: d0 06 00 00 ld [ %i0 ], %o0
200dbe4: 30 bf ff e5 b,a 200db78 <pipe_create+0xcc>
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
200dbe8: 81 c7 e0 08 ret
200dbec: 91 e8 3f ff restore %g0, -1, %o0
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
200dbf0: 40 00 10 c6 call 2011f08 <__errno>
200dbf4: b0 10 3f ff mov -1, %i0
200dbf8: fa 22 00 00 st %i5, [ %o0 ]
200dbfc: 81 c7 e0 08 ret
200dc00: 81 e8 00 00 restore
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
200dc04: 40 00 10 c1 call 2011f08 <__errno> <== NOT EXECUTED
200dc08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200dc0c: 81 c7 e0 08 ret <== NOT EXECUTED
200dc10: 81 e8 00 00 restore <== NOT EXECUTED
0200f0c4 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
200f0c4: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
200f0c8: 03 10 01 19 sethi %hi(0x40046400), %g1
200f0cc: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <RAM_END+0x3dc4667f>
200f0d0: 80 a6 40 01 cmp %i1, %g1
200f0d4: 12 80 00 11 bne 200f118 <pipe_ioctl+0x54>
200f0d8: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
200f0dc: 02 80 00 13 be 200f128 <pipe_ioctl+0x64>
200f0e0: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
200f0e4: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200f0e8: 7f ff e9 18 call 2009548 <rtems_semaphore_obtain>
200f0ec: 94 10 20 00 clr %o2
200f0f0: 80 a2 20 00 cmp %o0, 0
200f0f4: 12 80 00 0b bne 200f120 <pipe_ioctl+0x5c> <== NEVER TAKEN
200f0f8: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200f0fc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
200f100: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200f104: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
200f108: 7f ff e9 5f call 2009684 <rtems_semaphore_release>
200f10c: b0 10 20 00 clr %i0
return 0;
200f110: 81 c7 e0 08 ret
200f114: 81 e8 00 00 restore
}
return -EINVAL;
200f118: 81 c7 e0 08 ret
200f11c: 91 e8 3f ea restore %g0, -22, %o0
}
200f120: 81 c7 e0 08 ret <== NOT EXECUTED
200f124: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
200f128: 81 c7 e0 08 ret
200f12c: 91 e8 3f f2 restore %g0, -14, %o0
0200ed00 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200ed00: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200ed04: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200ed08: 92 10 20 00 clr %o1
200ed0c: 94 10 20 00 clr %o2
200ed10: 7f ff ea 0e call 2009548 <rtems_semaphore_obtain>
200ed14: ba 10 00 18 mov %i0, %i5
200ed18: 80 a2 20 00 cmp %o0, 0
200ed1c: 12 80 00 60 bne 200ee9c <pipe_read+0x19c> <== NEVER TAKEN
200ed20: a0 10 20 00 clr %l0
return -EINTR;
while (read < count) {
200ed24: 80 a6 a0 00 cmp %i2, 0
200ed28: 02 80 00 53 be 200ee74 <pipe_read+0x174> <== NEVER TAKEN
200ed2c: b0 10 20 00 clr %i0
while (PIPE_EMPTY(pipe)) {
200ed30: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200ed34: 80 a0 60 00 cmp %g1, 0
200ed38: 12 80 00 29 bne 200eddc <pipe_read+0xdc>
200ed3c: 84 26 80 10 sub %i2, %l0, %g2
/* Not an error */
if (pipe->Writers == 0)
200ed40: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200ed44: 80 a0 60 00 cmp %g1, 0
200ed48: 02 80 00 1c be 200edb8 <pipe_read+0xb8>
200ed4c: b8 10 20 00 clr %i4
goto out_locked;
if (LIBIO_NODELAY(iop)) {
200ed50: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
200ed54: 80 88 60 01 btst 1, %g1
200ed58: 32 80 00 18 bne,a 200edb8 <pipe_read+0xb8>
200ed5c: 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 ++;
200ed60: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
200ed64: 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 ++;
200ed68: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200ed6c: 7f ff ea 46 call 2009684 <rtems_semaphore_release>
200ed70: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
200ed74: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200ed78: 40 00 05 ce call 20104b0 <rtems_barrier_wait>
200ed7c: 92 10 20 00 clr %o1
200ed80: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200ed84: 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))
200ed88: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200ed8c: 92 10 20 00 clr %o1
200ed90: 94 10 20 00 clr %o2
200ed94: 7f ff e9 ed call 2009548 <rtems_semaphore_obtain>
200ed98: b8 0f 3f fc and %i4, -4, %i4
200ed9c: 80 a2 20 00 cmp %o0, 0
200eda0: 12 80 00 37 bne 200ee7c <pipe_read+0x17c> <== NEVER TAKEN
200eda4: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
200eda8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200edac: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200edb0: 02 bf ff e0 be 200ed30 <pipe_read+0x30> <== ALWAYS TAKEN
200edb4: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
200edb8: 7f ff ea 33 call 2009684 <rtems_semaphore_release>
200edbc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
200edc0: 80 a6 20 00 cmp %i0, 0
200edc4: 04 80 00 04 ble 200edd4 <pipe_read+0xd4>
200edc8: 01 00 00 00 nop
return read;
return ret;
}
200edcc: 81 c7 e0 08 ret
200edd0: 81 e8 00 00 restore
200edd4: 81 c7 e0 08 ret
200edd8: 91 e8 00 1c restore %g0, %i4, %o0
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
200eddc: 80 a0 40 02 cmp %g1, %g2
200ede0: 08 80 00 03 bleu 200edec <pipe_read+0xec>
200ede4: b8 10 00 01 mov %g1, %i4
200ede8: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - pipe->Start;
200edec: c2 07 60 08 ld [ %i5 + 8 ], %g1
200edf0: e2 07 60 04 ld [ %i5 + 4 ], %l1
200edf4: a2 24 40 01 sub %l1, %g1, %l1
if (chunk > chunk1) {
200edf8: 80 a7 00 11 cmp %i4, %l1
200edfc: 04 80 00 22 ble 200ee84 <pipe_read+0x184>
200ee00: d2 07 40 00 ld [ %i5 ], %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
200ee04: 94 10 00 11 mov %l1, %o2
200ee08: 92 02 40 01 add %o1, %g1, %o1
200ee0c: 40 00 12 2b call 20136b8 <memcpy>
200ee10: 90 06 40 10 add %i1, %l0, %o0
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
200ee14: d2 07 40 00 ld [ %i5 ], %o1
200ee18: 90 04 00 11 add %l0, %l1, %o0
200ee1c: 94 27 00 11 sub %i4, %l1, %o2
200ee20: 40 00 12 26 call 20136b8 <memcpy>
200ee24: 90 06 40 08 add %i1, %o0, %o0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
200ee28: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
200ee2c: d2 07 60 04 ld [ %i5 + 4 ], %o1
200ee30: 40 00 41 ff call 201f62c <.urem>
200ee34: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
200ee38: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
200ee3c: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
200ee40: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
200ee44: 80 a0 60 00 cmp %g1, 0
200ee48: 12 80 00 03 bne 200ee54 <pipe_read+0x154>
200ee4c: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
200ee50: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
200ee54: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200ee58: 80 a0 60 00 cmp %g1, 0
200ee5c: 32 80 00 12 bne,a 200eea4 <pipe_read+0x1a4>
200ee60: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
200ee64: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
200ee68: 80 a6 00 1a cmp %i0, %i2
200ee6c: 0a bf ff b1 bcs 200ed30 <pipe_read+0x30> <== NEVER TAKEN
200ee70: a0 10 00 18 mov %i0, %l0
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
200ee74: 10 bf ff d1 b 200edb8 <pipe_read+0xb8>
200ee78: b8 10 20 00 clr %i4
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
200ee7c: 10 bf ff d1 b 200edc0 <pipe_read+0xc0> <== NOT EXECUTED
200ee80: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
200ee84: 90 06 40 10 add %i1, %l0, %o0
200ee88: 92 02 40 01 add %o1, %g1, %o1
200ee8c: 40 00 12 0b call 20136b8 <memcpy>
200ee90: 94 10 00 1c mov %i4, %o2
pipe->Start += chunk;
200ee94: 10 bf ff e6 b 200ee2c <pipe_read+0x12c>
200ee98: d0 07 60 08 ld [ %i5 + 8 ], %o0
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
200ee9c: 81 c7 e0 08 ret <== NOT EXECUTED
200eea0: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
200eea4: 40 00 05 6b call 2010450 <rtems_barrier_release>
200eea8: 92 07 bf fc add %fp, -4, %o1
read += chunk;
200eeac: 10 bf ff ef b 200ee68 <pipe_read+0x168>
200eeb0: b0 06 00 1c add %i0, %i4, %i0
0200e750 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200e750: 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);
200e754: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
200e758: 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)
200e75c: 80 88 60 02 btst 2, %g1
200e760: 02 80 00 05 be 200e774 <pipe_release+0x24>
200e764: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
200e768: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200e76c: 84 00 bf ff add %g2, -1, %g2
200e770: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
200e774: 80 88 60 04 btst 4, %g1
200e778: 02 80 00 05 be 200e78c <pipe_release+0x3c>
200e77c: 01 00 00 00 nop
pipe->Writers --;
200e780: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e784: 82 00 7f ff add %g1, -1, %g1
200e788: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
200e78c: 7f ff eb be call 2009684 <rtems_semaphore_release>
200e790: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
200e794: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e798: 80 a0 60 00 cmp %g1, 0
200e79c: 02 80 00 0f be 200e7d8 <pipe_release+0x88>
200e7a0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
200e7a4: 80 a0 60 00 cmp %g1, 0
200e7a8: 12 80 00 07 bne 200e7c4 <pipe_release+0x74> <== NEVER TAKEN
200e7ac: 80 a7 20 02 cmp %i4, 2
200e7b0: 02 80 00 06 be 200e7c8 <pipe_release+0x78> <== NEVER TAKEN
200e7b4: 03 00 80 90 sethi %hi(0x2024000), %g1
PIPE_WAKEUPREADERS(pipe);
200e7b8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e7bc: 40 00 07 25 call 2010450 <rtems_barrier_release>
200e7c0: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200e7c4: 03 00 80 90 sethi %hi(0x2024000), %g1
200e7c8: 7f ff eb af call 2009684 <rtems_semaphore_release>
200e7cc: d0 00 61 10 ld [ %g1 + 0x110 ], %o0 ! 2024110 <pipe_semaphore>
200e7d0: 81 c7 e0 08 ret
200e7d4: 81 e8 00 00 restore
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
200e7d8: 80 a0 60 00 cmp %g1, 0
200e7dc: 02 80 00 0c be 200e80c <pipe_release+0xbc>
200e7e0: 80 a7 20 04 cmp %i4, 4
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
200e7e4: 02 bf ff f9 be 200e7c8 <pipe_release+0x78> <== NEVER TAKEN
200e7e8: 03 00 80 90 sethi %hi(0x2024000), %g1
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
200e7ec: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e7f0: 40 00 07 18 call 2010450 <rtems_barrier_release>
200e7f4: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200e7f8: 03 00 80 90 sethi %hi(0x2024000), %g1
200e7fc: 7f ff eb a2 call 2009684 <rtems_semaphore_release>
200e800: d0 00 61 10 ld [ %g1 + 0x110 ], %o0 ! 2024110 <pipe_semaphore>
200e804: 81 c7 e0 08 ret
200e808: 81 e8 00 00 restore
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
200e80c: 40 00 06 e8 call 20103ac <rtems_barrier_delete>
200e810: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
rtems_barrier_delete(pipe->writeBarrier);
200e814: 40 00 06 e6 call 20103ac <rtems_barrier_delete>
200e818: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
rtems_semaphore_delete(pipe->Semaphore);
200e81c: 7f ff eb 14 call 200946c <rtems_semaphore_delete>
200e820: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
free(pipe->Buffer);
200e824: 7f ff d8 63 call 20049b0 <free>
200e828: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
200e82c: 7f ff d8 61 call 20049b0 <free>
200e830: 90 10 00 1d mov %i5, %o0
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200e834: 03 00 80 90 sethi %hi(0x2024000), %g1
200e838: d0 00 61 10 ld [ %g1 + 0x110 ], %o0 ! 2024110 <pipe_semaphore>
200e83c: 7f ff eb 92 call 2009684 <rtems_semaphore_release>
200e840: c0 26 00 00 clr [ %i0 ]
200e844: 81 c7 e0 08 ret
200e848: 81 e8 00 00 restore
0200eeb4 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200eeb4: 9d e3 bf 98 save %sp, -104, %sp
200eeb8: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
200eebc: 80 a6 a0 00 cmp %i2, 0
200eec0: 12 80 00 04 bne 200eed0 <pipe_write+0x1c> <== ALWAYS TAKEN
200eec4: b0 10 20 00 clr %i0
#endif
if (written > 0)
return written;
return ret;
}
200eec8: 81 c7 e0 08 ret
200eecc: 81 e8 00 00 restore
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
200eed0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200eed4: 92 10 20 00 clr %o1
200eed8: 7f ff e9 9c call 2009548 <rtems_semaphore_obtain>
200eedc: 94 10 20 00 clr %o2
200eee0: 80 a2 20 00 cmp %o0, 0
200eee4: 12 80 00 6c bne 200f094 <pipe_write+0x1e0> <== NEVER TAKEN
200eee8: 01 00 00 00 nop
return -EINTR;
if (pipe->Readers == 0) {
200eeec: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200eef0: 80 a0 60 00 cmp %g1, 0
200eef4: 22 80 00 54 be,a 200f044 <pipe_write+0x190>
200eef8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
200eefc: f8 07 60 04 ld [ %i5 + 4 ], %i4
200ef00: 80 a6 80 1c cmp %i2, %i4
200ef04: 08 80 00 5b bleu 200f070 <pipe_write+0x1bc> <== ALWAYS TAKEN
200ef08: a0 10 20 01 mov 1, %l0
200ef0c: a2 10 20 00 clr %l1
200ef10: b0 10 20 00 clr %i0
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
200ef14: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200ef18: 84 27 00 01 sub %i4, %g1, %g2
200ef1c: 80 a0 80 10 cmp %g2, %l0
200ef20: 1a 80 00 27 bcc 200efbc <pipe_write+0x108>
200ef24: 86 26 80 11 sub %i2, %l1, %g3
if (LIBIO_NODELAY(iop)) {
200ef28: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
200ef2c: 80 88 60 01 btst 1, %g1
200ef30: 32 80 00 53 bne,a 200f07c <pipe_write+0x1c8>
200ef34: 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 ++;
200ef38: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
200ef3c: 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 ++;
200ef40: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200ef44: 7f ff e9 d0 call 2009684 <rtems_semaphore_release>
200ef48: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
200ef4c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200ef50: 40 00 05 58 call 20104b0 <rtems_barrier_wait>
200ef54: 92 10 20 00 clr %o1
200ef58: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200ef5c: 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))
200ef60: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200ef64: 92 10 20 00 clr %o1
200ef68: 94 10 20 00 clr %o2
200ef6c: 7f ff e9 77 call 2009548 <rtems_semaphore_obtain>
200ef70: b8 0f 3f fc and %i4, -4, %i4
200ef74: 80 a2 20 00 cmp %o0, 0
200ef78: 12 80 00 45 bne 200f08c <pipe_write+0x1d8> <== NEVER TAKEN
200ef7c: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
200ef80: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200ef84: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200ef88: 12 80 00 3d bne 200f07c <pipe_write+0x1c8> <== NEVER TAKEN
200ef8c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
200ef90: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200ef94: 80 a0 60 00 cmp %g1, 0
200ef98: 22 80 00 2b be,a 200f044 <pipe_write+0x190> <== NEVER TAKEN
200ef9c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
200efa0: f8 07 60 04 ld [ %i5 + 4 ], %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) {
200efa4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200efa8: 84 27 00 01 sub %i4, %g1, %g2
200efac: 80 a0 80 10 cmp %g2, %l0
200efb0: 2a bf ff df bcs,a 200ef2c <pipe_write+0x78> <== NEVER TAKEN
200efb4: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1 <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
200efb8: 86 26 80 11 sub %i2, %l1, %g3
200efbc: 80 a0 80 03 cmp %g2, %g3
200efc0: 08 80 00 03 bleu 200efcc <pipe_write+0x118>
200efc4: a0 10 00 02 mov %g2, %l0
200efc8: a0 10 00 03 mov %g3, %l0
chunk1 = pipe->Size - PIPE_WSTART(pipe);
200efcc: d0 07 60 08 ld [ %i5 + 8 ], %o0
200efd0: 92 10 00 1c mov %i4, %o1
200efd4: 40 00 41 96 call 201f62c <.urem>
200efd8: 90 00 40 08 add %g1, %o0, %o0
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
200efdc: c2 07 40 00 ld [ %i5 ], %g1
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
200efe0: b8 27 00 08 sub %i4, %o0, %i4
if (chunk > chunk1) {
200efe4: 80 a4 00 1c cmp %l0, %i4
200efe8: 04 80 00 2d ble 200f09c <pipe_write+0x1e8>
200efec: 92 06 40 11 add %i1, %l1, %o1
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
200eff0: 94 10 00 1c mov %i4, %o2
200eff4: 40 00 11 b1 call 20136b8 <memcpy>
200eff8: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
200effc: d0 07 40 00 ld [ %i5 ], %o0
200f000: 92 07 00 11 add %i4, %l1, %o1
200f004: 94 24 00 1c sub %l0, %i4, %o2
200f008: 40 00 11 ac call 20136b8 <memcpy>
200f00c: 92 06 40 09 add %i1, %o1, %o1
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
200f010: c4 07 60 0c ld [ %i5 + 0xc ], %g2
if (pipe->waitingReaders > 0)
200f014: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
200f018: 84 00 80 10 add %g2, %l0, %g2
if (pipe->waitingReaders > 0)
200f01c: 80 a0 60 00 cmp %g1, 0
200f020: 12 80 00 24 bne 200f0b0 <pipe_write+0x1fc>
200f024: c4 27 60 0c st %g2, [ %i5 + 0xc ]
PIPE_WAKEUPREADERS(pipe);
written += chunk;
200f028: b0 06 00 10 add %i0, %l0, %i0
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
200f02c: 80 a6 80 18 cmp %i2, %i0
200f030: 08 80 00 12 bleu 200f078 <pipe_write+0x1c4> <== ALWAYS TAKEN
200f034: a2 10 00 18 mov %i0, %l1
200f038: f8 07 60 04 ld [ %i5 + 4 ], %i4 <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
200f03c: 10 bf ff b6 b 200ef14 <pipe_write+0x60> <== NOT EXECUTED
200f040: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
}
out_locked:
PIPE_UNLOCK(pipe);
200f044: 7f ff e9 90 call 2009684 <rtems_semaphore_release>
200f048: b8 10 3f e0 mov -32, %i4
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
200f04c: 40 00 01 49 call 200f570 <getpid>
200f050: 01 00 00 00 nop
200f054: 40 00 02 ce call 200fb8c <kill>
200f058: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
200f05c: 80 a6 20 00 cmp %i0, 0
200f060: 14 bf ff 9a bg 200eec8 <pipe_write+0x14>
200f064: 01 00 00 00 nop
200f068: 81 c7 e0 08 ret
200f06c: 91 e8 00 1c restore %g0, %i4, %o0
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
200f070: 10 bf ff a7 b 200ef0c <pipe_write+0x58>
200f074: a0 10 00 1a mov %i2, %l0
while (written < count) {
200f078: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
200f07c: 7f ff e9 82 call 2009684 <rtems_semaphore_release>
200f080: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
200f084: 10 bf ff f7 b 200f060 <pipe_write+0x1ac>
200f088: 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;
200f08c: 10 bf ff f4 b 200f05c <pipe_write+0x1a8> <== NOT EXECUTED
200f090: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
200f094: 81 c7 e0 08 ret <== NOT EXECUTED
200f098: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
200f09c: 90 00 40 08 add %g1, %o0, %o0
200f0a0: 40 00 11 86 call 20136b8 <memcpy>
200f0a4: 94 10 00 10 mov %l0, %o2
pipe->Length += chunk;
200f0a8: 10 bf ff db b 200f014 <pipe_write+0x160>
200f0ac: c4 07 60 0c ld [ %i5 + 0xc ], %g2
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
200f0b0: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200f0b4: 40 00 04 e7 call 2010450 <rtems_barrier_release>
200f0b8: 92 07 bf fc add %fp, -4, %o1
written += chunk;
200f0bc: 10 bf ff dc b 200f02c <pipe_write+0x178>
200f0c0: b0 06 00 10 add %i0, %l0, %i0
02007d60 <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
2007d60: 05 00 80 94 sethi %hi(0x2025000), %g2
2007d64: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 20252d0 <rtems_malloc_statistics>
2007d68: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2007d6c: 86 00 e0 01 inc %g3
2007d70: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
2007d74: 84 02 7f ff add %o1, -1, %g2
2007d78: 80 88 80 09 btst %g2, %o1
2007d7c: 02 80 00 04 be 2007d8c <posix_memalign+0x2c> <== ALWAYS TAKEN
2007d80: 80 a2 60 03 cmp %o1, 3
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
2007d84: 81 c3 e0 08 retl
2007d88: 90 10 20 16 mov 0x16, %o0
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
2007d8c: 08 bf ff fe bleu 2007d84 <posix_memalign+0x24>
2007d90: 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 );
2007d94: 82 13 c0 00 mov %o7, %g1
2007d98: 40 00 00 89 call 2007fbc <rtems_memalign>
2007d9c: 9e 10 40 00 mov %g1, %o7
0200c614 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
200c614: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
200c618: 80 a0 60 00 cmp %g1, 0
200c61c: 02 80 00 06 be 200c634 <pthread_attr_setschedpolicy+0x20>
200c620: 90 10 20 16 mov 0x16, %o0
200c624: c4 00 40 00 ld [ %g1 ], %g2
200c628: 80 a0 a0 00 cmp %g2, 0
200c62c: 12 80 00 04 bne 200c63c <pthread_attr_setschedpolicy+0x28>
200c630: 80 a2 60 04 cmp %o1, 4
return 0;
default:
return ENOTSUP;
}
}
200c634: 81 c3 e0 08 retl
200c638: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
200c63c: 18 80 00 09 bgu 200c660 <pthread_attr_setschedpolicy+0x4c>
200c640: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
200c644: 85 28 80 09 sll %g2, %o1, %g2
200c648: 80 88 a0 17 btst 0x17, %g2
200c64c: 02 80 00 05 be 200c660 <pthread_attr_setschedpolicy+0x4c> <== NEVER TAKEN
200c650: 01 00 00 00 nop
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
200c654: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
return 0;
200c658: 81 c3 e0 08 retl
200c65c: 90 10 20 00 clr %o0
default:
return ENOTSUP;
}
}
200c660: 81 c3 e0 08 retl
200c664: 90 10 20 86 mov 0x86, %o0
02007d98 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
2007d98: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
2007d9c: 80 a6 20 00 cmp %i0, 0
2007da0: 02 80 00 04 be 2007db0 <pthread_barrier_init+0x18>
2007da4: 80 a6 a0 00 cmp %i2, 0
return EINVAL;
if ( count == 0 )
2007da8: 12 80 00 04 bne 2007db8 <pthread_barrier_init+0x20>
2007dac: 80 a6 60 00 cmp %i1, 0
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
_Thread_Enable_dispatch();
return 0;
}
2007db0: 81 c7 e0 08 ret
2007db4: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007db8: 02 80 00 23 be 2007e44 <pthread_barrier_init+0xac>
2007dbc: 90 07 bf f8 add %fp, -8, %o0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
2007dc0: c2 06 40 00 ld [ %i1 ], %g1
2007dc4: 80 a0 60 00 cmp %g1, 0
2007dc8: 02 bf ff fa be 2007db0 <pthread_barrier_init+0x18>
2007dcc: 01 00 00 00 nop
return EINVAL;
switch ( the_attr->process_shared ) {
2007dd0: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007dd4: 80 a0 60 00 cmp %g1, 0
2007dd8: 12 bf ff f6 bne 2007db0 <pthread_barrier_init+0x18> <== NEVER TAKEN
2007ddc: 03 00 80 7e sethi %hi(0x201f800), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2007de0: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201f970 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
2007de4: c0 27 bf f0 clr [ %fp + -16 ]
++level;
2007de8: 84 00 a0 01 inc %g2
the_attributes.maximum_count = count;
2007dec: f4 27 bf f4 st %i2, [ %fp + -12 ]
_Thread_Dispatch_disable_level = level;
2007df0: c4 20 61 70 st %g2, [ %g1 + 0x170 ]
* 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 *)
2007df4: 39 00 80 7f sethi %hi(0x201fc00), %i4
2007df8: 40 00 09 00 call 200a1f8 <_Objects_Allocate>
2007dfc: 90 17 21 04 or %i4, 0x104, %o0 ! 201fd04 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
2007e00: ba 92 20 00 orcc %o0, 0, %i5
2007e04: 02 80 00 14 be 2007e54 <pthread_barrier_init+0xbc>
2007e08: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
2007e0c: 40 00 06 49 call 2009730 <_CORE_barrier_Initialize>
2007e10: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007e14: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007e18: b8 17 21 04 or %i4, 0x104, %i4
2007e1c: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007e20: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007e24: 85 28 a0 02 sll %g2, 2, %g2
2007e28: fa 20 c0 02 st %i5, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
2007e2c: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
2007e30: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
2007e34: 40 00 0e 3d call 200b728 <_Thread_Enable_dispatch>
2007e38: b0 10 20 00 clr %i0
2007e3c: 81 c7 e0 08 ret
2007e40: 81 e8 00 00 restore
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
2007e44: 7f ff ff 9c call 2007cb4 <pthread_barrierattr_init>
2007e48: 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 )
2007e4c: 10 bf ff de b 2007dc4 <pthread_barrier_init+0x2c>
2007e50: c2 06 40 00 ld [ %i1 ], %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
2007e54: 40 00 0e 35 call 200b728 <_Thread_Enable_dispatch>
2007e58: b0 10 20 0b mov 0xb, %i0
2007e5c: 81 c7 e0 08 ret
2007e60: 81 e8 00 00 restore
0200762c <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
200762c: 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 )
2007630: 80 a6 20 00 cmp %i0, 0
2007634: 02 80 00 13 be 2007680 <pthread_cleanup_push+0x54>
2007638: 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)
{
uint32_t level = _Thread_Dispatch_disable_level;
200763c: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201f170 <_Thread_Dispatch_disable_level>
++level;
2007640: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2007644: c4 20 61 70 st %g2, [ %g1 + 0x170 ]
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
2007648: 40 00 13 1b call 200c2b4 <_Workspace_Allocate>
200764c: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
2007650: 80 a2 20 00 cmp %o0, 0
2007654: 02 80 00 09 be 2007678 <pthread_cleanup_push+0x4c> <== NEVER TAKEN
2007658: 03 00 80 7d sethi %hi(0x201f400), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
200765c: c2 00 62 a0 ld [ %g1 + 0x2a0 ], %g1 ! 201f6a0 <_Per_CPU_Information+0x10>
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
2007660: 92 10 00 08 mov %o0, %o1
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
if ( handler ) {
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
2007664: c2 00 61 5c ld [ %g1 + 0x15c ], %g1
handler->routine = routine;
2007668: f0 22 20 08 st %i0, [ %o0 + 8 ]
handler->arg = arg;
200766c: f2 22 20 0c st %i1, [ %o0 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
2007670: 40 00 06 79 call 2009054 <_Chain_Append>
2007674: 90 00 60 e4 add %g1, 0xe4, %o0
}
_Thread_Enable_dispatch();
2007678: 40 00 0e 7c call 200b068 <_Thread_Enable_dispatch>
200767c: 81 e8 00 00 restore
2007680: 81 c7 e0 08 ret
2007684: 81 e8 00 00 restore
020085cc <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
20085cc: 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;
20085d0: 80 a6 60 00 cmp %i1, 0
20085d4: 22 80 00 27 be,a 2008670 <pthread_cond_init+0xa4>
20085d8: 33 00 80 7a sethi %hi(0x201e800), %i1
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
20085dc: c4 06 60 04 ld [ %i1 + 4 ], %g2 ! 201e804 <rtems_status_assoc+0xcc>
20085e0: 80 a0 a0 01 cmp %g2, 1
20085e4: 02 80 00 06 be 20085fc <pthread_cond_init+0x30> <== NEVER TAKEN
20085e8: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
20085ec: c4 06 40 00 ld [ %i1 ], %g2
20085f0: 80 a0 a0 00 cmp %g2, 0
20085f4: 32 80 00 04 bne,a 2008604 <pthread_cond_init+0x38>
20085f8: 03 00 80 82 sethi %hi(0x2020800), %g1
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
20085fc: 81 c7 e0 08 ret
2008600: 91 e8 00 01 restore %g0, %g1, %o0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2008604: c4 00 63 70 ld [ %g1 + 0x370 ], %g2
++level;
2008608: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
200860c: c4 20 63 70 st %g2, [ %g1 + 0x370 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
2008610: 39 00 80 83 sethi %hi(0x2020c00), %i4
2008614: 40 00 0a b0 call 200b0d4 <_Objects_Allocate>
2008618: 90 17 23 9c or %i4, 0x39c, %o0 ! 2020f9c <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
200861c: ba 92 20 00 orcc %o0, 0, %i5
2008620: 02 80 00 16 be 2008678 <pthread_cond_init+0xac>
2008624: 90 07 60 18 add %i5, 0x18, %o0
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
2008628: c2 06 60 04 ld [ %i1 + 4 ], %g1
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
200862c: 92 10 20 00 clr %o1
2008630: 15 04 00 02 sethi %hi(0x10000800), %o2
2008634: 96 10 20 74 mov 0x74, %o3
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
2008638: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
200863c: 40 00 12 22 call 200cec4 <_Thread_queue_Initialize>
2008640: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008644: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008648: b8 17 23 9c or %i4, 0x39c, %i4
200864c: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008650: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008654: 85 28 a0 02 sll %g2, 2, %g2
2008658: fa 20 c0 02 st %i5, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
200865c: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
2008660: 40 00 0f e9 call 200c604 <_Thread_Enable_dispatch>
2008664: c2 26 00 00 st %g1, [ %i0 ]
return 0;
2008668: 10 bf ff e5 b 20085fc <pthread_cond_init+0x30>
200866c: 82 10 20 00 clr %g1
{
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
2008670: 10 bf ff db b 20085dc <pthread_cond_init+0x10>
2008674: b2 16 61 ec or %i1, 0x1ec, %i1
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
2008678: 40 00 0f e3 call 200c604 <_Thread_Enable_dispatch>
200867c: 01 00 00 00 nop
return ENOMEM;
2008680: 10 bf ff df b 20085fc <pthread_cond_init+0x30>
2008684: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
02008430 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
2008430: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
2008434: 80 a0 60 00 cmp %g1, 0
2008438: 02 80 00 06 be 2008450 <pthread_condattr_destroy+0x20>
200843c: 90 10 20 16 mov 0x16, %o0
2008440: c4 00 40 00 ld [ %g1 ], %g2
2008444: 80 a0 a0 00 cmp %g2, 0
2008448: 32 80 00 04 bne,a 2008458 <pthread_condattr_destroy+0x28><== ALWAYS TAKEN
200844c: c0 20 40 00 clr [ %g1 ]
return EINVAL;
attr->is_initialized = false;
return 0;
}
2008450: 81 c3 e0 08 retl
2008454: 01 00 00 00 nop
2008458: 81 c3 e0 08 retl
200845c: 90 10 20 00 clr %o0 ! 0 <PROM_START>
02007ad8 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
2007ad8: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
2007adc: 80 a6 a0 00 cmp %i2, 0
2007ae0: 02 80 00 0a be 2007b08 <pthread_create+0x30>
2007ae4: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
2007ae8: 80 a6 60 00 cmp %i1, 0
2007aec: 22 80 00 63 be,a 2007c78 <pthread_create+0x1a0>
2007af0: 33 00 80 84 sethi %hi(0x2021000), %i1
if ( !the_attr->is_initialized )
2007af4: c2 06 40 00 ld [ %i1 ], %g1
2007af8: 80 a0 60 00 cmp %g1, 0
2007afc: 32 80 00 05 bne,a 2007b10 <pthread_create+0x38>
2007b00: c2 06 60 04 ld [ %i1 + 4 ], %g1
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
2007b04: ba 10 20 16 mov 0x16, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
2007b08: 81 c7 e0 08 ret
2007b0c: 91 e8 00 1d restore %g0, %i5, %o0
* 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) )
2007b10: 80 a0 60 00 cmp %g1, 0
2007b14: 02 80 00 07 be 2007b30 <pthread_create+0x58>
2007b18: 03 00 80 89 sethi %hi(0x2022400), %g1
2007b1c: c4 06 60 08 ld [ %i1 + 8 ], %g2
2007b20: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1
2007b24: 80 a0 80 01 cmp %g2, %g1
2007b28: 0a bf ff f8 bcs 2007b08 <pthread_create+0x30>
2007b2c: ba 10 20 16 mov 0x16, %i5
* 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 ) {
2007b30: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2007b34: 80 a0 60 01 cmp %g1, 1
2007b38: 02 80 00 52 be 2007c80 <pthread_create+0x1a8>
2007b3c: 80 a0 60 02 cmp %g1, 2
2007b40: 32 bf ff f2 bne,a 2007b08 <pthread_create+0x30>
2007b44: ba 10 20 16 mov 0x16, %i5
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
2007b48: da 06 60 18 ld [ %i1 + 0x18 ], %o5
2007b4c: de 06 60 1c ld [ %i1 + 0x1c ], %o7
2007b50: fa 06 60 20 ld [ %i1 + 0x20 ], %i5
2007b54: c8 06 60 24 ld [ %i1 + 0x24 ], %g4
2007b58: c6 06 60 28 ld [ %i1 + 0x28 ], %g3
2007b5c: c4 06 60 2c ld [ %i1 + 0x2c ], %g2
2007b60: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
2007b64: f8 06 60 14 ld [ %i1 + 0x14 ], %i4
schedparam = the_attr->schedparam;
2007b68: da 27 bf e4 st %o5, [ %fp + -28 ]
2007b6c: de 27 bf e8 st %o7, [ %fp + -24 ]
2007b70: fa 27 bf ec st %i5, [ %fp + -20 ]
2007b74: c8 27 bf f0 st %g4, [ %fp + -16 ]
2007b78: c6 27 bf f4 st %g3, [ %fp + -12 ]
2007b7c: c4 27 bf f8 st %g2, [ %fp + -8 ]
2007b80: c2 27 bf fc st %g1, [ %fp + -4 ]
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
2007b84: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2007b88: 80 a0 60 00 cmp %g1, 0
2007b8c: 12 bf ff df bne 2007b08 <pthread_create+0x30>
2007b90: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
2007b94: 40 00 1a bf call 200e690 <_POSIX_Priority_Is_valid>
2007b98: d0 07 bf e4 ld [ %fp + -28 ], %o0
2007b9c: 80 8a 20 ff btst 0xff, %o0
2007ba0: 02 bf ff da be 2007b08 <pthread_create+0x30> <== NEVER TAKEN
2007ba4: ba 10 20 16 mov 0x16, %i5
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
2007ba8: 03 00 80 89 sethi %hi(0x2022400), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
2007bac: e0 07 bf e4 ld [ %fp + -28 ], %l0
2007bb0: e8 08 61 bc ldub [ %g1 + 0x1bc ], %l4
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
2007bb4: 90 10 00 1c mov %i4, %o0
2007bb8: 92 07 bf e4 add %fp, -28, %o1
2007bbc: 94 07 bf dc add %fp, -36, %o2
2007bc0: 40 00 1a c1 call 200e6c4 <_POSIX_Thread_Translate_sched_param>
2007bc4: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
2007bc8: ba 92 20 00 orcc %o0, 0, %i5
2007bcc: 12 bf ff cf bne 2007b08 <pthread_create+0x30>
2007bd0: 25 00 80 8c sethi %hi(0x2023000), %l2
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
2007bd4: d0 04 a2 d4 ld [ %l2 + 0x2d4 ], %o0 ! 20232d4 <_RTEMS_Allocator_Mutex>
2007bd8: 40 00 06 ab call 2009684 <_API_Mutex_Lock>
2007bdc: 27 00 80 8d sethi %hi(0x2023400), %l3
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
2007be0: 40 00 09 82 call 200a1e8 <_Objects_Allocate>
2007be4: 90 14 e0 64 or %l3, 0x64, %o0 ! 2023464 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
2007be8: a2 92 20 00 orcc %o0, 0, %l1
2007bec: 02 80 00 1f be 2007c68 <pthread_create+0x190>
2007bf0: 05 00 80 89 sethi %hi(0x2022400), %g2
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
2007bf4: c2 06 60 08 ld [ %i1 + 8 ], %g1
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
2007bf8: d6 00 a1 c0 ld [ %g2 + 0x1c0 ], %o3
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
2007bfc: c0 27 bf d4 clr [ %fp + -44 ]
2007c00: 97 2a e0 01 sll %o3, 1, %o3
2007c04: 80 a2 c0 01 cmp %o3, %g1
2007c08: 1a 80 00 03 bcc 2007c14 <pthread_create+0x13c>
2007c0c: d4 06 60 04 ld [ %i1 + 4 ], %o2
2007c10: 96 10 00 01 mov %g1, %o3
2007c14: c2 07 bf dc ld [ %fp + -36 ], %g1
2007c18: 9a 0d 20 ff and %l4, 0xff, %o5
2007c1c: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
2007c20: 82 10 20 01 mov 1, %g1
2007c24: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2007c28: c2 07 bf e0 ld [ %fp + -32 ], %g1
2007c2c: c0 23 a0 68 clr [ %sp + 0x68 ]
2007c30: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2007c34: 82 07 bf d4 add %fp, -44, %g1
2007c38: 90 14 e0 64 or %l3, 0x64, %o0
2007c3c: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2007c40: 92 10 00 11 mov %l1, %o1
2007c44: 98 10 20 01 mov 1, %o4
2007c48: 40 00 0e eb call 200b7f4 <_Thread_Initialize>
2007c4c: 9a 23 40 10 sub %o5, %l0, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
2007c50: 80 8a 20 ff btst 0xff, %o0
2007c54: 12 80 00 1e bne 2007ccc <pthread_create+0x1f4>
2007c58: 11 00 80 8d sethi %hi(0x2023400), %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
2007c5c: 92 10 00 11 mov %l1, %o1
2007c60: 40 00 0a 5a call 200a5c8 <_Objects_Free>
2007c64: 90 12 20 64 or %o0, 0x64, %o0
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
2007c68: d0 04 a2 d4 ld [ %l2 + 0x2d4 ], %o0
2007c6c: 40 00 06 9b call 20096d8 <_API_Mutex_Unlock>
2007c70: ba 10 20 0b mov 0xb, %i5
2007c74: 30 bf ff a5 b,a 2007b08 <pthread_create+0x30>
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
2007c78: 10 bf ff 9f b 2007af4 <pthread_create+0x1c>
2007c7c: b2 16 60 c4 or %i1, 0xc4, %i1
* 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 ];
2007c80: 03 00 80 8d sethi %hi(0x2023400), %g1
2007c84: c2 00 63 80 ld [ %g1 + 0x380 ], %g1 ! 2023780 <_Per_CPU_Information+0x10>
2007c88: c2 00 61 5c ld [ %g1 + 0x15c ], %g1
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
2007c8c: d8 00 60 88 ld [ %g1 + 0x88 ], %o4
2007c90: da 00 60 8c ld [ %g1 + 0x8c ], %o5
2007c94: de 00 60 90 ld [ %g1 + 0x90 ], %o7
2007c98: fa 00 60 94 ld [ %g1 + 0x94 ], %i5
2007c9c: c8 00 60 98 ld [ %g1 + 0x98 ], %g4
2007ca0: c6 00 60 9c ld [ %g1 + 0x9c ], %g3
2007ca4: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
schedpolicy = api->schedpolicy;
2007ca8: f8 00 60 84 ld [ %g1 + 0x84 ], %i4
schedparam = api->schedparam;
2007cac: d8 27 bf e4 st %o4, [ %fp + -28 ]
2007cb0: da 27 bf e8 st %o5, [ %fp + -24 ]
2007cb4: de 27 bf ec st %o7, [ %fp + -20 ]
2007cb8: fa 27 bf f0 st %i5, [ %fp + -16 ]
2007cbc: c8 27 bf f4 st %g4, [ %fp + -12 ]
2007cc0: c6 27 bf f8 st %g3, [ %fp + -8 ]
break;
2007cc4: 10 bf ff b0 b 2007b84 <pthread_create+0xac>
2007cc8: c4 27 bf fc st %g2, [ %fp + -4 ]
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
2007ccc: e0 04 61 5c ld [ %l1 + 0x15c ], %l0
api->Attributes = *the_attr;
2007cd0: 92 10 00 19 mov %i1, %o1
2007cd4: 94 10 20 40 mov 0x40, %o2
2007cd8: 40 00 27 83 call 2011ae4 <memcpy>
2007cdc: 90 10 00 10 mov %l0, %o0
api->detachstate = the_attr->detachstate;
2007ce0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
2007ce4: 92 07 bf e4 add %fp, -28, %o1
2007ce8: 94 10 20 1c mov 0x1c, %o2
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
2007cec: c2 24 20 40 st %g1, [ %l0 + 0x40 ]
api->schedpolicy = schedpolicy;
2007cf0: f8 24 20 84 st %i4, [ %l0 + 0x84 ]
api->schedparam = schedparam;
2007cf4: 40 00 27 7c call 2011ae4 <memcpy>
2007cf8: 90 04 20 88 add %l0, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
2007cfc: 90 10 00 11 mov %l1, %o0
2007d00: 92 10 20 01 mov 1, %o1
2007d04: 94 10 00 1a mov %i2, %o2
2007d08: 96 10 00 1b mov %i3, %o3
2007d0c: 40 00 11 32 call 200c1d4 <_Thread_Start>
2007d10: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
2007d14: 80 a7 20 04 cmp %i4, 4
2007d18: 02 80 00 07 be 2007d34 <pthread_create+0x25c>
2007d1c: 01 00 00 00 nop
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
2007d20: c2 04 60 08 ld [ %l1 + 8 ], %g1
_RTEMS_Unlock_allocator();
2007d24: d0 04 a2 d4 ld [ %l2 + 0x2d4 ], %o0
2007d28: 40 00 06 6c call 20096d8 <_API_Mutex_Unlock>
2007d2c: c2 26 00 00 st %g1, [ %i0 ]
2007d30: 30 bf ff 76 b,a 2007b08 <pthread_create+0x30>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
2007d34: 40 00 11 52 call 200c27c <_Timespec_To_ticks>
2007d38: 90 04 20 90 add %l0, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007d3c: 92 04 20 a8 add %l0, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2007d40: d0 24 20 b4 st %o0, [ %l0 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007d44: 11 00 80 8c sethi %hi(0x2023000), %o0
2007d48: 40 00 12 07 call 200c564 <_Watchdog_Insert>
2007d4c: 90 12 22 ec or %o0, 0x2ec, %o0 ! 20232ec <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
2007d50: 10 bf ff f5 b 2007d24 <pthread_create+0x24c>
2007d54: c2 04 60 08 ld [ %l1 + 8 ], %g1
0201b138 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
201b138: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
201b13c: 80 a6 60 00 cmp %i1, 0
201b140: 02 80 00 31 be 201b204 <pthread_kill+0xcc>
201b144: b8 06 7f ff add %i1, -1, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201b148: 80 a7 20 1f cmp %i4, 0x1f
201b14c: 18 80 00 2e bgu 201b204 <pthread_kill+0xcc>
201b150: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
201b154: 7f ff bd 95 call 200a7a8 <_Thread_Get>
201b158: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
201b15c: c2 07 bf fc ld [ %fp + -4 ], %g1
201b160: 80 a0 60 00 cmp %g1, 0
201b164: 12 80 00 2e bne 201b21c <pthread_kill+0xe4> <== NEVER TAKEN
201b168: ba 10 00 08 mov %o0, %i5
201b16c: 11 00 80 76 sethi %hi(0x201d800), %o0
201b170: 7f ff b4 f7 call 200854c <_API_extensions_Add_post_switch>
201b174: 90 12 20 f4 or %o0, 0xf4, %o0 ! 201d8f4 <_POSIX_signals_Post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
201b178: 83 2e 60 02 sll %i1, 2, %g1
201b17c: 85 2e 60 04 sll %i1, 4, %g2
201b180: 84 20 80 01 sub %g2, %g1, %g2
201b184: 03 00 80 7a sethi %hi(0x201e800), %g1
201b188: 82 10 60 a0 or %g1, 0xa0, %g1 ! 201e8a0 <_POSIX_signals_Vectors>
201b18c: 82 00 40 02 add %g1, %g2, %g1
201b190: c4 00 60 08 ld [ %g1 + 8 ], %g2
201b194: 80 a0 a0 01 cmp %g2, 1
201b198: 02 80 00 15 be 201b1ec <pthread_kill+0xb4>
201b19c: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201b1a0: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
201b1a4: b6 10 20 01 mov 1, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201b1a8: 90 10 00 1d mov %i5, %o0
201b1ac: b9 2e c0 1c sll %i3, %i4, %i4
201b1b0: 92 10 00 19 mov %i1, %o1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201b1b4: b8 10 80 1c or %g2, %i4, %i4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201b1b8: 94 10 20 00 clr %o2
201b1bc: 7f ff ff 86 call 201afd4 <_POSIX_signals_Unblock_thread>
201b1c0: f8 20 60 d4 st %i4, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201b1c4: 03 00 80 7a sethi %hi(0x201e800), %g1
201b1c8: 82 10 60 40 or %g1, 0x40, %g1 ! 201e840 <_Per_CPU_Information>
201b1cc: c4 00 60 08 ld [ %g1 + 8 ], %g2
201b1d0: 80 a0 a0 00 cmp %g2, 0
201b1d4: 02 80 00 06 be 201b1ec <pthread_kill+0xb4>
201b1d8: 01 00 00 00 nop
201b1dc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
201b1e0: 80 a7 40 02 cmp %i5, %g2
201b1e4: 02 80 00 06 be 201b1fc <pthread_kill+0xc4>
201b1e8: 01 00 00 00 nop
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
_Thread_Enable_dispatch();
201b1ec: 7f ff bd 63 call 200a778 <_Thread_Enable_dispatch>
201b1f0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
201b1f4: 81 c7 e0 08 ret
201b1f8: 81 e8 00 00 restore
api->signals_pending |= signo_to_mask( sig );
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
201b1fc: f6 28 60 0c stb %i3, [ %g1 + 0xc ]
201b200: 30 bf ff fb b,a 201b1ec <pthread_kill+0xb4>
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
201b204: 7f ff d4 75 call 20103d8 <__errno>
201b208: b0 10 3f ff mov -1, %i0
201b20c: 82 10 20 16 mov 0x16, %g1
201b210: c2 22 00 00 st %g1, [ %o0 ]
201b214: 81 c7 e0 08 ret
201b218: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
201b21c: 7f ff d4 6f call 20103d8 <__errno> <== NOT EXECUTED
201b220: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201b224: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
201b228: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
201b22c: 81 c7 e0 08 ret <== NOT EXECUTED
201b230: 81 e8 00 00 restore <== NOT EXECUTED
02009b18 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
2009b18: 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 );
2009b1c: 90 10 00 19 mov %i1, %o0
2009b20: 40 00 00 38 call 2009c00 <_POSIX_Absolute_timeout_to_ticks>
2009b24: 92 07 bf fc add %fp, -4, %o1
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
2009b28: d4 07 bf fc ld [ %fp + -4 ], %o2
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
2009b2c: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
2009b30: 80 a7 60 03 cmp %i5, 3
2009b34: 02 80 00 0c be 2009b64 <pthread_mutex_timedlock+0x4c>
2009b38: 90 10 00 18 mov %i0, %o0
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
2009b3c: 7f ff ff bd call 2009a30 <_POSIX_Mutex_Lock_support>
2009b40: 92 10 20 00 clr %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) ) {
2009b44: 80 a2 20 10 cmp %o0, 0x10
2009b48: 12 80 00 0a bne 2009b70 <pthread_mutex_timedlock+0x58>
2009b4c: b0 10 00 08 mov %o0, %i0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2009b50: 80 a7 60 00 cmp %i5, 0
2009b54: 12 80 00 09 bne 2009b78 <pthread_mutex_timedlock+0x60> <== ALWAYS TAKEN
2009b58: ba 07 7f ff add %i5, -1, %i5
return EINVAL;
2009b5c: 81 c7 e0 08 ret <== NOT EXECUTED
2009b60: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
2009b64: 7f ff ff b3 call 2009a30 <_POSIX_Mutex_Lock_support>
2009b68: 92 10 20 01 mov 1, %o1
2009b6c: b0 10 00 08 mov %o0, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
2009b70: 81 c7 e0 08 ret
2009b74: 81 e8 00 00 restore
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2009b78: 80 a7 60 01 cmp %i5, 1
2009b7c: 18 bf ff fd bgu 2009b70 <pthread_mutex_timedlock+0x58> <== NEVER TAKEN
2009b80: 01 00 00 00 nop
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
2009b84: 81 c7 e0 08 ret
2009b88: 91 e8 20 74 restore %g0, 0x74, %o0
02007358 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
2007358: 82 10 00 08 mov %o0, %g1
if ( !attr )
200735c: 80 a0 60 00 cmp %g1, 0
2007360: 02 80 00 06 be 2007378 <pthread_mutexattr_gettype+0x20>
2007364: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
2007368: c4 00 40 00 ld [ %g1 ], %g2
200736c: 80 a0 a0 00 cmp %g2, 0
2007370: 12 80 00 04 bne 2007380 <pthread_mutexattr_gettype+0x28>
2007374: 80 a2 60 00 cmp %o1, 0
if ( !type )
return EINVAL;
*type = attr->type;
return 0;
}
2007378: 81 c3 e0 08 retl
200737c: 01 00 00 00 nop
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
2007380: 02 bf ff fe be 2007378 <pthread_mutexattr_gettype+0x20> <== NEVER TAKEN
2007384: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
2007388: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
200738c: 90 10 20 00 clr %o0
}
2007390: 81 c3 e0 08 retl
2007394: c2 22 40 00 st %g1, [ %o1 ]
020096e4 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
20096e4: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
20096e8: 80 a0 60 00 cmp %g1, 0
20096ec: 02 80 00 06 be 2009704 <pthread_mutexattr_setpshared+0x20>
20096f0: 90 10 20 16 mov 0x16, %o0
20096f4: c4 00 40 00 ld [ %g1 ], %g2
20096f8: 80 a0 a0 00 cmp %g2, 0
20096fc: 12 80 00 04 bne 200970c <pthread_mutexattr_setpshared+0x28>
2009700: 80 a2 60 01 cmp %o1, 1
return 0;
default:
return EINVAL;
}
}
2009704: 81 c3 e0 08 retl
2009708: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
200970c: 18 bf ff fe bgu 2009704 <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
2009710: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
2009714: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
default:
return EINVAL;
}
}
2009718: 81 c3 e0 08 retl
200971c: 90 10 20 00 clr %o0
020073ec <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
20073ec: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
20073f0: 80 a0 60 00 cmp %g1, 0
20073f4: 02 80 00 06 be 200740c <pthread_mutexattr_settype+0x20>
20073f8: 90 10 20 16 mov 0x16, %o0
20073fc: c4 00 40 00 ld [ %g1 ], %g2
2007400: 80 a0 a0 00 cmp %g2, 0
2007404: 12 80 00 04 bne 2007414 <pthread_mutexattr_settype+0x28> <== ALWAYS TAKEN
2007408: 80 a2 60 03 cmp %o1, 3
return 0;
default:
return EINVAL;
}
}
200740c: 81 c3 e0 08 retl
2007410: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( type ) {
2007414: 18 bf ff fe bgu 200740c <pthread_mutexattr_settype+0x20>
2007418: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
200741c: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
default:
return EINVAL;
}
}
2007420: 81 c3 e0 08 retl
2007424: 90 10 20 00 clr %o0
0200820c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
200820c: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
2008210: 80 a6 60 00 cmp %i1, 0
2008214: 12 80 00 05 bne 2008228 <pthread_once+0x1c>
2008218: 80 a6 20 00 cmp %i0, 0
return EINVAL;
200821c: 82 10 20 16 mov 0x16, %g1
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
2008220: 81 c7 e0 08 ret
2008224: 91 e8 00 01 restore %g0, %g1, %o0
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
2008228: 22 bf ff fe be,a 2008220 <pthread_once+0x14>
200822c: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !once_control->init_executed ) {
2008230: c4 06 20 04 ld [ %i0 + 4 ], %g2
2008234: 80 a0 a0 00 cmp %g2, 0
2008238: 12 bf ff fa bne 2008220 <pthread_once+0x14>
200823c: 82 10 20 00 clr %g1
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2008240: 90 10 21 00 mov 0x100, %o0
2008244: 92 10 21 00 mov 0x100, %o1
2008248: 40 00 03 21 call 2008ecc <rtems_task_mode>
200824c: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
2008250: c2 06 20 04 ld [ %i0 + 4 ], %g1
2008254: 80 a0 60 00 cmp %g1, 0
2008258: 02 80 00 09 be 200827c <pthread_once+0x70> <== ALWAYS TAKEN
200825c: 82 10 20 01 mov 1, %g1
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2008260: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
2008264: 92 10 21 00 mov 0x100, %o1
2008268: 40 00 03 19 call 2008ecc <rtems_task_mode>
200826c: 94 07 bf fc add %fp, -4, %o2
}
return 0;
2008270: 82 10 20 00 clr %g1
}
2008274: 81 c7 e0 08 ret
2008278: 91 e8 00 01 restore %g0, %g1, %o0
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
200827c: c2 26 00 00 st %g1, [ %i0 ]
once_control->init_executed = true;
(*init_routine)();
2008280: 9f c6 40 00 call %i1
2008284: c2 26 20 04 st %g1, [ %i0 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2008288: 10 bf ff f7 b 2008264 <pthread_once+0x58>
200828c: d0 07 bf fc ld [ %fp + -4 ], %o0
02008164 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
2008164: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
2008168: 80 a6 20 00 cmp %i0, 0
200816c: 02 80 00 08 be 200818c <pthread_rwlock_init+0x28>
2008170: 80 a6 60 00 cmp %i1, 0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2008174: 02 80 00 23 be 2008200 <pthread_rwlock_init+0x9c>
2008178: 90 07 bf f8 add %fp, -8, %o0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
200817c: c2 06 40 00 ld [ %i1 ], %g1
2008180: 80 a0 60 00 cmp %g1, 0
2008184: 32 80 00 04 bne,a 2008194 <pthread_rwlock_init+0x30> <== ALWAYS TAKEN
2008188: c2 06 60 04 ld [ %i1 + 4 ], %g1
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
200818c: 81 c7 e0 08 ret
2008190: 91 e8 20 16 restore %g0, 0x16, %o0
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
switch ( the_attr->process_shared ) {
2008194: 80 a0 60 00 cmp %g1, 0
2008198: 12 bf ff fd bne 200818c <pthread_rwlock_init+0x28> <== NEVER TAKEN
200819c: 03 00 80 8b sethi %hi(0x2022c00), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
20081a0: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 2022dd0 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
20081a4: c0 27 bf f4 clr [ %fp + -12 ]
++level;
20081a8: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
20081ac: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
* 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 *)
20081b0: 39 00 80 8b sethi %hi(0x2022c00), %i4
20081b4: 40 00 0b 14 call 200ae04 <_Objects_Allocate>
20081b8: 90 17 23 e4 or %i4, 0x3e4, %o0 ! 2022fe4 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
20081bc: ba 92 20 00 orcc %o0, 0, %i5
20081c0: 02 80 00 14 be 2008210 <pthread_rwlock_init+0xac>
20081c4: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
20081c8: 40 00 09 5f call 200a744 <_CORE_RWLock_Initialize>
20081cc: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20081d0: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20081d4: b8 17 23 e4 or %i4, 0x3e4, %i4
20081d8: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20081dc: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20081e0: 85 28 a0 02 sll %g2, 2, %g2
20081e4: fa 20 c0 02 st %i5, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
20081e8: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
20081ec: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
20081f0: 40 00 10 88 call 200c410 <_Thread_Enable_dispatch>
20081f4: b0 10 20 00 clr %i0
20081f8: 81 c7 e0 08 ret
20081fc: 81 e8 00 00 restore
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
2008200: 40 00 01 b6 call 20088d8 <pthread_rwlockattr_init>
2008204: 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 )
2008208: 10 bf ff de b 2008180 <pthread_rwlock_init+0x1c>
200820c: c2 06 40 00 ld [ %i1 ], %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
2008210: 40 00 10 80 call 200c410 <_Thread_Enable_dispatch>
2008214: b0 10 20 0b mov 0xb, %i0
2008218: 81 c7 e0 08 ret
200821c: 81 e8 00 00 restore
02008a64 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008a64: 9d e3 bf 98 save %sp, -104, %sp
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
2008a68: 80 a6 20 00 cmp %i0, 0
2008a6c: 02 80 00 25 be 2008b00 <pthread_rwlock_timedrdlock+0x9c>
2008a70: 92 07 bf fc add %fp, -4, %o1
*
* 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 );
2008a74: 40 00 1b 58 call 200f7d4 <_POSIX_Absolute_timeout_to_ticks>
2008a78: 90 10 00 19 mov %i1, %o0
2008a7c: d2 06 00 00 ld [ %i0 ], %o1
2008a80: ba 10 00 08 mov %o0, %i5
2008a84: 94 07 bf f8 add %fp, -8, %o2
2008a88: 11 00 80 85 sethi %hi(0x2021400), %o0
2008a8c: 40 00 0b ca call 200b9b4 <_Objects_Get>
2008a90: 90 12 21 14 or %o0, 0x114, %o0 ! 2021514 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
2008a94: c2 07 bf f8 ld [ %fp + -8 ], %g1
2008a98: 80 a0 60 00 cmp %g1, 0
2008a9c: 32 80 00 1a bne,a 2008b04 <pthread_rwlock_timedrdlock+0xa0>
2008aa0: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
2008aa4: d2 06 00 00 ld [ %i0 ], %o1
2008aa8: d6 07 bf fc ld [ %fp + -4 ], %o3
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
2008aac: 82 1f 60 03 xor %i5, 3, %g1
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
2008ab0: 90 02 20 10 add %o0, 0x10, %o0
2008ab4: 80 a0 00 01 cmp %g0, %g1
2008ab8: 98 10 20 00 clr %o4
2008abc: b8 60 3f ff subx %g0, -1, %i4
2008ac0: 40 00 08 08 call 200aae0 <_CORE_RWLock_Obtain_for_reading>
2008ac4: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
2008ac8: 40 00 0f a9 call 200c96c <_Thread_Enable_dispatch>
2008acc: 01 00 00 00 nop
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
2008ad0: 03 00 80 86 sethi %hi(0x2021800), %g1
2008ad4: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 2021870 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
2008ad8: 80 a7 20 00 cmp %i4, 0
2008adc: 12 80 00 05 bne 2008af0 <pthread_rwlock_timedrdlock+0x8c>
2008ae0: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
2008ae4: 80 a2 20 02 cmp %o0, 2
2008ae8: 02 80 00 09 be 2008b0c <pthread_rwlock_timedrdlock+0xa8>
2008aec: 80 a7 60 00 cmp %i5, 0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
2008af0: 40 00 00 3f call 2008bec <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008af4: 01 00 00 00 nop
2008af8: 81 c7 e0 08 ret
2008afc: 91 e8 00 08 restore %g0, %o0, %o0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008b00: b0 10 20 16 mov 0x16, %i0
}
2008b04: 81 c7 e0 08 ret
2008b08: 81 e8 00 00 restore
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2008b0c: 22 bf ff fe be,a 2008b04 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
2008b10: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2008b14: ba 07 7f ff add %i5, -1, %i5
2008b18: 80 a7 60 01 cmp %i5, 1
2008b1c: 18 bf ff f5 bgu 2008af0 <pthread_rwlock_timedrdlock+0x8c> <== NEVER TAKEN
2008b20: b0 10 20 74 mov 0x74, %i0
2008b24: 30 bf ff f8 b,a 2008b04 <pthread_rwlock_timedrdlock+0xa0>
02008b28 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008b28: 9d e3 bf 98 save %sp, -104, %sp
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
2008b2c: 80 a6 20 00 cmp %i0, 0
2008b30: 02 80 00 25 be 2008bc4 <pthread_rwlock_timedwrlock+0x9c>
2008b34: 92 07 bf fc add %fp, -4, %o1
*
* 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 );
2008b38: 40 00 1b 27 call 200f7d4 <_POSIX_Absolute_timeout_to_ticks>
2008b3c: 90 10 00 19 mov %i1, %o0
2008b40: d2 06 00 00 ld [ %i0 ], %o1
2008b44: ba 10 00 08 mov %o0, %i5
2008b48: 94 07 bf f8 add %fp, -8, %o2
2008b4c: 11 00 80 85 sethi %hi(0x2021400), %o0
2008b50: 40 00 0b 99 call 200b9b4 <_Objects_Get>
2008b54: 90 12 21 14 or %o0, 0x114, %o0 ! 2021514 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
2008b58: c2 07 bf f8 ld [ %fp + -8 ], %g1
2008b5c: 80 a0 60 00 cmp %g1, 0
2008b60: 32 80 00 1a bne,a 2008bc8 <pthread_rwlock_timedwrlock+0xa0>
2008b64: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
2008b68: d2 06 00 00 ld [ %i0 ], %o1
2008b6c: d6 07 bf fc ld [ %fp + -4 ], %o3
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
2008b70: 82 1f 60 03 xor %i5, 3, %g1
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
2008b74: 90 02 20 10 add %o0, 0x10, %o0
2008b78: 80 a0 00 01 cmp %g0, %g1
2008b7c: 98 10 20 00 clr %o4
2008b80: b8 60 3f ff subx %g0, -1, %i4
2008b84: 40 00 08 0c call 200abb4 <_CORE_RWLock_Obtain_for_writing>
2008b88: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
2008b8c: 40 00 0f 78 call 200c96c <_Thread_Enable_dispatch>
2008b90: 01 00 00 00 nop
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
2008b94: 03 00 80 86 sethi %hi(0x2021800), %g1
2008b98: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 2021870 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
2008b9c: 80 a7 20 00 cmp %i4, 0
2008ba0: 12 80 00 05 bne 2008bb4 <pthread_rwlock_timedwrlock+0x8c>
2008ba4: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
2008ba8: 80 a2 20 02 cmp %o0, 2
2008bac: 02 80 00 09 be 2008bd0 <pthread_rwlock_timedwrlock+0xa8>
2008bb0: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
2008bb4: 40 00 00 0e call 2008bec <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008bb8: 01 00 00 00 nop
2008bbc: 81 c7 e0 08 ret
2008bc0: 91 e8 00 08 restore %g0, %o0, %o0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008bc4: b0 10 20 16 mov 0x16, %i0
}
2008bc8: 81 c7 e0 08 ret
2008bcc: 81 e8 00 00 restore
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2008bd0: 22 bf ff fe be,a 2008bc8 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
2008bd4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2008bd8: ba 07 7f ff add %i5, -1, %i5
2008bdc: 80 a7 60 01 cmp %i5, 1
2008be0: 18 bf ff f5 bgu 2008bb4 <pthread_rwlock_timedwrlock+0x8c> <== NEVER TAKEN
2008be4: b0 10 20 74 mov 0x74, %i0
2008be8: 30 bf ff f8 b,a 2008bc8 <pthread_rwlock_timedwrlock+0xa0>
02009404 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
2009404: 82 10 00 08 mov %o0, %g1
if ( !attr )
2009408: 80 a0 60 00 cmp %g1, 0
200940c: 02 80 00 06 be 2009424 <pthread_rwlockattr_setpshared+0x20>
2009410: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
2009414: c4 00 40 00 ld [ %g1 ], %g2
2009418: 80 a0 a0 00 cmp %g2, 0
200941c: 12 80 00 04 bne 200942c <pthread_rwlockattr_setpshared+0x28>
2009420: 80 a2 60 01 cmp %o1, 1
return 0;
default:
return EINVAL;
}
}
2009424: 81 c3 e0 08 retl
2009428: 01 00 00 00 nop
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
200942c: 18 bf ff fe bgu 2009424 <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
2009430: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
2009434: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
default:
return EINVAL;
}
}
2009438: 81 c3 e0 08 retl
200943c: 90 10 20 00 clr %o0
0200a4c4 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
200a4c4: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
200a4c8: 80 a6 a0 00 cmp %i2, 0
200a4cc: 02 80 00 0a be 200a4f4 <pthread_setschedparam+0x30>
200a4d0: ba 10 20 16 mov 0x16, %i5
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
200a4d4: 90 10 00 19 mov %i1, %o0
200a4d8: 92 10 00 1a mov %i2, %o1
200a4dc: 94 07 bf f4 add %fp, -12, %o2
200a4e0: 40 00 19 2a call 2010988 <_POSIX_Thread_Translate_sched_param>
200a4e4: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
200a4e8: ba 92 20 00 orcc %o0, 0, %i5
200a4ec: 02 80 00 05 be 200a500 <pthread_setschedparam+0x3c>
200a4f0: 90 10 00 18 mov %i0, %o0
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
200a4f4: b0 10 00 1d mov %i5, %i0
200a4f8: 81 c7 e0 08 ret
200a4fc: 81 e8 00 00 restore
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
200a500: 40 00 0c fc call 200d8f0 <_Thread_Get>
200a504: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a508: c2 07 bf fc ld [ %fp + -4 ], %g1
200a50c: 80 a0 60 00 cmp %g1, 0
200a510: 12 80 00 2b bne 200a5bc <pthread_setschedparam+0xf8>
200a514: b6 10 00 08 mov %o0, %i3
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200a518: f8 02 21 5c ld [ %o0 + 0x15c ], %i4
if ( api->schedpolicy == SCHED_SPORADIC )
200a51c: c2 07 20 84 ld [ %i4 + 0x84 ], %g1
200a520: 80 a0 60 04 cmp %g1, 4
200a524: 02 80 00 35 be 200a5f8 <pthread_setschedparam+0x134>
200a528: 01 00 00 00 nop
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
200a52c: c2 06 80 00 ld [ %i2 ], %g1
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
200a530: 80 a6 60 00 cmp %i1, 0
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
200a534: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
200a538: c4 06 a0 04 ld [ %i2 + 4 ], %g2
200a53c: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
200a540: c4 06 a0 08 ld [ %i2 + 8 ], %g2
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
200a544: f2 27 20 84 st %i1, [ %i4 + 0x84 ]
api->schedparam = *param;
200a548: c4 27 20 90 st %g2, [ %i4 + 0x90 ]
200a54c: c4 06 a0 0c ld [ %i2 + 0xc ], %g2
200a550: c4 27 20 94 st %g2, [ %i4 + 0x94 ]
200a554: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2
200a558: c4 27 20 98 st %g2, [ %i4 + 0x98 ]
200a55c: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
200a560: c4 27 20 9c st %g2, [ %i4 + 0x9c ]
200a564: c4 06 a0 18 ld [ %i2 + 0x18 ], %g2
200a568: c4 27 20 a0 st %g2, [ %i4 + 0xa0 ]
the_thread->budget_algorithm = budget_algorithm;
200a56c: c4 07 bf f4 ld [ %fp + -12 ], %g2
200a570: c4 26 e0 78 st %g2, [ %i3 + 0x78 ]
the_thread->budget_callout = budget_callout;
200a574: c4 07 bf f8 ld [ %fp + -8 ], %g2
switch ( api->schedpolicy ) {
200a578: 06 80 00 0e bl 200a5b0 <pthread_setschedparam+0xec> <== NEVER TAKEN
200a57c: c4 26 e0 7c st %g2, [ %i3 + 0x7c ]
200a580: 80 a6 60 02 cmp %i1, 2
200a584: 04 80 00 11 ble 200a5c8 <pthread_setschedparam+0x104>
200a588: 07 00 80 8a sethi %hi(0x2022800), %g3
200a58c: 80 a6 60 04 cmp %i1, 4
200a590: 12 80 00 08 bne 200a5b0 <pthread_setschedparam+0xec> <== NEVER TAKEN
200a594: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
200a598: c2 27 20 a4 st %g1, [ %i4 + 0xa4 ]
_Watchdog_Remove( &api->Sporadic_timer );
200a59c: 40 00 11 0f call 200e9d8 <_Watchdog_Remove>
200a5a0: 90 07 20 a8 add %i4, 0xa8, %o0
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
200a5a4: 90 10 20 00 clr %o0
200a5a8: 7f ff ff 7b call 200a394 <_POSIX_Threads_Sporadic_budget_TSR>
200a5ac: 92 10 00 1b mov %i3, %o1
break;
}
_Thread_Enable_dispatch();
200a5b0: 40 00 0c c4 call 200d8c0 <_Thread_Enable_dispatch>
200a5b4: b0 10 00 1d mov %i5, %i0
200a5b8: 30 bf ff d0 b,a 200a4f8 <pthread_setschedparam+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
200a5bc: ba 10 20 03 mov 3, %i5
}
200a5c0: 81 c7 e0 08 ret
200a5c4: 91 e8 00 1d restore %g0, %i5, %o0
200a5c8: d2 08 e3 dc ldub [ %g3 + 0x3dc ], %o1
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a5cc: 05 00 80 8e sethi %hi(0x2023800), %g2
200a5d0: c4 00 a0 40 ld [ %g2 + 0x40 ], %g2 ! 2023840 <_Thread_Ticks_per_timeslice>
200a5d4: 92 22 40 01 sub %o1, %g1, %o1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a5d8: 90 10 00 1b mov %i3, %o0
200a5dc: 94 10 20 01 mov 1, %o2
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a5e0: c4 26 e0 74 st %g2, [ %i3 + 0x74 ]
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a5e4: 40 00 0b 65 call 200d378 <_Thread_Change_priority>
200a5e8: d2 26 e0 18 st %o1, [ %i3 + 0x18 ]
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
200a5ec: 40 00 0c b5 call 200d8c0 <_Thread_Enable_dispatch>
200a5f0: b0 10 00 1d mov %i5, %i0
200a5f4: 30 bf ff c1 b,a 200a4f8 <pthread_setschedparam+0x34>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
200a5f8: 40 00 10 f8 call 200e9d8 <_Watchdog_Remove>
200a5fc: 90 07 20 a8 add %i4, 0xa8, %o0
api->schedpolicy = policy;
api->schedparam = *param;
200a600: 10 bf ff cc b 200a530 <pthread_setschedparam+0x6c>
200a604: c2 06 80 00 ld [ %i2 ], %g1
02007e5c <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
2007e5c: 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() )
2007e60: 3b 00 80 7d sethi %hi(0x201f400), %i5
2007e64: ba 17 62 90 or %i5, 0x290, %i5 ! 201f690 <_Per_CPU_Information>
2007e68: c2 07 60 08 ld [ %i5 + 8 ], %g1
2007e6c: 80 a0 60 00 cmp %g1, 0
2007e70: 12 80 00 16 bne 2007ec8 <pthread_testcancel+0x6c> <== NEVER TAKEN
2007e74: 03 00 80 7c sethi %hi(0x201f000), %g1
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007e78: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2007e7c: c6 00 61 70 ld [ %g1 + 0x170 ], %g3
2007e80: c4 00 a1 5c ld [ %g2 + 0x15c ], %g2
++level;
2007e84: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
2007e88: c6 20 61 70 st %g3, [ %g1 + 0x170 ]
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
2007e8c: c2 00 a0 d8 ld [ %g2 + 0xd8 ], %g1
2007e90: 80 a0 60 00 cmp %g1, 0
2007e94: 12 80 00 0b bne 2007ec0 <pthread_testcancel+0x64> <== NEVER TAKEN
2007e98: 01 00 00 00 nop
2007e9c: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1
2007ea0: 80 a0 60 00 cmp %g1, 0
2007ea4: 02 80 00 07 be 2007ec0 <pthread_testcancel+0x64>
2007ea8: 01 00 00 00 nop
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
2007eac: 40 00 0c 6f call 200b068 <_Thread_Enable_dispatch>
2007eb0: b2 10 3f ff mov -1, %i1 ! ffffffff <RAM_END+0xfdbfffff>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
2007eb4: f0 07 60 10 ld [ %i5 + 0x10 ], %i0
2007eb8: 40 00 18 c7 call 200e1d4 <_POSIX_Thread_Exit>
2007ebc: 81 e8 00 00 restore
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
2007ec0: 40 00 0c 6a call 200b068 <_Thread_Enable_dispatch>
2007ec4: 81 e8 00 00 restore
2007ec8: 81 c7 e0 08 ret <== NOT EXECUTED
2007ecc: 81 e8 00 00 restore <== NOT EXECUTED
0200d070 <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
200d070: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
200d074: 7f ff df 4a call 2004d9c <malloc>
200d078: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
200d07c: ba 92 20 00 orcc %o0, 0, %i5
200d080: 02 80 00 0b be 200d0ac <ramdisk_allocate+0x3c> <== NEVER TAKEN
200d084: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
200d088: 02 80 00 0b be 200d0b4 <ramdisk_allocate+0x44>
200d08c: 90 10 00 1a mov %i2, %o0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
200d090: c0 2f 60 0d clrb [ %i5 + 0xd ]
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
200d094: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
200d098: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = media_block_count;
200d09c: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
200d0a0: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
200d0a4: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
200d0a8: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
200d0ac: 81 c7 e0 08 ret
200d0b0: 91 e8 00 1d restore %g0, %i5, %o0
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(media_block_count, media_block_size);
200d0b4: 7f ff dd 21 call 2004538 <calloc>
200d0b8: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
200d0bc: b0 92 20 00 orcc %o0, 0, %i0
200d0c0: 02 80 00 04 be 200d0d0 <ramdisk_allocate+0x60> <== NEVER TAKEN
200d0c4: 82 10 20 01 mov 1, %g1
free(rd);
return NULL;
}
rd->malloced = true;
200d0c8: 10 bf ff f4 b 200d098 <ramdisk_allocate+0x28>
200d0cc: c2 2f 60 0d stb %g1, [ %i5 + 0xd ]
}
if (area_begin == NULL) {
area_begin = calloc(media_block_count, media_block_size);
if (area_begin == NULL) {
free(rd);
200d0d0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200d0d4: 7f ff dd ea call 200487c <free> <== NOT EXECUTED
200d0d8: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
200d0dc: 30 bf ff f4 b,a 200d0ac <ramdisk_allocate+0x3c> <== NOT EXECUTED
0200d0e0 <ramdisk_free>:
return rd;
}
void ramdisk_free(ramdisk *rd)
{
200d0e0: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
200d0e4: 80 a6 20 00 cmp %i0, 0
200d0e8: 02 80 00 0c be 200d118 <ramdisk_free+0x38> <== NEVER TAKEN
200d0ec: 01 00 00 00 nop
if (rd->malloced) {
200d0f0: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
200d0f4: 80 a0 60 00 cmp %g1, 0
200d0f8: 12 80 00 04 bne 200d108 <ramdisk_free+0x28>
200d0fc: 01 00 00 00 nop
free(rd->area);
}
free(rd);
200d100: 7f ff dd df call 200487c <free>
200d104: 81 e8 00 00 restore
void ramdisk_free(ramdisk *rd)
{
if (rd != NULL) {
if (rd->malloced) {
free(rd->area);
200d108: 7f ff dd dd call 200487c <free>
200d10c: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
200d110: 7f ff dd db call 200487c <free>
200d114: 81 e8 00 00 restore
200d118: 81 c7 e0 08 ret <== NOT EXECUTED
200d11c: 81 e8 00 00 restore <== NOT EXECUTED
0200e644 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
200e644: 9d e3 bf 80 save %sp, -128, %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();
200e648: 7f ff d8 d2 call 2004990 <rtems_disk_io_initialize>
200e64c: a0 10 00 18 mov %i0, %l0
if (rc != RTEMS_SUCCESSFUL)
200e650: b0 92 20 00 orcc %o0, 0, %i0
200e654: 02 80 00 04 be 200e664 <ramdisk_initialize+0x20> <== ALWAYS TAKEN
200e658: 23 00 80 9d sethi %hi(0x2027400), %l1
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
}
200e65c: 81 c7 e0 08 ret <== NOT EXECUTED
200e660: 81 e8 00 00 restore <== NOT EXECUTED
* 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));
200e664: fa 04 60 3c ld [ %l1 + 0x3c ], %i5
200e668: 92 10 20 10 mov 0x10, %o1
200e66c: 7f ff dc 9e call 20058e4 <calloc>
200e670: 90 10 00 1d mov %i5, %o0
r->trace = false;
200e674: c0 2a 20 0e clrb [ %o0 + 0xe ]
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
200e678: 80 a7 60 00 cmp %i5, 0
200e67c: 02 80 00 2e be 200e734 <ramdisk_initialize+0xf0> <== NEVER TAKEN
200e680: b6 10 00 08 mov %o0, %i3
200e684: 35 00 80 9d sethi %hi(0x2027400), %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
200e688: 39 0b d9 19 sethi %hi(0x2f646400), %i4
200e68c: 3b 0b dc 99 sethi %hi(0x2f726400), %i5
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
200e690: 25 00 80 39 sethi %hi(0x200e400), %l2
* 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++)
200e694: b4 16 a0 40 or %i2, 0x40, %i2
200e698: b2 10 20 00 clr %i1
200e69c: a2 14 60 3c or %l1, 0x3c, %l1
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
200e6a0: b8 17 21 76 or %i4, 0x176, %i4
200e6a4: ba 17 60 61 or %i5, 0x61, %i5
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
ramdisk_ioctl, r, name);
200e6a8: a6 07 bf f0 add %fp, -16, %l3
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
200e6ac: a4 14 a3 80 or %l2, 0x380, %l2
}
}
else
{
r->malloced = false;
r->initialized = true;
200e6b0: b0 10 20 01 mov 1, %i0
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;
200e6b4: d4 06 80 00 ld [ %i2 ], %o2
r->block_num = c->block_num;
200e6b8: d6 06 a0 04 ld [ %i2 + 4 ], %o3
if (c->location == NULL)
200e6bc: c2 06 a0 08 ld [ %i2 + 8 ], %g1
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";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
200e6c0: f2 2f bf f8 stb %i1, [ %fp + -8 ]
r->block_size = c->block_size;
200e6c4: d4 26 c0 00 st %o2, [ %i3 ]
r->block_num = c->block_num;
200e6c8: d6 26 e0 04 st %o3, [ %i3 + 4 ]
if (c->location == NULL)
200e6cc: 80 a0 60 00 cmp %g1, 0
200e6d0: 02 80 00 1f be 200e74c <ramdisk_initialize+0x108> <== ALWAYS TAKEN
200e6d4: f8 3f bf f0 std %i4, [ %fp + -16 ]
r->initialized = true;
}
}
else
{
r->malloced = false;
200e6d8: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
200e6dc: f0 2e e0 0c stb %i0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
200e6e0: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
200e6e4: 92 10 00 19 mov %i1, %o1
200e6e8: 9a 10 00 1b mov %i3, %o5
200e6ec: 98 10 00 12 mov %l2, %o4
200e6f0: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
200e6f4: 7f ff d8 07 call 2004710 <rtems_disk_create_phys>
200e6f8: 90 10 00 10 mov %l0, %o0
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
200e6fc: 80 a2 20 00 cmp %o0, 0
200e700: 22 80 00 08 be,a 200e720 <ramdisk_initialize+0xdc> <== ALWAYS TAKEN
200e704: c2 04 40 00 ld [ %l1 ], %g1
{
if (r->malloced)
200e708: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
200e70c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e710: 12 80 00 0b bne 200e73c <ramdisk_initialize+0xf8> <== NOT EXECUTED
200e714: 01 00 00 00 nop <== NOT EXECUTED
{
free(r->area);
}
r->initialized = false;
200e718: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
200e71c: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
200e720: b2 06 60 01 inc %i1
200e724: b4 06 a0 0c add %i2, 0xc, %i2
200e728: 80 a0 40 19 cmp %g1, %i1
200e72c: 18 bf ff e2 bgu 200e6b4 <ramdisk_initialize+0x70> <== NEVER TAKEN
200e730: b6 06 e0 10 add %i3, 0x10, %i3
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
200e734: 81 c7 e0 08 ret
200e738: 91 e8 20 00 restore %g0, 0, %o0
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
{
if (r->malloced)
{
free(r->area);
200e73c: 7f ff dd 3b call 2005c28 <free> <== NOT EXECUTED
200e740: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
200e744: 10 bf ff f6 b 200e71c <ramdisk_initialize+0xd8> <== NOT EXECUTED
200e748: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
200e74c: 92 10 00 0a mov %o2, %o1
200e750: 90 10 00 0b mov %o3, %o0
200e754: d4 3f bf e8 std %o2, [ %fp + -24 ]
200e758: 40 00 51 2a call 2022c00 <.umul>
200e75c: f0 2e e0 0d stb %i0, [ %i3 + 0xd ]
200e760: 7f ff de cf call 200629c <malloc>
200e764: 01 00 00 00 nop
200e768: d0 26 e0 08 st %o0, [ %i3 + 8 ]
if (r->area == NULL) /* No enough memory for this disk */
200e76c: 80 a2 20 00 cmp %o0, 0
200e770: 02 bf ff ea be 200e718 <ramdisk_initialize+0xd4> <== NEVER TAKEN
200e774: d4 1f bf e8 ldd [ %fp + -24 ], %o2
r->initialized = false;
continue;
}
else
{
r->initialized = true;
200e778: 10 bf ff db b 200e6e4 <ramdisk_initialize+0xa0>
200e77c: f0 2e e0 0c stb %i0, [ %i3 + 0xc ]
0200cf28 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200cf28: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200cf2c: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200cf30: b8 10 00 1a mov %i2, %i4
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200cf34: 84 10 a2 07 or %g2, 0x207, %g2
200cf38: 80 a6 40 02 cmp %i1, %g2
200cf3c: 02 80 00 09 be 200cf60 <ramdisk_ioctl+0x38>
200cf40: f6 06 20 3c ld [ %i0 + 0x3c ], %i3
200cf44: 05 30 06 10 sethi %hi(0xc0184000), %g2
200cf48: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <RAM_END+0xbdd84201>
200cf4c: 80 a6 40 02 cmp %i1, %g2
200cf50: 22 80 00 0e be,a 200cf88 <ramdisk_ioctl+0x60>
200cf54: c2 06 80 00 ld [ %i2 ], %g1
ramdisk_free(rd);
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
200cf58: 40 00 0b 08 call 200fb78 <rtems_blkdev_ioctl>
200cf5c: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
200cf60: c2 0e e0 0f ldub [ %i3 + 0xf ], %g1
200cf64: 80 a0 60 00 cmp %g1, 0
200cf68: 12 80 00 3f bne 200d064 <ramdisk_ioctl+0x13c>
200cf6c: 01 00 00 00 nop
default:
return rtems_blkdev_ioctl (dd, req, argp);
break;
}
errno = EINVAL;
200cf70: 40 00 1e d8 call 2014ad0 <__errno>
200cf74: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff>
200cf78: 82 10 20 16 mov 0x16, %g1
200cf7c: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
200cf80: 81 c7 e0 08 ret
200cf84: 81 e8 00 00 restore
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
200cf88: 80 a0 60 00 cmp %g1, 0
200cf8c: 12 80 00 1c bne 200cffc <ramdisk_ioctl+0xd4>
200cf90: 80 a0 60 01 cmp %g1, 1
#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++)
200cf94: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
200cf98: ba 06 a0 18 add %i2, 0x18, %i5
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
200cf9c: f0 06 e0 08 ld [ %i3 + 8 ], %i0
#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++)
200cfa0: 80 a0 60 00 cmp %g1, 0
200cfa4: 02 80 00 0f be 200cfe0 <ramdisk_ioctl+0xb8> <== NEVER TAKEN
200cfa8: 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);
200cfac: d0 07 40 00 ld [ %i5 ], %o0
200cfb0: d2 06 c0 00 ld [ %i3 ], %o1
200cfb4: 40 00 41 d0 call 201d6f4 <.umul>
200cfb8: f2 07 60 08 ld [ %i5 + 8 ], %i1
200cfbc: d4 07 60 04 ld [ %i5 + 4 ], %o2
200cfc0: 92 06 00 08 add %i0, %o0, %o1
200cfc4: 40 00 21 14 call 2015414 <memcpy>
200cfc8: 90 10 00 19 mov %i1, %o0
#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++)
200cfcc: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
200cfd0: b4 06 a0 01 inc %i2
200cfd4: 80 a6 80 01 cmp %i2, %g1
200cfd8: 0a bf ff f5 bcs 200cfac <ramdisk_ioctl+0x84> <== NEVER TAKEN
200cfdc: ba 07 60 10 add %i5, 0x10, %i5
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
200cfe0: c2 07 20 04 ld [ %i4 + 4 ], %g1
200cfe4: 90 10 00 1c mov %i4, %o0
200cfe8: 92 10 20 00 clr %o1
200cfec: 9f c0 40 00 call %g1
200cff0: 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);
200cff4: 81 c7 e0 08 ret
200cff8: 81 e8 00 00 restore
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
200cffc: 12 bf ff dd bne 200cf70 <ramdisk_ioctl+0x48> <== NEVER TAKEN
200d000: ba 06 a0 18 add %i2, 0x18, %i5
#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++)
200d004: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
200d008: f2 06 e0 08 ld [ %i3 + 8 ], %i1
#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++)
200d00c: 80 a0 60 00 cmp %g1, 0
200d010: 02 bf ff f4 be 200cfe0 <ramdisk_ioctl+0xb8> <== NEVER TAKEN
200d014: 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);
200d018: d0 07 40 00 ld [ %i5 ], %o0
200d01c: d2 06 c0 00 ld [ %i3 ], %o1
200d020: 40 00 41 b5 call 201d6f4 <.umul>
200d024: b4 06 a0 01 inc %i2
200d028: d2 07 60 08 ld [ %i5 + 8 ], %o1
200d02c: d4 07 60 04 ld [ %i5 + 4 ], %o2
200d030: 40 00 20 f9 call 2015414 <memcpy>
200d034: 90 06 40 08 add %i1, %o0, %o0
#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++)
200d038: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
200d03c: 80 a6 80 01 cmp %i2, %g1
200d040: 0a bf ff f6 bcs 200d018 <ramdisk_ioctl+0xf0>
200d044: ba 07 60 10 add %i5, 0x10, %i5
200d048: c2 07 20 04 ld [ %i4 + 4 ], %g1
200d04c: 90 10 00 1c mov %i4, %o0
200d050: 92 10 20 00 clr %o1
200d054: 9f c0 40 00 call %g1
200d058: 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);
200d05c: 81 c7 e0 08 ret
200d060: 81 e8 00 00 restore
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
ramdisk_free(rd);
200d064: 40 00 00 1f call 200d0e0 <ramdisk_free>
200d068: 90 10 00 1b mov %i3, %o0
200d06c: 30 bf ff c1 b,a 200cf70 <ramdisk_ioctl+0x48>
0200d120 <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
200d120: 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);
200d124: 90 10 20 00 clr %o0
const char *disk,
dev_t *dev_ptr
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
200d128: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
200d12c: 94 07 bf fc add %fp, -4, %o2
200d130: 13 00 80 82 sethi %hi(0x2020800), %o1
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
200d134: ba 10 20 0d mov 0xd, %i5
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);
200d138: 7f ff f1 9c call 20097a8 <rtems_io_register_driver>
200d13c: 92 12 62 d8 or %o1, 0x2d8, %o1
if (sc != RTEMS_SUCCESSFUL) {
200d140: 80 a2 20 00 cmp %o0, 0
200d144: 02 80 00 04 be 200d154 <ramdisk_register+0x34> <== ALWAYS TAKEN
200d148: 96 10 00 1a mov %i2, %o3
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
200d14c: 81 c7 e0 08 ret
200d150: 91 e8 00 1d restore %g0, %i5, %o0
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
200d154: 92 10 00 18 mov %i0, %o1
200d158: 7f ff ff c6 call 200d070 <ramdisk_allocate>
200d15c: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
200d160: b4 92 20 00 orcc %o0, 0, %i2
200d164: 02 80 00 14 be 200d1b4 <ramdisk_register+0x94> <== NEVER TAKEN
200d168: e0 07 bf fc ld [ %fp + -4 ], %l0
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
200d16c: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
200d170: 90 10 00 10 mov %l0, %o0
200d174: 92 10 20 00 clr %o1
200d178: 94 10 00 18 mov %i0, %o2
200d17c: 96 10 00 19 mov %i1, %o3
200d180: 9a 10 00 1a mov %i2, %o5
200d184: 19 00 80 33 sethi %hi(0x200cc00), %o4
200d188: 7f ff da 1d call 20039fc <rtems_disk_create_phys>
200d18c: 98 13 23 28 or %o4, 0x328, %o4 ! 200cf28 <ramdisk_ioctl>
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
200d190: 80 a2 20 00 cmp %o0, 0
200d194: 12 80 00 06 bne 200d1ac <ramdisk_register+0x8c> <== NEVER TAKEN
200d198: 01 00 00 00 nop
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
200d19c: e0 27 00 00 st %l0, [ %i4 ]
200d1a0: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
200d1a4: 10 bf ff ea b 200d14c <ramdisk_register+0x2c>
200d1a8: ba 10 20 00 clr %i5
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ramdisk_free(rd);
200d1ac: 7f ff ff cd call 200d0e0 <ramdisk_free> <== NOT EXECUTED
200d1b0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
200d1b4: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
200d1b8: 7f ff f1 e1 call 200993c <rtems_io_unregister_driver> <== NOT EXECUTED
200d1bc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
200d1c0: 81 c7 e0 08 ret <== NOT EXECUTED
200d1c4: 81 e8 00 00 restore <== NOT EXECUTED
0201aaf8 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
201aaf8: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201aafc: 03 00 80 75 sethi %hi(0x201d400), %g1
201ab00: c2 00 63 44 ld [ %g1 + 0x344 ], %g1 ! 201d744 <rtems_libio_number_iops>
201ab04: 80 a6 00 01 cmp %i0, %g1
201ab08: 1a 80 00 18 bcc 201ab68 <read+0x70>
201ab0c: 03 00 80 78 sethi %hi(0x201e000), %g1
iop = rtems_libio_iop( fd );
201ab10: d0 00 61 94 ld [ %g1 + 0x194 ], %o0 ! 201e194 <rtems_libio_iops>
201ab14: 83 2e 20 03 sll %i0, 3, %g1
201ab18: b1 2e 20 06 sll %i0, 6, %i0
201ab1c: b0 26 00 01 sub %i0, %g1, %i0
201ab20: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
201ab24: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
201ab28: 80 88 61 00 btst 0x100, %g1
201ab2c: 02 80 00 0f be 201ab68 <read+0x70>
201ab30: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
201ab34: 02 80 00 13 be 201ab80 <read+0x88> <== NEVER TAKEN
201ab38: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
201ab3c: 02 80 00 0f be 201ab78 <read+0x80>
201ab40: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
201ab44: 80 88 60 02 btst 2, %g1
201ab48: 02 80 00 08 be 201ab68 <read+0x70>
201ab4c: 92 10 00 19 mov %i1, %o1
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
201ab50: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
201ab54: c2 00 60 08 ld [ %g1 + 8 ], %g1
201ab58: 9f c0 40 00 call %g1
201ab5c: 94 10 00 1a mov %i2, %o2
}
201ab60: 81 c7 e0 08 ret
201ab64: 91 e8 00 08 restore %g0, %o0, %o0
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
201ab68: 7f ff d6 1c call 20103d8 <__errno>
201ab6c: b0 10 3f ff mov -1, %i0
201ab70: 82 10 20 09 mov 9, %g1
201ab74: c2 22 00 00 st %g1, [ %o0 ]
201ab78: 81 c7 e0 08 ret
201ab7c: 81 e8 00 00 restore
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
201ab80: 7f ff d6 16 call 20103d8 <__errno> <== NOT EXECUTED
201ab84: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201ab88: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201ab8c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201ab90: 81 c7 e0 08 ret <== NOT EXECUTED
201ab94: 81 e8 00 00 restore <== NOT EXECUTED
02004d08 <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)
{
2004d08: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
2004d0c: 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)
{
2004d10: 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))
2004d14: 80 a6 a0 00 cmp %i2, 0
2004d18: 02 80 00 16 be 2004d70 <read_extended_partition+0x68> <== NEVER TAKEN
2004d1c: b0 10 20 19 mov 0x19, %i0
2004d20: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2004d24: 80 a0 60 00 cmp %g1, 0
2004d28: 02 80 00 12 be 2004d70 <read_extended_partition+0x68> <== NEVER TAKEN
2004d2c: 90 10 00 1d mov %i5, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
2004d30: e0 06 a0 04 ld [ %i2 + 4 ], %l0
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
2004d34: b9 2c 20 09 sll %l0, 9, %i4
new_off = lseek(fd, off, SEEK_SET);
2004d38: 92 10 20 00 clr %o1
2004d3c: 94 10 00 1c mov %i4, %o2
2004d40: 40 00 04 de call 20060b8 <lseek>
2004d44: 96 10 20 00 clr %o3
if (new_off != off) {
2004d48: 80 a2 20 00 cmp %o0, 0
2004d4c: 02 80 00 0b be 2004d78 <read_extended_partition+0x70> <== ALWAYS TAKEN
2004d50: 80 a7 00 09 cmp %i4, %o1
return RTEMS_IO_ERROR;
2004d54: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
if (rc != RTEMS_SUCCESSFUL)
{
if (sector)
2004d58: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
2004d5c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004d60: 02 80 00 41 be 2004e64 <read_extended_partition+0x15c> <== NOT EXECUTED
2004d64: 01 00 00 00 nop <== NOT EXECUTED
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004d68: 40 00 03 b0 call 2005c28 <free> <== NOT EXECUTED
2004d6c: 01 00 00 00 nop <== NOT EXECUTED
2004d70: 81 c7 e0 08 ret <== NOT EXECUTED
2004d74: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
new_off = lseek(fd, off, SEEK_SET);
if (new_off != off) {
2004d78: 12 bf ff f8 bne 2004d58 <read_extended_partition+0x50> <== NEVER TAKEN
2004d7c: b0 10 20 1b mov 0x1b, %i0
2004d80: 90 10 00 1d mov %i5, %o0
2004d84: 92 10 00 10 mov %l0, %o1
2004d88: 7f ff ff 7c call 2004b78 <get_sector.part.0>
2004d8c: 94 07 bf f8 add %fp, -8, %o2
here = ext_part->start;
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
if (rc != RTEMS_SUCCESSFUL)
2004d90: b0 92 20 00 orcc %o0, 0, %i0
2004d94: 12 bf ff f1 bne 2004d58 <read_extended_partition+0x50> <== NEVER TAKEN
2004d98: d0 07 bf f8 ld [ %fp + -8 ], %o0
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) &&
2004d9c: c2 0a 22 02 ldub [ %o0 + 0x202 ], %g1
2004da0: 80 a0 60 55 cmp %g1, 0x55
2004da4: 22 80 00 06 be,a 2004dbc <read_extended_partition+0xb4> <== ALWAYS TAKEN
2004da8: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
return rc;
}
if (!msdos_signature_check(sector))
{
free(sector);
2004dac: 40 00 03 9f call 2005c28 <free> <== NOT EXECUTED
2004db0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
2004db4: 81 c7 e0 08 ret <== NOT EXECUTED
2004db8: 81 e8 00 00 restore <== 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) &&
2004dbc: 80 a0 60 aa cmp %g1, 0xaa
2004dc0: 12 bf ff fb bne 2004dac <read_extended_partition+0xa4> <== NEVER TAKEN
2004dc4: b6 02 21 d2 add %o0, 0x1d2, %i3
2004dc8: 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)
2004dcc: a2 06 a0 10 add %i2, 0x10, %l1
2004dd0: 90 06 ff f0 add %i3, -16, %o0
2004dd4: 7f ff ff 80 call 2004bd4 <data_to_part_desc.part.1>
2004dd8: 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)
2004ddc: b0 92 20 00 orcc %o0, 0, %i0
2004de0: 12 80 00 1f bne 2004e5c <read_extended_partition+0x154> <== NEVER TAKEN
2004de4: d4 07 bf fc ld [ %fp + -4 ], %o2
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
2004de8: 80 a2 a0 00 cmp %o2, 0
2004dec: 22 80 00 19 be,a 2004e50 <read_extended_partition+0x148>
2004df0: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
2004df4: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
2004df8: 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));
2004dfc: c4 0a a0 01 ldub [ %o2 + 1 ], %g2
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
2004e00: f4 22 a0 14 st %i2, [ %o2 + 0x14 ]
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
2004e04: 84 08 a0 7f and %g2, 0x7f, %g2
2004e08: 80 a0 a0 05 cmp %g2, 5
2004e0c: 02 80 00 18 be 2004e6c <read_extended_partition+0x164>
2004e10: c2 22 a0 10 st %g1, [ %o2 + 0x10 ]
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;
2004e14: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
2004e18: de 02 a0 04 ld [ %o2 + 4 ], %o7
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004e1c: c8 02 a0 08 ld [ %o2 + 8 ], %g4
}
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;
2004e20: 84 00 e0 01 add %g3, 1, %g2
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;
2004e24: 86 00 e0 0a add %g3, 0xa, %g3
new_part_desc->log_id = ++disk_desc->last_log_id;
2004e28: c4 20 60 24 st %g2, [ %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;
2004e2c: 87 28 e0 02 sll %g3, 2, %g3
2004e30: d4 20 40 03 st %o2, [ %g1 + %g3 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
2004e34: c4 2a a0 02 stb %g2, [ %o2 + 2 ]
new_part_desc->start += here;
2004e38: 82 04 00 0f add %l0, %o7, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004e3c: 84 01 3f ff add %g4, -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;
new_part_desc->start += here;
2004e40: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004e44: 82 00 80 01 add %g2, %g1, %g1
2004e48: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
2004e4c: 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++)
2004e50: 80 a7 00 11 cmp %i4, %l1
2004e54: 12 bf ff df bne 2004dd0 <read_extended_partition+0xc8>
2004e58: 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);
2004e5c: 40 00 03 73 call 2005c28 <free>
2004e60: d0 07 bf f8 ld [ %fp + -8 ], %o0
2004e64: 81 c7 e0 08 ret
2004e68: 81 e8 00 00 restore
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
2004e6c: c2 02 a0 04 ld [ %o2 + 4 ], %g1
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;
2004e70: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
2004e74: 82 00 40 19 add %g1, %i1, %g1
read_extended_partition(fd, start, new_part_desc);
2004e78: 90 10 00 1d mov %i5, %o0
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
2004e7c: c2 22 a0 04 st %g1, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
2004e80: 7f ff ff a2 call 2004d08 <read_extended_partition>
2004e84: 92 10 00 19 mov %i1, %o1
2004e88: 10 bf ff f2 b 2004e50 <read_extended_partition+0x148>
2004e8c: b8 07 20 04 add %i4, 4, %i4
02005224 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
2005224: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
2005228: 03 00 80 78 sethi %hi(0x201e000), %g1
200522c: c2 00 62 44 ld [ %g1 + 0x244 ], %g1 ! 201e244 <rtems_libio_number_iops>
2005230: 80 a6 00 01 cmp %i0, %g1
2005234: 1a 80 00 45 bcc 2005348 <readv+0x124>
2005238: 03 00 80 7b sethi %hi(0x201ec00), %g1
iop = rtems_libio_iop( fd );
200523c: f6 00 60 94 ld [ %g1 + 0x94 ], %i3 ! 201ec94 <rtems_libio_iops>
2005240: 83 2e 20 03 sll %i0, 3, %g1
2005244: b1 2e 20 06 sll %i0, 6, %i0
2005248: b0 26 00 01 sub %i0, %g1, %i0
200524c: b6 06 c0 18 add %i3, %i0, %i3
rtems_libio_check_is_open( iop );
2005250: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
2005254: 80 88 61 00 btst 0x100, %g1
2005258: 02 80 00 3c be 2005348 <readv+0x124>
200525c: 80 88 60 02 btst 2, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
2005260: 02 80 00 3a be 2005348 <readv+0x124> <== NEVER TAKEN
2005264: 80 a6 60 00 cmp %i1, 0
/*
* Argument validation on IO vector
*/
if ( !iov )
2005268: 02 80 00 32 be 2005330 <readv+0x10c>
200526c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
2005270: 04 80 00 30 ble 2005330 <readv+0x10c>
2005274: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
2005278: 14 80 00 2e bg 2005330 <readv+0x10c> <== NEVER TAKEN
200527c: b5 2e a0 03 sll %i2, 3, %i2
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
2005280: 82 10 20 00 clr %g1
2005284: ba 10 20 01 mov 1, %i5
2005288: 10 80 00 03 b 2005294 <readv+0x70>
200528c: 84 10 20 00 clr %g2
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
2005290: 84 10 00 04 mov %g4, %g2
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
2005294: c6 06 40 01 ld [ %i1 + %g1 ], %g3
2005298: 80 a0 e0 00 cmp %g3, 0
200529c: 02 80 00 25 be 2005330 <readv+0x10c>
20052a0: 88 06 40 01 add %i1, %g1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
20052a4: c6 01 20 04 ld [ %g4 + 4 ], %g3
20052a8: 88 00 c0 02 add %g3, %g2, %g4
if ( total < old )
20052ac: 80 a1 00 02 cmp %g4, %g2
20052b0: 06 80 00 20 bl 2005330 <readv+0x10c>
20052b4: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
20052b8: 80 a0 00 03 cmp %g0, %g3
20052bc: 84 40 3f ff addx %g0, -1, %g2
* 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++ ) {
20052c0: 80 a0 40 1a cmp %g1, %i2
20052c4: 12 bf ff f3 bne 2005290 <readv+0x6c>
20052c8: ba 0f 40 02 and %i5, %g2, %i5
/*
* 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 ) {
20052cc: 80 8f 60 ff btst 0xff, %i5
20052d0: 12 80 00 16 bne 2005328 <readv+0x104>
20052d4: b0 10 20 00 clr %i0
20052d8: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
20052dc: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
20052e0: b8 06 40 1d add %i1, %i5, %i4
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
20052e4: d2 06 40 1d ld [ %i1 + %i5 ], %o1
20052e8: c2 00 60 08 ld [ %g1 + 8 ], %g1
20052ec: d4 07 20 04 ld [ %i4 + 4 ], %o2
20052f0: 9f c0 40 00 call %g1
20052f4: 90 10 00 1b mov %i3, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
20052f8: 80 a2 20 00 cmp %o0, 0
20052fc: 26 80 00 0b bl,a 2005328 <readv+0x104> <== NEVER TAKEN
2005300: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
2005304: 32 80 00 02 bne,a 200530c <readv+0xe8> <== ALWAYS TAKEN
2005308: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
200530c: c2 07 20 04 ld [ %i4 + 4 ], %g1
2005310: 80 a2 00 01 cmp %o0, %g1
2005314: 12 80 00 05 bne 2005328 <readv+0x104> <== NEVER TAKEN
2005318: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
200531c: 80 a6 80 1d cmp %i2, %i5
2005320: 32 bf ff f0 bne,a 20052e0 <readv+0xbc>
2005324: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
2005328: 81 c7 e0 08 ret
200532c: 81 e8 00 00 restore
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
2005330: 40 00 2f 82 call 2011138 <__errno>
2005334: b0 10 3f ff mov -1, %i0
2005338: 82 10 20 16 mov 0x16, %g1
200533c: c2 22 00 00 st %g1, [ %o0 ]
2005340: 81 c7 e0 08 ret
2005344: 81 e8 00 00 restore
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
2005348: 40 00 2f 7c call 2011138 <__errno>
200534c: b0 10 3f ff mov -1, %i0
2005350: 82 10 20 09 mov 9, %g1
2005354: c2 22 00 00 st %g1, [ %o0 ]
2005358: 81 c7 e0 08 ret
200535c: 81 e8 00 00 restore
02004528 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
2004528: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
200452c: 3b 00 80 78 sethi %hi(0x201e000), %i5
2004530: ba 17 61 a0 or %i5, 0x1a0, %i5 ! 201e1a0 <rtems_malloc_statistics>
2004534: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
2004538: 03 00 80 7a sethi %hi(0x201e800), %g1
200453c: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 201e838 <_System_state_Current>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
2004540: 84 00 a0 01 inc %g2
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
2004544: 80 a0 60 03 cmp %g1, 3
2004548: 02 80 00 2a be 20045f0 <realloc+0xc8>
200454c: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
}
/*
* Continue with realloc().
*/
if ( !ptr )
2004550: 80 a6 20 00 cmp %i0, 0
2004554: 02 80 00 46 be 200466c <realloc+0x144>
2004558: 80 a6 60 00 cmp %i1, 0
return malloc( size );
if ( !size ) {
200455c: 02 80 00 39 be 2004640 <realloc+0x118> <== NEVER TAKEN
2004560: 39 00 80 75 sethi %hi(0x201d400), %i4
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
2004564: d0 07 23 00 ld [ %i4 + 0x300 ], %o0 ! 201d700 <RTEMS_Malloc_Heap>
2004568: 92 10 00 18 mov %i0, %o1
200456c: 40 00 15 4e call 2009aa4 <_Protected_heap_Get_block_size>
2004570: 94 07 bf fc add %fp, -4, %o2
2004574: 80 8a 20 ff btst 0xff, %o0
2004578: 02 80 00 37 be 2004654 <realloc+0x12c>
200457c: d0 07 23 00 ld [ %i4 + 0x300 ], %o0
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
2004580: 92 10 00 18 mov %i0, %o1
2004584: 40 00 15 58 call 2009ae4 <_Protected_heap_Resize_block>
2004588: 94 10 00 19 mov %i1, %o2
200458c: 80 8a 20 ff btst 0xff, %o0
2004590: 02 80 00 04 be 20045a0 <realloc+0x78>
2004594: 01 00 00 00 nop
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
2004598: 81 c7 e0 08 ret
200459c: 81 e8 00 00 restore
* 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 );
20045a0: 7f ff fd 0e call 20039d8 <malloc>
20045a4: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
20045a8: c2 07 60 04 ld [ %i5 + 4 ], %g1
* 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 );
20045ac: b8 10 00 08 mov %o0, %i4
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
20045b0: 82 00 7f ff add %g1, -1, %g1
if ( !new_area ) {
20045b4: 80 a2 20 00 cmp %o0, 0
20045b8: 02 80 00 17 be 2004614 <realloc+0xec>
20045bc: c2 27 60 04 st %g1, [ %i5 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
20045c0: c2 07 bf fc ld [ %fp + -4 ], %g1
20045c4: 80 a6 40 01 cmp %i1, %g1
20045c8: 18 80 00 15 bgu 200461c <realloc+0xf4> <== ALWAYS TAKEN
20045cc: 94 10 00 19 mov %i1, %o2
20045d0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20045d4: 40 00 31 d2 call 2010d1c <memcpy> <== NOT EXECUTED
20045d8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free( ptr );
20045dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20045e0: 7f ff fc 24 call 2003670 <free> <== NOT EXECUTED
20045e4: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
20045e8: 81 c7 e0 08 ret <== NOT EXECUTED
20045ec: 81 e8 00 00 restore <== NOT EXECUTED
* 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 )
20045f0: 03 00 80 78 sethi %hi(0x201e000), %g1
20045f4: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 201e320 <_Thread_Dispatch_disable_level>
20045f8: 80 a0 60 00 cmp %g1, 0
20045fc: 12 80 00 06 bne 2004614 <realloc+0xec> <== NEVER TAKEN
2004600: 03 00 80 7a sethi %hi(0x201e800), %g1
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
2004604: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 ! 201e848 <_Per_CPU_Information+0x8>
2004608: 80 a0 60 00 cmp %g1, 0
200460c: 02 bf ff d2 be 2004554 <realloc+0x2c> <== ALWAYS TAKEN
2004610: 80 a6 20 00 cmp %i0, 0
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
2004614: 81 c7 e0 08 ret
2004618: 91 e8 20 00 restore %g0, 0, %o0
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
200461c: 92 10 00 18 mov %i0, %o1
2004620: 94 10 00 01 mov %g1, %o2
2004624: 40 00 31 be call 2010d1c <memcpy>
2004628: 90 10 00 1c mov %i4, %o0
free( ptr );
200462c: 90 10 00 18 mov %i0, %o0
2004630: 7f ff fc 10 call 2003670 <free>
2004634: b0 10 00 1c mov %i4, %i0
2004638: 81 c7 e0 08 ret
200463c: 81 e8 00 00 restore
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
2004640: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2004644: 7f ff fc 0b call 2003670 <free> <== NOT EXECUTED
2004648: b0 10 20 00 clr %i0 <== NOT EXECUTED
200464c: 81 c7 e0 08 ret <== NOT EXECUTED
2004650: 81 e8 00 00 restore <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
2004654: 40 00 2f 61 call 20103d8 <__errno>
2004658: b0 10 20 00 clr %i0
200465c: 82 10 20 16 mov 0x16, %g1
2004660: c2 22 00 00 st %g1, [ %o0 ]
2004664: 81 c7 e0 08 ret
2004668: 81 e8 00 00 restore
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
200466c: 7f ff fc db call 20039d8 <malloc>
2004670: 91 e8 00 19 restore %g0, %i1, %o0
020083b8 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
20083b8: 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);
20083bc: 39 00 80 82 sethi %hi(0x2020800), %i4
20083c0: 40 00 02 7b call 2008dac <pthread_mutex_lock>
20083c4: 90 17 20 4c or %i4, 0x4c, %o0 ! 202084c <aio_request_queue>
if (result != 0) {
20083c8: b6 92 20 00 orcc %o0, 0, %i3
20083cc: 12 80 00 31 bne 2008490 <rtems_aio_enqueue+0xd8> <== NEVER TAKEN
20083d0: 90 10 00 18 mov %i0, %o0
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
20083d4: 40 00 04 b6 call 20096ac <pthread_self>
20083d8: b2 17 20 4c or %i4, 0x4c, %i1
20083dc: 92 07 bf e0 add %fp, -32, %o1
20083e0: 40 00 03 a8 call 2009280 <pthread_getschedparam>
20083e4: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
20083e8: 40 00 04 b1 call 20096ac <pthread_self>
20083ec: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
20083f0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
req->policy = policy;
20083f4: c6 07 bf e0 ld [ %fp + -32 ], %g3
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
20083f8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
req->policy = policy;
20083fc: c6 26 20 08 st %g3, [ %i0 + 8 ]
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2008400: c6 07 bf e4 ld [ %fp + -28 ], %g3
/* _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 ();
2008404: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2008408: 84 20 c0 02 sub %g3, %g2, %g2
200840c: c4 26 20 0c st %g2, [ %i0 + 0xc ]
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
2008410: c4 06 60 68 ld [ %i1 + 0x68 ], %g2
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
2008414: 86 10 20 77 mov 0x77, %g3
req->aiocbp->return_value = 0;
2008418: c0 20 60 38 clr [ %g1 + 0x38 ]
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
200841c: c6 20 60 34 st %g3, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
2008420: 80 a0 a0 00 cmp %g2, 0
2008424: 12 80 00 06 bne 200843c <rtems_aio_enqueue+0x84> <== NEVER TAKEN
2008428: d2 00 40 00 ld [ %g1 ], %o1
200842c: c4 06 60 64 ld [ %i1 + 0x64 ], %g2
2008430: 80 a0 a0 04 cmp %g2, 4
2008434: 24 80 00 1b ble,a 20084a0 <rtems_aio_enqueue+0xe8>
2008438: 90 06 60 48 add %i1, 0x48, %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,
200843c: 94 10 20 00 clr %o2
2008440: 11 00 80 82 sethi %hi(0x2020800), %o0
2008444: 7f ff ff 78 call 2008224 <rtems_aio_search_fd>
2008448: 90 12 20 94 or %o0, 0x94, %o0 ! 2020894 <aio_request_queue+0x48>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
200844c: b4 92 20 00 orcc %o0, 0, %i2
2008450: 22 80 00 31 be,a 2008514 <rtems_aio_enqueue+0x15c>
2008454: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
pthread_mutex_lock (&r_chain->mutex);
2008458: b2 06 a0 1c add %i2, 0x1c, %i1
200845c: 40 00 02 54 call 2008dac <pthread_mutex_lock>
2008460: 90 10 00 19 mov %i1, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
2008464: 90 06 a0 08 add %i2, 8, %o0
2008468: 7f ff ff 12 call 20080b0 <rtems_aio_insert_prio>
200846c: 92 10 00 18 mov %i0, %o1
pthread_cond_signal (&r_chain->cond);
2008470: 40 00 01 2c call 2008920 <pthread_cond_signal>
2008474: 90 06 a0 20 add %i2, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
2008478: 40 00 02 6d call 2008e2c <pthread_mutex_unlock>
200847c: 90 10 00 19 mov %i1, %o0
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
2008480: 40 00 02 6b call 2008e2c <pthread_mutex_unlock>
2008484: 90 17 20 4c or %i4, 0x4c, %o0
return 0;
}
2008488: 81 c7 e0 08 ret
200848c: 91 e8 00 1b restore %g0, %i3, %o0
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
2008490: 7f ff ed c7 call 2003bac <free> <== NOT EXECUTED
2008494: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
2008498: 81 c7 e0 08 ret <== NOT EXECUTED
200849c: 81 e8 00 00 restore <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
20084a0: 7f ff ff 61 call 2008224 <rtems_aio_search_fd>
20084a4: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
20084a8: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
20084ac: 80 a0 60 01 cmp %g1, 1
20084b0: 12 bf ff ea bne 2008458 <rtems_aio_enqueue+0xa0>
20084b4: b4 10 00 08 mov %o0, %i2
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
20084b8: 90 02 20 08 add %o0, 8, %o0
20084bc: 40 00 09 56 call 200aa14 <_Chain_Insert>
20084c0: 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);
20084c4: 92 10 20 00 clr %o1
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
20084c8: c0 26 a0 18 clr [ %i2 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
20084cc: 40 00 01 df call 2008c48 <pthread_mutex_init>
20084d0: 90 06 a0 1c add %i2, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
20084d4: 92 10 20 00 clr %o1
20084d8: 40 00 00 e3 call 2008864 <pthread_cond_init>
20084dc: 90 06 a0 20 add %i2, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
20084e0: 90 07 bf dc add %fp, -36, %o0
20084e4: 92 06 60 08 add %i1, 8, %o1
20084e8: 96 10 00 1a mov %i2, %o3
20084ec: 15 00 80 1f sethi %hi(0x2007c00), %o2
20084f0: 40 00 02 c4 call 2009000 <pthread_create>
20084f4: 94 12 a2 04 or %o2, 0x204, %o2 ! 2007e04 <rtems_aio_handle>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
20084f8: 82 92 20 00 orcc %o0, 0, %g1
20084fc: 12 80 00 25 bne 2008590 <rtems_aio_enqueue+0x1d8> <== NEVER TAKEN
2008500: 90 10 00 19 mov %i1, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
2008504: c2 06 60 64 ld [ %i1 + 0x64 ], %g1
2008508: 82 00 60 01 inc %g1
200850c: 10 bf ff dd b 2008480 <rtems_aio_enqueue+0xc8>
2008510: c2 26 60 64 st %g1, [ %i1 + 0x64 ]
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
2008514: 11 00 80 82 sethi %hi(0x2020800), %o0
2008518: d2 00 40 00 ld [ %g1 ], %o1
200851c: 90 12 20 a0 or %o0, 0xa0, %o0
2008520: 7f ff ff 41 call 2008224 <rtems_aio_search_fd>
2008524: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2008528: 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);
200852c: b4 10 00 08 mov %o0, %i2
2008530: 92 10 00 18 mov %i0, %o1
if (r_chain->new_fd == 1) {
2008534: 80 a0 60 01 cmp %g1, 1
2008538: 02 80 00 0b be 2008564 <rtems_aio_enqueue+0x1ac>
200853c: 90 02 20 08 add %o0, 8, %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);
2008540: 7f ff fe dc call 20080b0 <rtems_aio_insert_prio>
2008544: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
2008548: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
200854c: 80 a0 60 00 cmp %g1, 0
2008550: 04 bf ff cc ble 2008480 <rtems_aio_enqueue+0xc8> <== ALWAYS TAKEN
2008554: 01 00 00 00 nop
pthread_cond_signal (&aio_request_queue.new_req);
2008558: 40 00 00 f2 call 2008920 <pthread_cond_signal> <== NOT EXECUTED
200855c: 90 06 60 04 add %i1, 4, %o0 <== NOT EXECUTED
2008560: 30 bf ff c8 b,a 2008480 <rtems_aio_enqueue+0xc8> <== NOT EXECUTED
2008564: 40 00 09 2c call 200aa14 <_Chain_Insert>
2008568: 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);
200856c: 90 06 a0 1c add %i2, 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;
2008570: c0 26 a0 18 clr [ %i2 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
2008574: 40 00 01 b5 call 2008c48 <pthread_mutex_init>
2008578: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
200857c: 90 06 a0 20 add %i2, 0x20, %o0
2008580: 40 00 00 b9 call 2008864 <pthread_cond_init>
2008584: 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)
2008588: 10 bf ff f1 b 200854c <rtems_aio_enqueue+0x194>
200858c: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
2008590: 40 00 02 27 call 2008e2c <pthread_mutex_unlock> <== NOT EXECUTED
2008594: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
2008598: 30 bf ff bc b,a 2008488 <rtems_aio_enqueue+0xd0> <== NOT EXECUTED
02007e04 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
2007e04: 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);
2007e08: 35 00 80 82 sethi %hi(0x2020800), %i2
2007e0c: b6 06 20 1c add %i0, 0x1c, %i3
2007e10: b4 16 a0 4c or %i2, 0x4c, %i2
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007e14: a0 10 00 1a mov %i2, %l0
2007e18: a2 10 00 1a mov %i2, %l1
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)) {
2007e1c: a4 06 a0 58 add %i2, 0x58, %l2
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 &&
2007e20: b2 06 a0 4c add %i2, 0x4c, %i1
/* 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);
2007e24: 40 00 03 e2 call 2008dac <pthread_mutex_lock>
2007e28: 90 10 00 1b mov %i3, %o0
if (result != 0)
2007e2c: 80 a2 20 00 cmp %o0, 0
2007e30: 12 80 00 2b bne 2007edc <rtems_aio_handle+0xd8> <== NEVER TAKEN
2007e34: 01 00 00 00 nop
2007e38: fa 06 20 08 ld [ %i0 + 8 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2007e3c: 82 06 20 0c add %i0, 0xc, %g1
/* 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)) {
2007e40: 80 a7 40 01 cmp %i5, %g1
2007e44: 02 80 00 41 be 2007f48 <rtems_aio_handle+0x144>
2007e48: 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);
2007e4c: 40 00 06 18 call 20096ac <pthread_self>
2007e50: 01 00 00 00 nop
2007e54: 92 07 bf d8 add %fp, -40, %o1
2007e58: 40 00 05 0a call 2009280 <pthread_getschedparam>
2007e5c: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
2007e60: c2 07 60 0c ld [ %i5 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
2007e64: 40 00 06 12 call 20096ac <pthread_self>
2007e68: c2 27 bf e4 st %g1, [ %fp + -28 ]
2007e6c: d2 07 60 08 ld [ %i5 + 8 ], %o1
2007e70: 40 00 06 13 call 20096bc <pthread_setschedparam>
2007e74: 94 07 bf e4 add %fp, -28, %o2
2007e78: 40 00 0a ce call 200a9b0 <_Chain_Extract>
2007e7c: 90 10 00 1d mov %i5, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
2007e80: 40 00 03 eb call 2008e2c <pthread_mutex_unlock>
2007e84: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
2007e88: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
2007e8c: c2 07 20 30 ld [ %i4 + 0x30 ], %g1
2007e90: 80 a0 60 02 cmp %g1, 2
2007e94: 22 80 00 25 be,a 2007f28 <rtems_aio_handle+0x124>
2007e98: c4 1f 20 08 ldd [ %i4 + 8 ], %g2
2007e9c: 80 a0 60 03 cmp %g1, 3
2007ea0: 02 80 00 1e be 2007f18 <rtems_aio_handle+0x114> <== NEVER TAKEN
2007ea4: 01 00 00 00 nop
2007ea8: 80 a0 60 01 cmp %g1, 1
2007eac: 22 80 00 0e be,a 2007ee4 <rtems_aio_handle+0xe0> <== ALWAYS TAKEN
2007eb0: c4 1f 20 08 ldd [ %i4 + 8 ], %g2
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
2007eb4: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
2007eb8: 40 00 2a 60 call 2012838 <__errno> <== NOT EXECUTED
2007ebc: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
2007ec0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
2007ec4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2007ec8: 40 00 03 b9 call 2008dac <pthread_mutex_lock> <== NOT EXECUTED
2007ecc: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
if (result != 0)
2007ed0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2007ed4: 22 bf ff da be,a 2007e3c <rtems_aio_handle+0x38> <== NOT EXECUTED
2007ed8: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007edc: 81 c7 e0 08 ret
2007ee0: 91 e8 20 00 restore %g0, 0, %o0
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
2007ee4: d0 07 00 00 ld [ %i4 ], %o0
2007ee8: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
2007eec: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
2007ef0: 96 10 00 02 mov %g2, %o3
2007ef4: 40 00 2d 57 call 2013450 <pread>
2007ef8: 98 10 00 03 mov %g3, %o4
break;
default:
result = -1;
}
if (result == -1) {
2007efc: 80 a2 3f ff cmp %o0, -1
2007f00: 22 bf ff ed be,a 2007eb4 <rtems_aio_handle+0xb0> <== NEVER TAKEN
2007f04: f8 07 60 14 ld [ %i5 + 0x14 ], %i4 <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
2007f08: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2007f0c: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
2007f10: 10 bf ff c5 b 2007e24 <rtems_aio_handle+0x20>
2007f14: c0 20 60 34 clr [ %g1 + 0x34 ]
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
2007f18: 40 00 1c 3d call 200f00c <fsync> <== NOT EXECUTED
2007f1c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
break;
2007f20: 10 bf ff f8 b 2007f00 <rtems_aio_handle+0xfc> <== NOT EXECUTED
2007f24: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
2007f28: d0 07 00 00 ld [ %i4 ], %o0
2007f2c: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
2007f30: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
2007f34: 96 10 00 02 mov %g2, %o3
2007f38: 40 00 2d 84 call 2013548 <pwrite>
2007f3c: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007f40: 10 bf ff f0 b 2007f00 <rtems_aio_handle+0xfc>
2007f44: 80 a2 3f ff cmp %o0, -1
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
2007f48: 40 00 03 b9 call 2008e2c <pthread_mutex_unlock>
2007f4c: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
2007f50: 40 00 03 97 call 2008dac <pthread_mutex_lock>
2007f54: 90 10 00 1a mov %i2, %o0
if (rtems_chain_is_empty (chain))
2007f58: c2 06 20 08 ld [ %i0 + 8 ], %g1
2007f5c: 80 a7 40 01 cmp %i5, %g1
2007f60: 02 80 00 05 be 2007f74 <rtems_aio_handle+0x170> <== ALWAYS TAKEN
2007f64: 92 07 bf dc add %fp, -36, %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);
2007f68: 40 00 03 b1 call 2008e2c <pthread_mutex_unlock>
2007f6c: 90 10 00 1a mov %i2, %o0
2007f70: 30 bf ff ad b,a 2007e24 <rtems_aio_handle+0x20>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
2007f74: 40 00 01 d3 call 20086c0 <clock_gettime>
2007f78: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
2007f7c: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
2007f80: c0 27 bf e0 clr [ %fp + -32 ]
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007f84: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007f88: ba 06 20 20 add %i0, 0x20, %i5
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007f8c: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007f90: 90 10 00 1d mov %i5, %o0
2007f94: 92 10 00 10 mov %l0, %o1
2007f98: 40 00 02 7e call 2008990 <pthread_cond_timedwait>
2007f9c: 94 07 bf dc add %fp, -36, %o2
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
2007fa0: 80 a2 20 74 cmp %o0, 0x74
2007fa4: 12 bf ff f1 bne 2007f68 <rtems_aio_handle+0x164> <== NEVER TAKEN
2007fa8: 01 00 00 00 nop
2007fac: 40 00 0a 81 call 200a9b0 <_Chain_Extract>
2007fb0: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
2007fb4: 40 00 02 d2 call 2008afc <pthread_mutex_destroy>
2007fb8: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
2007fbc: 40 00 01 f4 call 200878c <pthread_cond_destroy>
2007fc0: 90 10 00 1d mov %i5, %o0
free (r_chain);
2007fc4: 7f ff ee fa call 2003bac <free>
2007fc8: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2007fcc: f0 06 a0 54 ld [ %i2 + 0x54 ], %i0
/* 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)) {
2007fd0: 80 a6 00 12 cmp %i0, %l2
2007fd4: 22 80 00 1d be,a 2008048 <rtems_aio_handle+0x244>
2007fd8: c4 06 a0 68 ld [ %i2 + 0x68 ], %g2
}
}
/* 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;
2007fdc: c4 04 60 68 ld [ %l1 + 0x68 ], %g2
++aio_request_queue.active_threads;
2007fe0: c2 04 60 64 ld [ %l1 + 0x64 ], %g1
}
}
/* 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;
2007fe4: 84 00 bf ff add %g2, -1, %g2
++aio_request_queue.active_threads;
2007fe8: 82 00 60 01 inc %g1
}
}
/* 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;
2007fec: c4 24 60 68 st %g2, [ %l1 + 0x68 ]
++aio_request_queue.active_threads;
2007ff0: c2 24 60 64 st %g1, [ %l1 + 0x64 ]
2007ff4: 40 00 0a 6f call 200a9b0 <_Chain_Extract>
2007ff8: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2007ffc: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
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 &&
2008000: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
2008004: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
2008008: 80 a0 c0 02 cmp %g3, %g2
200800c: 14 80 00 08 bg 200802c <rtems_aio_handle+0x228> <== ALWAYS TAKEN
2008010: 80 a0 40 19 cmp %g1, %i1
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
2008014: 10 80 00 09 b 2008038 <rtems_aio_handle+0x234> <== NOT EXECUTED
2008018: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
200801c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
2008020: 80 a0 80 03 cmp %g2, %g3
2008024: 16 80 00 04 bge 2008034 <rtems_aio_handle+0x230>
2008028: 80 a0 40 19 cmp %g1, %i1
200802c: 32 bf ff fc bne,a 200801c <rtems_aio_handle+0x218> <== ALWAYS TAKEN
2008030: c2 00 40 00 ld [ %g1 ], %g1
2008034: d0 00 60 04 ld [ %g1 + 4 ], %o0
2008038: 92 10 00 18 mov %i0, %o1
200803c: 40 00 0a 76 call 200aa14 <_Chain_Insert>
2008040: b6 06 20 1c add %i0, 0x1c, %i3
2008044: 30 bf ff c9 b,a 2007f68 <rtems_aio_handle+0x164>
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;
2008048: c2 06 a0 64 ld [ %i2 + 0x64 ], %g1
/* 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;
200804c: 84 00 a0 01 inc %g2
--aio_request_queue.active_threads;
2008050: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2008054: 92 07 bf dc add %fp, -36, %o1
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
2008058: c4 26 a0 68 st %g2, [ %i2 + 0x68 ]
--aio_request_queue.active_threads;
200805c: c2 26 a0 64 st %g1, [ %i2 + 0x64 ]
clock_gettime (CLOCK_REALTIME, &timeout);
2008060: 40 00 01 98 call 20086c0 <clock_gettime>
2008064: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
2008068: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
200806c: c0 27 bf e0 clr [ %fp + -32 ]
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2008070: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2008074: 90 06 a0 04 add %i2, 4, %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;
2008078: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
200807c: 92 10 00 1a mov %i2, %o1
2008080: 40 00 02 44 call 2008990 <pthread_cond_timedwait>
2008084: 94 07 bf dc add %fp, -36, %o2
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
2008088: 80 a2 20 74 cmp %o0, 0x74
200808c: 22 80 00 04 be,a 200809c <rtems_aio_handle+0x298> <== ALWAYS TAKEN
2008090: c2 06 a0 68 ld [ %i2 + 0x68 ], %g1
2008094: 10 bf ff d2 b 2007fdc <rtems_aio_handle+0x1d8> <== NOT EXECUTED
2008098: f0 06 a0 54 ld [ %i2 + 0x54 ], %i0 <== NOT EXECUTED
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
200809c: 90 10 00 1a mov %i2, %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;
20080a0: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
20080a4: 40 00 03 62 call 2008e2c <pthread_mutex_unlock>
20080a8: c2 26 a0 68 st %g1, [ %i2 + 0x68 ]
20080ac: 30 bf ff 8c b,a 2007edc <rtems_aio_handle+0xd8>
0200811c <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
200811c: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
2008120: 3b 00 80 82 sethi %hi(0x2020800), %i5
2008124: 40 00 03 9c call 2008f94 <pthread_attr_init>
2008128: 90 17 60 54 or %i5, 0x54, %o0 ! 2020854 <aio_request_queue+0x8>
if (result != 0)
200812c: b0 92 20 00 orcc %o0, 0, %i0
2008130: 12 80 00 23 bne 20081bc <rtems_aio_init+0xa0> <== NEVER TAKEN
2008134: 90 17 60 54 or %i5, 0x54, %o0
return result;
result =
2008138: 40 00 03 a3 call 2008fc4 <pthread_attr_setdetachstate>
200813c: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
2008140: 80 a2 20 00 cmp %o0, 0
2008144: 12 80 00 20 bne 20081c4 <rtems_aio_init+0xa8> <== NEVER TAKEN
2008148: 39 00 80 82 sethi %hi(0x2020800), %i4
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
200814c: 92 10 20 00 clr %o1
2008150: 40 00 02 be call 2008c48 <pthread_mutex_init>
2008154: 90 17 20 4c or %i4, 0x4c, %o0
if (result != 0)
2008158: 80 a2 20 00 cmp %o0, 0
200815c: 12 80 00 23 bne 20081e8 <rtems_aio_init+0xcc> <== NEVER TAKEN
2008160: 92 10 20 00 clr %o1
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
2008164: 11 00 80 82 sethi %hi(0x2020800), %o0
2008168: 40 00 01 bf call 2008864 <pthread_cond_init>
200816c: 90 12 20 50 or %o0, 0x50, %o0 ! 2020850 <aio_request_queue+0x4>
if (result != 0) {
2008170: b0 92 20 00 orcc %o0, 0, %i0
2008174: 12 80 00 26 bne 200820c <rtems_aio_init+0xf0> <== NEVER TAKEN
2008178: 01 00 00 00 nop
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200817c: 82 17 20 4c or %i4, 0x4c, %g1
head->previous = NULL;
tail->previous = head;
2008180: 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;
2008184: ba 00 60 4c add %g1, 0x4c, %i5
head->previous = NULL;
tail->previous = head;
2008188: 88 00 60 48 add %g1, 0x48, %g4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200818c: 86 00 60 58 add %g1, 0x58, %g3
head->previous = NULL;
tail->previous = head;
2008190: 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;
2008194: fa 20 60 48 st %i5, [ %g1 + 0x48 ]
head->previous = NULL;
2008198: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
200819c: c8 20 60 50 st %g4, [ %g1 + 0x50 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
20081a0: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
head->previous = NULL;
20081a4: 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;
20081a8: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
20081ac: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
20081b0: 05 00 00 2c sethi %hi(0xb000), %g2
20081b4: 84 10 a0 0b or %g2, 0xb, %g2 ! b00b <PROM_START+0xb00b>
20081b8: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
20081bc: 81 c7 e0 08 ret
20081c0: 81 e8 00 00 restore
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
20081c4: 40 00 03 68 call 2008f64 <pthread_attr_destroy> <== NOT EXECUTED
20081c8: 90 17 60 54 or %i5, 0x54, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
20081cc: 39 00 80 82 sethi %hi(0x2020800), %i4 <== NOT EXECUTED
20081d0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20081d4: 40 00 02 9d call 2008c48 <pthread_mutex_init> <== NOT EXECUTED
20081d8: 90 17 20 4c or %i4, 0x4c, %o0 <== NOT EXECUTED
if (result != 0)
20081dc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20081e0: 02 bf ff e1 be 2008164 <rtems_aio_init+0x48> <== NOT EXECUTED
20081e4: 92 10 20 00 clr %o1 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
20081e8: 40 00 03 5f call 2008f64 <pthread_attr_destroy> <== NOT EXECUTED
20081ec: 90 17 60 54 or %i5, 0x54, %o0 <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
20081f0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20081f4: 11 00 80 82 sethi %hi(0x2020800), %o0 <== NOT EXECUTED
20081f8: 40 00 01 9b call 2008864 <pthread_cond_init> <== NOT EXECUTED
20081fc: 90 12 20 50 or %o0, 0x50, %o0 ! 2020850 <aio_request_queue+0x4><== NOT EXECUTED
if (result != 0) {
2008200: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2008204: 22 bf ff df be,a 2008180 <rtems_aio_init+0x64> <== NOT EXECUTED
2008208: 82 17 20 4c or %i4, 0x4c, %g1 <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
200820c: 40 00 02 3c call 2008afc <pthread_mutex_destroy> <== NOT EXECUTED
2008210: 90 17 20 4c or %i4, 0x4c, %o0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
2008214: 40 00 03 54 call 2008f64 <pthread_attr_destroy> <== NOT EXECUTED
2008218: 90 17 60 54 or %i5, 0x54, %o0 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200821c: 10 bf ff d9 b 2008180 <rtems_aio_init+0x64> <== NOT EXECUTED
2008220: 82 17 20 4c or %i4, 0x4c, %g1 <== NOT EXECUTED
020080b0 <rtems_aio_insert_prio>:
20080b0: c2 02 00 00 ld [ %o0 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
20080b4: 88 02 20 04 add %o0, 4, %g4
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
20080b8: 80 a0 40 04 cmp %g1, %g4
20080bc: 02 80 00 15 be 2008110 <rtems_aio_insert_prio+0x60> <== NEVER TAKEN
20080c0: 9a 10 00 09 mov %o1, %o5
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 &&
20080c4: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
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;
20080c8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
while (req->aiocbp->aio_reqprio > prio &&
20080cc: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
20080d0: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2
20080d4: 80 a0 80 03 cmp %g2, %g3
20080d8: 26 80 00 07 bl,a 20080f4 <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
20080dc: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
20080e0: 10 80 00 0b b 200810c <rtems_aio_insert_prio+0x5c>
20080e4: d0 00 60 04 ld [ %g1 + 4 ], %o0
20080e8: 22 80 00 09 be,a 200810c <rtems_aio_insert_prio+0x5c> <== NOT EXECUTED
20080ec: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
20080f0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
20080f4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== 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 &&
20080f8: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2 <== NOT EXECUTED
20080fc: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
2008100: 06 bf ff fa bl 20080e8 <rtems_aio_insert_prio+0x38> <== NOT EXECUTED
2008104: 80 a1 00 01 cmp %g4, %g1 <== NOT EXECUTED
2008108: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
200810c: 92 10 00 0d mov %o5, %o1
2008110: 82 13 c0 00 mov %o7, %g1
2008114: 40 00 0a 40 call 200aa14 <_Chain_Insert>
2008118: 9e 10 40 00 mov %g1, %o7
020082f8 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
20082f8: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20082fc: fa 06 20 08 ld [ %i0 + 8 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
2008300: b0 06 20 0c add %i0, 0xc, %i0
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
2008304: 80 a7 40 18 cmp %i5, %i0
2008308: 02 80 00 0e be 2008340 <rtems_aio_remove_fd+0x48> <== NEVER TAKEN
200830c: b6 10 20 8c mov 0x8c, %i3
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2008310: 40 00 09 a8 call 200a9b0 <_Chain_Extract>
2008314: 90 10 00 1d mov %i5, %o0
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
2008318: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200831c: f8 07 40 00 ld [ %i5 ], %i4
req->aiocbp->return_value = -1;
2008320: 84 10 3f ff mov -1, %g2
free (req);
2008324: 90 10 00 1d mov %i5, %o0
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
2008328: f6 20 60 34 st %i3, [ %g1 + 0x34 ]
req->aiocbp->return_value = -1;
free (req);
200832c: 7f ff ee 20 call 2003bac <free>
2008330: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
2008334: 80 a7 00 18 cmp %i4, %i0
2008338: 12 bf ff f6 bne 2008310 <rtems_aio_remove_fd+0x18>
200833c: ba 10 00 1c mov %i4, %i5
2008340: 81 c7 e0 08 ret
2008344: 81 e8 00 00 restore
02008348 <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)
{
2008348: 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;
200834c: 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 );
2008350: 84 06 20 04 add %i0, 4, %g2
if (rtems_chain_is_empty (chain))
2008354: 80 a7 40 02 cmp %i5, %g2
2008358: 12 80 00 06 bne 2008370 <rtems_aio_remove_req+0x28>
200835c: b0 10 20 02 mov 2, %i0
2008360: 30 80 00 12 b,a 20083a8 <rtems_aio_remove_req+0x60>
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) {
2008364: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
2008368: 02 80 00 12 be 20083b0 <rtems_aio_remove_req+0x68> <== NOT EXECUTED
200836c: 01 00 00 00 nop <== NOT EXECUTED
2008370: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2008374: 80 a0 40 19 cmp %g1, %i1
2008378: 32 bf ff fb bne,a 2008364 <rtems_aio_remove_req+0x1c> <== NEVER TAKEN
200837c: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
2008380: 40 00 09 8c call 200a9b0 <_Chain_Extract>
2008384: 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;
2008388: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
current->aiocbp->return_value = -1;
200838c: 84 10 3f ff mov -1, %g2
2008390: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
2008394: 84 10 20 8c mov 0x8c, %g2
current->aiocbp->return_value = -1;
free (current);
2008398: 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;
200839c: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
free (current);
20083a0: 7f ff ee 03 call 2003bac <free>
20083a4: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
20083a8: 81 c7 e0 08 ret
20083ac: 81 e8 00 00 restore
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
20083b0: 81 c7 e0 08 ret <== NOT EXECUTED
20083b4: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
0200f840 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
200f840: 9d e3 bf a0 save %sp, -96, %sp
200f844: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
200f848: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
200f84c: 10 80 00 04 b 200f85c <rtems_assoc_local_by_remote_bitfield+0x1c>
200f850: ba 10 20 01 mov 1, %i5
200f854: 02 80 00 0c be 200f884 <rtems_assoc_local_by_remote_bitfield+0x44>
200f858: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
200f85c: 80 8f 40 19 btst %i5, %i1
200f860: 22 bf ff fd be,a 200f854 <rtems_assoc_local_by_remote_bitfield+0x14>
200f864: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
200f868: 92 10 00 1d mov %i5, %o1
200f86c: 40 00 00 08 call 200f88c <rtems_assoc_local_by_remote>
200f870: 90 10 00 18 mov %i0, %o0
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
200f874: bb 2f 60 01 sll %i5, 1, %i5
200f878: b8 87 3f ff addcc %i4, -1, %i4
200f87c: 12 bf ff f8 bne 200f85c <rtems_assoc_local_by_remote_bitfield+0x1c><== ALWAYS TAKEN
200f880: b6 16 c0 08 or %i3, %o0, %i3
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
200f884: 81 c7 e0 08 ret
200f888: 91 e8 00 1b restore %g0, %i3, %o0
0200c68c <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
200c68c: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
200c690: d0 06 00 00 ld [ %i0 ], %o0
200c694: 80 a2 20 00 cmp %o0, 0
200c698: 02 80 00 1d be 200c70c <rtems_assoc_ptr_by_local+0x80>
200c69c: 13 00 80 71 sethi %hi(0x201c400), %o1
200c6a0: 40 00 12 e8 call 2011240 <strcmp>
200c6a4: 92 12 60 c8 or %o1, 0xc8, %o1 ! 201c4c8 <IMFS_memfile_handlers+0x30>
200c6a8: 80 a2 20 00 cmp %o0, 0
200c6ac: 22 80 00 12 be,a 200c6f4 <rtems_assoc_ptr_by_local+0x68>
200c6b0: c4 06 20 0c ld [ %i0 + 0xc ], %g2
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
200c6b4: 84 10 20 00 clr %g2
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
200c6b8: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c6bc: 80 a0 40 19 cmp %g1, %i1
200c6c0: 32 80 00 07 bne,a 200c6dc <rtems_assoc_ptr_by_local+0x50>
200c6c4: b0 06 20 0c add %i0, 0xc, %i0
200c6c8: 30 80 00 13 b,a 200c714 <rtems_assoc_ptr_by_local+0x88>
200c6cc: 80 a0 40 19 cmp %g1, %i1
200c6d0: 02 80 00 11 be 200c714 <rtems_assoc_ptr_by_local+0x88>
200c6d4: 01 00 00 00 nop
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
200c6d8: b0 06 20 0c add %i0, 0xc, %i0
200c6dc: c2 06 00 00 ld [ %i0 ], %g1
200c6e0: 80 a0 60 00 cmp %g1, 0
200c6e4: 32 bf ff fa bne,a 200c6cc <rtems_assoc_ptr_by_local+0x40>
200c6e8: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c6ec: 81 c7 e0 08 ret
200c6f0: 91 e8 00 02 restore %g0, %g2, %o0
200c6f4: 80 a0 a0 00 cmp %g2, 0
200c6f8: 02 80 00 07 be 200c714 <rtems_assoc_ptr_by_local+0x88> <== NEVER TAKEN
200c6fc: 82 06 20 0c add %i0, 0xc, %g1
200c700: 84 10 00 18 mov %i0, %g2
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
200c704: 10 bf ff ed b 200c6b8 <rtems_assoc_ptr_by_local+0x2c>
200c708: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
200c70c: 81 c7 e0 08 ret
200c710: 91 e8 20 00 restore %g0, 0, %o0
200c714: 81 c7 e0 08 ret
200c718: 81 e8 00 00 restore
02003ed0 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
2003ed0: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
2003ed4: fa 06 00 00 ld [ %i0 ], %i5
2003ed8: 80 a7 60 00 cmp %i5, 0
2003edc: 02 80 00 1e be 2003f54 <rtems_assoc_ptr_by_name+0x84>
2003ee0: 90 10 00 1d mov %i5, %o0
2003ee4: 13 00 80 71 sethi %hi(0x201c400), %o1
2003ee8: 40 00 37 8b call 2011d14 <strcmp>
2003eec: 92 12 62 70 or %o1, 0x270, %o1 ! 201c670 <_rodata_start+0x780>
2003ef0: 80 a2 20 00 cmp %o0, 0
2003ef4: 22 80 00 10 be,a 2003f34 <rtems_assoc_ptr_by_name+0x64>
2003ef8: fa 06 20 0c ld [ %i0 + 0xc ], %i5
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
2003efc: 10 80 00 06 b 2003f14 <rtems_assoc_ptr_by_name+0x44>
2003f00: b8 10 20 00 clr %i4
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
2003f04: fa 06 00 00 ld [ %i0 ], %i5
2003f08: 80 a7 60 00 cmp %i5, 0
2003f0c: 02 80 00 10 be 2003f4c <rtems_assoc_ptr_by_name+0x7c>
2003f10: 01 00 00 00 nop
if (strcmp(ap->name, name) == 0)
2003f14: 90 10 00 1d mov %i5, %o0
2003f18: 40 00 37 7f call 2011d14 <strcmp>
2003f1c: 92 10 00 19 mov %i1, %o1
2003f20: 80 a2 20 00 cmp %o0, 0
2003f24: 32 bf ff f8 bne,a 2003f04 <rtems_assoc_ptr_by_name+0x34>
2003f28: b0 06 20 0c add %i0, 0xc, %i0
return ap;
return default_ap;
}
2003f2c: 81 c7 e0 08 ret
2003f30: 81 e8 00 00 restore
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
2003f34: 80 a7 60 00 cmp %i5, 0
2003f38: 02 bf ff fd be 2003f2c <rtems_assoc_ptr_by_name+0x5c> <== NEVER TAKEN
2003f3c: 82 06 20 0c add %i0, 0xc, %g1
2003f40: b8 10 00 18 mov %i0, %i4
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
2003f44: 10 bf ff f4 b 2003f14 <rtems_assoc_ptr_by_name+0x44>
2003f48: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
2003f4c: 81 c7 e0 08 ret
2003f50: 91 e8 00 1c restore %g0, %i4, %o0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
2003f54: 81 c7 e0 08 ret
2003f58: 91 e8 20 00 restore %g0, 0, %o0
0200f8c8 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
200f8c8: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
200f8cc: d0 06 00 00 ld [ %i0 ], %o0
200f8d0: 80 a2 20 00 cmp %o0, 0
200f8d4: 02 80 00 1d be 200f948 <rtems_assoc_ptr_by_remote+0x80>
200f8d8: 13 00 80 71 sethi %hi(0x201c400), %o1
200f8dc: 40 00 06 59 call 2011240 <strcmp>
200f8e0: 92 12 60 c8 or %o1, 0xc8, %o1 ! 201c4c8 <IMFS_memfile_handlers+0x30>
200f8e4: 80 a2 20 00 cmp %o0, 0
200f8e8: 22 80 00 12 be,a 200f930 <rtems_assoc_ptr_by_remote+0x68>
200f8ec: c4 06 20 0c ld [ %i0 + 0xc ], %g2
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
200f8f0: 84 10 20 00 clr %g2
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
200f8f4: c2 06 20 08 ld [ %i0 + 8 ], %g1
200f8f8: 80 a0 40 19 cmp %g1, %i1
200f8fc: 32 80 00 07 bne,a 200f918 <rtems_assoc_ptr_by_remote+0x50>
200f900: b0 06 20 0c add %i0, 0xc, %i0
200f904: 30 80 00 13 b,a 200f950 <rtems_assoc_ptr_by_remote+0x88>
200f908: 80 a0 40 19 cmp %g1, %i1
200f90c: 02 80 00 11 be 200f950 <rtems_assoc_ptr_by_remote+0x88>
200f910: 01 00 00 00 nop
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
200f914: b0 06 20 0c add %i0, 0xc, %i0
200f918: c2 06 00 00 ld [ %i0 ], %g1
200f91c: 80 a0 60 00 cmp %g1, 0
200f920: 32 bf ff fa bne,a 200f908 <rtems_assoc_ptr_by_remote+0x40>
200f924: c2 06 20 08 ld [ %i0 + 8 ], %g1
200f928: 81 c7 e0 08 ret
200f92c: 91 e8 00 02 restore %g0, %g2, %o0
200f930: 80 a0 a0 00 cmp %g2, 0
200f934: 02 80 00 07 be 200f950 <rtems_assoc_ptr_by_remote+0x88> <== NEVER TAKEN
200f938: 82 06 20 0c add %i0, 0xc, %g1
200f93c: 84 10 00 18 mov %i0, %g2
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
200f940: 10 bf ff ed b 200f8f4 <rtems_assoc_ptr_by_remote+0x2c>
200f944: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
200f948: 81 c7 e0 08 ret
200f94c: 91 e8 20 00 restore %g0, 0, %o0
200f950: 81 c7 e0 08 ret
200f954: 81 e8 00 00 restore
02003fec <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
2003fec: 9d e3 bf a0 save %sp, -96, %sp
2003ff0: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t remote_value = 0;
2003ff4: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1)
2003ff8: 10 80 00 04 b 2004008 <rtems_assoc_remote_by_local_bitfield+0x1c>
2003ffc: ba 10 20 01 mov 1, %i5
2004000: 02 80 00 0c be 2004030 <rtems_assoc_remote_by_local_bitfield+0x44>
2004004: bb 2f 60 01 sll %i5, 1, %i5
if (b & local_value)
2004008: 80 8f 40 19 btst %i5, %i1
200400c: 22 bf ff fd be,a 2004000 <rtems_assoc_remote_by_local_bitfield+0x14>
2004010: b8 87 3f ff addcc %i4, -1, %i4
remote_value |= rtems_assoc_remote_by_local(ap, b);
2004014: 92 10 00 1d mov %i5, %o1
2004018: 40 00 00 08 call 2004038 <rtems_assoc_remote_by_local>
200401c: 90 10 00 18 mov %i0, %o0
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
2004020: bb 2f 60 01 sll %i5, 1, %i5
2004024: b8 87 3f ff addcc %i4, -1, %i4
2004028: 12 bf ff f8 bne 2004008 <rtems_assoc_remote_by_local_bitfield+0x1c><== ALWAYS TAKEN
200402c: b6 16 c0 08 or %i3, %o0, %i3
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
2004030: 81 c7 e0 08 ret
2004034: 91 e8 00 1b restore %g0, %i3, %o0
0200d730 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
200d730: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
200d734: 3b 00 80 89 sethi %hi(0x2022400), %i5
200d738: ba 17 63 0c or %i5, 0x30c, %i5 ! 202270c <bdbuf_cache>
200d73c: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
200d740: 80 a0 60 00 cmp %g1, 0
200d744: 22 80 00 08 be,a 200d764 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== ALWAYS TAKEN
200d748: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
200d74c: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
200d750: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
200d754: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200d758: 02 80 00 2b be 200d804 <rtems_bdbuf_add_to_modified_list_after_access+0xd4><== NOT EXECUTED
200d75c: 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
200d760: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
200d764: 80 a0 60 05 cmp %g1, 5
200d768: 22 80 00 16 be,a 200d7c0 <rtems_bdbuf_add_to_modified_list_after_access+0x90>
200d76c: 03 00 80 7f sethi %hi(0x201fc00), %g1
200d770: 80 a0 60 03 cmp %g1, 3
200d774: 02 80 00 13 be 200d7c0 <rtems_bdbuf_add_to_modified_list_after_access+0x90>
200d778: 03 00 80 7f sethi %hi(0x201fc00), %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d77c: 84 10 20 07 mov 7, %g2
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200d780: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
200d784: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
the_node->next = tail;
200d788: 84 07 60 50 add %i5, 0x50, %g2
tail->previous = the_node;
200d78c: f0 27 60 54 st %i0, [ %i5 + 0x54 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200d790: c4 26 00 00 st %g2, [ %i0 ]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
200d794: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
200d798: c2 26 20 04 st %g1, [ %i0 + 4 ]
200d79c: 80 a0 a0 00 cmp %g2, 0
200d7a0: 12 80 00 15 bne 200d7f4 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
200d7a4: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
200d7a8: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
200d7ac: 80 a0 60 00 cmp %g1, 0
200d7b0: 12 80 00 13 bne 200d7fc <rtems_bdbuf_add_to_modified_list_after_access+0xcc>
200d7b4: 01 00 00 00 nop
200d7b8: 81 c7 e0 08 ret
200d7bc: 81 e8 00 00 restore
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
200d7c0: c2 00 60 c8 ld [ %g1 + 0xc8 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d7c4: 84 10 20 07 mov 7, %g2
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
200d7c8: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200d7cc: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d7d0: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
the_node->next = tail;
200d7d4: 84 07 60 50 add %i5, 0x50, %g2
tail->previous = the_node;
200d7d8: f0 27 60 54 st %i0, [ %i5 + 0x54 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200d7dc: c4 26 00 00 st %g2, [ %i0 ]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
200d7e0: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
200d7e4: c2 26 20 04 st %g1, [ %i0 + 4 ]
200d7e8: 80 a0 a0 00 cmp %g2, 0
200d7ec: 02 bf ff ef be 200d7a8 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
200d7f0: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200d7f4: 7f ff ff c0 call 200d6f4 <rtems_bdbuf_wake>
200d7f8: 91 ef 60 64 restore %i5, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
200d7fc: 7f ff ff 23 call 200d488 <rtems_bdbuf_wake_swapper>
200d800: 81 e8 00 00 restore
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
{
rtems_bdbuf_unlock_cache ();
200d804: 7f ff ff 1b call 200d470 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200d808: 01 00 00 00 nop <== NOT EXECUTED
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BDBUF_FATAL_SYNC_LOCK);
200d80c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d810: 7f ff fe f5 call 200d3e4 <rtems_bdbuf_lock> <== NOT EXECUTED
200d814: 92 10 20 19 mov 0x19, %o1 <== NOT EXECUTED
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
200d818: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d81c: 7f ff ff 0a call 200d444 <rtems_bdbuf_unlock> <== NOT EXECUTED
200d820: 92 10 20 1a mov 0x1a, %o1 <== NOT EXECUTED
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
rtems_bdbuf_unlock_sync ();
rtems_bdbuf_lock_cache ();
200d824: 7f ff fe fd call 200d418 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200d828: 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
200d82c: 10 bf ff ce b 200d764 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== NOT EXECUTED
200d830: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
0200d530 <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)
{
200d530: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
200d534: c2 06 00 00 ld [ %i0 ], %g1
200d538: 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 ();
200d53c: 7f ff ff e0 call 200d4bc <rtems_bdbuf_disable_preemption>
200d540: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
200d544: 7f ff ff cb call 200d470 <rtems_bdbuf_unlock_cache>
200d548: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
200d54c: d0 06 20 04 ld [ %i0 + 4 ], %o0
200d550: 92 10 20 00 clr %o1
200d554: 7f ff ee 7a call 2008f3c <rtems_semaphore_obtain>
200d558: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
200d55c: 80 a2 20 06 cmp %o0, 6
200d560: 02 80 00 0d be 200d594 <rtems_bdbuf_anonymous_wait+0x64> <== NEVER TAKEN
200d564: 80 a2 20 0d cmp %o0, 0xd
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
200d568: 12 80 00 0d bne 200d59c <rtems_bdbuf_anonymous_wait+0x6c> <== NEVER TAKEN
200d56c: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
rtems_bdbuf_lock_cache ();
200d570: 7f ff ff aa call 200d418 <rtems_bdbuf_lock_cache>
200d574: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
200d578: 7f ff ff df call 200d4f4 <rtems_bdbuf_restore_preemption>
200d57c: 90 10 00 1d mov %i5, %o0
--waiters->count;
200d580: c2 06 00 00 ld [ %i0 ], %g1
200d584: 82 00 7f ff add %g1, -1, %g1
200d588: c2 26 00 00 st %g1, [ %i0 ]
200d58c: 81 c7 e0 08 ret
200d590: 81 e8 00 00 restore
rtems_bdbuf_unlock_cache ();
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
if (sc == RTEMS_TIMEOUT)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
200d594: 7f ff ff 8f call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d598: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
200d59c: 7f ff ff 8d call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d5a0: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
0200d834 <rtems_bdbuf_create_task.constprop.9>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
200d834: 9d e3 bf a0 save %sp, -96, %sp
rtems_task_argument arg,
rtems_id *id
)
{
rtems_status_code sc;
size_t stack_size = bdbuf_config.task_stack_size ?
200d838: 03 00 80 7f sethi %hi(0x201fc00), %g1
200d83c: d4 00 60 d4 ld [ %g1 + 0xd4 ], %o2 ! 201fcd4 <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
200d840: 80 a2 a0 00 cmp %o2, 0
200d844: 12 80 00 03 bne 200d850 <rtems_bdbuf_create_task.constprop.9+0x1c><== ALWAYS TAKEN
200d848: 92 10 00 19 mov %i1, %o1
200d84c: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
200d850: 80 a2 60 00 cmp %o1, 0
200d854: 22 80 00 02 be,a 200d85c <rtems_bdbuf_create_task.constprop.9+0x28><== NEVER TAKEN
200d858: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
200d85c: 90 10 00 18 mov %i0, %o0
200d860: 96 10 24 00 mov 0x400, %o3
200d864: 98 10 20 00 clr %o4
200d868: 7f ff ee 44 call 2009178 <rtems_task_create>
200d86c: 9a 10 00 1c mov %i4, %o5
stack_size,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
id);
if (sc == RTEMS_SUCCESSFUL)
200d870: 80 a2 20 00 cmp %o0, 0
200d874: 02 80 00 04 be 200d884 <rtems_bdbuf_create_task.constprop.9+0x50><== ALWAYS TAKEN
200d878: b0 10 00 08 mov %o0, %i0
sc = rtems_task_start (*id, entry, arg);
return sc;
}
200d87c: 81 c7 e0 08 ret <== NOT EXECUTED
200d880: 81 e8 00 00 restore <== NOT EXECUTED
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
id);
if (sc == RTEMS_SUCCESSFUL)
sc = rtems_task_start (*id, entry, arg);
200d884: f0 07 00 00 ld [ %i4 ], %i0
200d888: b2 10 00 1a mov %i2, %i1
200d88c: 7f ff ee c6 call 20093a4 <rtems_task_start>
200d890: 95 e8 00 1b restore %g0, %i3, %o2
0200d4bc <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
200d4bc: 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);
200d4c0: 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;
200d4c4: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
200d4c8: 92 10 21 00 mov 0x100, %o1
200d4cc: 40 00 12 83 call 2011ed8 <rtems_task_mode>
200d4d0: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
200d4d4: 80 a2 20 00 cmp %o0, 0
200d4d8: 12 80 00 04 bne 200d4e8 <rtems_bdbuf_disable_preemption+0x2c><== NEVER TAKEN
200d4dc: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
return prev_mode;
}
200d4e0: 81 c7 e0 08 ret
200d4e4: 81 e8 00 00 restore
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
200d4e8: 7f ff ff ba call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d4ec: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
0200dcb4 <rtems_bdbuf_discard_buffer_after_access>:
return bdbuf_cache.max_bds_per_group / bds_per_size;
}
static void
rtems_bdbuf_discard_buffer_after_access (rtems_bdbuf_buffer *bd)
{
200dcb4: 9d e3 bf a0 save %sp, -96, %sp
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200dcb8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
200dcbc: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200dcc0: c6 00 60 0c ld [ %g1 + 0xc ], %g3
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
200dcc4: 80 a0 a0 00 cmp %g2, 0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200dcc8: 86 00 ff ff add %g3, -1, %g3
200dccc: c6 20 60 0c st %g3, [ %g1 + 0xc ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200dcd0: 82 10 20 01 mov 1, %g1
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
200dcd4: 02 80 00 05 be 200dce8 <rtems_bdbuf_discard_buffer_after_access+0x34>
200dcd8: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_discard_buffer (bd);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200dcdc: 31 00 80 89 sethi %hi(0x2022400), %i0
200dce0: 7f ff fe 85 call 200d6f4 <rtems_bdbuf_wake>
200dce4: 91 ee 23 70 restore %i0, 0x370, %o0
200dce8: 7f ff ff e6 call 200dc80 <rtems_bdbuf_discard_buffer.part.4>
200dcec: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_discard_buffer_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_discard_buffer (bd);
if (bd->waiters)
200dcf0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200dcf4: 80 a0 60 00 cmp %g1, 0
200dcf8: 32 bf ff fa bne,a 200dce0 <rtems_bdbuf_discard_buffer_after_access+0x2c><== NEVER TAKEN
200dcfc: 31 00 80 89 sethi %hi(0x2022400), %i0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200dd00: 31 00 80 89 sethi %hi(0x2022400), %i0
200dd04: 7f ff fe 7c call 200d6f4 <rtems_bdbuf_wake>
200dd08: 91 ee 23 80 restore %i0, 0x380, %o0
0200eb90 <rtems_bdbuf_execute_read_request>:
static rtems_status_code
rtems_bdbuf_execute_read_request (rtems_disk_device *dd,
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
200eb90: 9d e3 bf a0 save %sp, -96, %sp
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
200eb94: 83 2e a0 04 sll %i2, 4, %g1
200eb98: 82 00 60 20 add %g1, 0x20, %g1
200eb9c: 9c 23 80 01 sub %sp, %g1, %sp
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
200eba0: 03 00 80 3b sethi %hi(0x200ec00), %g1
200eba4: 82 10 60 64 or %g1, 0x64, %g1 ! 200ec64 <rtems_bdbuf_transfer_done>
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
200eba8: a2 03 a0 60 add %sp, 0x60, %l1
rtems_bdbuf_execute_read_request (rtems_disk_device *dd,
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
200ebac: f8 06 60 18 ld [ %i1 + 0x18 ], %i4
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
200ebb0: e0 06 20 24 ld [ %i0 + 0x24 ], %l0
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
200ebb4: e4 06 20 2c ld [ %i0 + 0x2c ], %l2
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
200ebb8: c2 24 60 04 st %g1, [ %l1 + 4 ]
req->io_task = rtems_task_self ();
200ebbc: 40 00 0d 33 call 2012088 <rtems_task_self>
200ebc0: c0 24 40 00 clr [ %l1 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
200ebc4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
req->io_task = rtems_task_self ();
200ebc8: d0 24 60 14 st %o0, [ %l1 + 0x14 ]
req->bufnum = 0;
200ebcc: c0 24 60 10 clr [ %l1 + 0x10 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ebd0: 84 10 20 09 mov 9, %g2
200ebd4: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
req->io_task = rtems_task_self ();
req->bufnum = 0;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
200ebd8: f2 24 60 24 st %i1, [ %l1 + 0x24 ]
req->bufs [0].block = media_block;
200ebdc: f8 24 60 18 st %i4, [ %l1 + 0x18 ]
req->bufs [0].length = block_size;
200ebe0: e0 24 60 1c st %l0, [ %l1 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
200ebe4: 80 a6 a0 01 cmp %i2, 1
200ebe8: 08 80 00 1d bleu 200ec5c <rtems_bdbuf_execute_read_request+0xcc>
200ebec: c2 24 60 20 st %g1, [ %l1 + 0x20 ]
200ebf0: ba 10 00 11 mov %l1, %i5
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
200ebf4: b6 10 20 01 mov 1, %i3
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ebf8: 10 80 00 0b b 200ec24 <rtems_bdbuf_execute_read_request+0x94>
200ebfc: b2 10 20 09 mov 9, %i1
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
200ec00: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
req->bufs [transfer_index].block = media_block;
200ec04: f8 27 60 28 st %i4, [ %i5 + 0x28 ]
req->bufs [transfer_index].length = block_size;
200ec08: e0 27 60 2c st %l0, [ %i5 + 0x2c ]
req->bufs [transfer_index].buffer = bd->buffer;
200ec0c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
200ec10: b6 06 e0 01 inc %i3
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
req->bufs [transfer_index].block = media_block;
req->bufs [transfer_index].length = block_size;
req->bufs [transfer_index].buffer = bd->buffer;
200ec14: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
200ec18: 80 a6 c0 1a cmp %i3, %i2
200ec1c: 02 80 00 09 be 200ec40 <rtems_bdbuf_execute_read_request+0xb0>
200ec20: ba 07 60 10 add %i5, 0x10, %i5
{
media_block += media_blocks_per_block;
200ec24: b8 07 00 12 add %i4, %l2, %i4
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
200ec28: 90 10 00 18 mov %i0, %o0
200ec2c: 7f ff fd 50 call 200e16c <rtems_bdbuf_get_buffer_for_read_ahead>
200ec30: 92 10 00 1c mov %i4, %o1
if (bd == NULL)
200ec34: 80 a2 20 00 cmp %o0, 0
200ec38: 32 bf ff f2 bne,a 200ec00 <rtems_bdbuf_execute_read_request+0x70><== ALWAYS TAKEN
200ec3c: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200ec40: f6 24 60 10 st %i3, [ %l1 + 0x10 ]
return rtems_bdbuf_execute_transfer_request (dd, req, true);
200ec44: 90 10 00 18 mov %i0, %o0
200ec48: 92 10 00 11 mov %l1, %o1
200ec4c: 7f ff fd f5 call 200e420 <rtems_bdbuf_execute_transfer_request>
200ec50: 94 10 20 01 mov 1, %o2
}
200ec54: 81 c7 e0 08 ret
200ec58: 91 e8 00 08 restore %g0, %o0, %o0
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
200ec5c: 10 bf ff f9 b 200ec40 <rtems_bdbuf_execute_read_request+0xb0>
200ec60: b6 10 20 01 mov 1, %i3
0200e420 <rtems_bdbuf_execute_transfer_request>:
static rtems_status_code
rtems_bdbuf_execute_transfer_request (rtems_disk_device *dd,
rtems_blkdev_request *req,
bool cache_locked)
{
200e420: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
200e424: 80 a6 a0 00 cmp %i2, 0
200e428: 12 80 00 6e bne 200e5e0 <rtems_bdbuf_execute_transfer_request+0x1c0>
200e42c: ba 10 00 18 mov %i0, %i5
rtems_bdbuf_unlock_cache ();
/* The return value will be ignored for transfer requests */
dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
200e430: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
200e434: d0 07 60 08 ld [ %i5 + 8 ], %o0
200e438: 94 10 00 19 mov %i1, %o2
200e43c: 13 30 06 10 sethi %hi(0xc0184000), %o1
200e440: 9f c0 40 00 call %g1
200e444: 92 12 62 01 or %o1, 0x201, %o1 ! c0184201 <RAM_END+0xbdd84201>
/* Wait for transfer request completion */
rtems_bdbuf_wait_for_transient_event ();
200e448: 7f ff ff e8 call 200e3e8 <rtems_bdbuf_wait_for_transient_event>
200e44c: 01 00 00 00 nop
sc = req->status;
rtems_bdbuf_lock_cache ();
200e450: 7f ff fb f2 call 200d418 <rtems_bdbuf_lock_cache>
200e454: f0 06 60 0c ld [ %i1 + 0xc ], %i0
/* Statistics */
if (req->req == RTEMS_BLKDEV_REQ_READ)
200e458: c2 06 40 00 ld [ %i1 ], %g1
200e45c: 80 a0 60 00 cmp %g1, 0
200e460: 12 80 00 47 bne 200e57c <rtems_bdbuf_execute_transfer_request+0x15c>
200e464: c8 06 60 10 ld [ %i1 + 0x10 ], %g4
{
dd->stats.read_blocks += req->bufnum;
200e468: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (sc != RTEMS_SUCCESSFUL)
200e46c: 80 a6 20 00 cmp %i0, 0
rtems_bdbuf_lock_cache ();
/* Statistics */
if (req->req == RTEMS_BLKDEV_REQ_READ)
{
dd->stats.read_blocks += req->bufnum;
200e470: 82 00 40 04 add %g1, %g4, %g1
if (sc != RTEMS_SUCCESSFUL)
200e474: 12 80 00 57 bne 200e5d0 <rtems_bdbuf_execute_transfer_request+0x1b0>
200e478: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.write_errors;
}
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
200e47c: 80 a1 20 00 cmp %g4, 0
200e480: 02 80 00 35 be 200e554 <rtems_bdbuf_execute_transfer_request+0x134><== NEVER TAKEN
200e484: b6 10 20 00 clr %i3
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e488: 21 00 80 89 sethi %hi(0x2022400), %l0
200e48c: b8 10 00 19 mov %i1, %i4
200e490: a0 14 23 0c or %l0, 0x30c, %l0
200e494: a8 10 20 00 clr %l4
200e498: ba 10 20 00 clr %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e49c: a6 10 20 01 mov 1, %l3
200e4a0: a4 10 20 02 mov 2, %l2
the_node->next = tail;
200e4a4: 10 80 00 16 b 200e4fc <rtems_bdbuf_execute_transfer_request+0xdc>
200e4a8: a2 04 20 44 add %l0, 0x44, %l1
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200e4ac: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
else
wake_buffer_waiters = true;
rtems_bdbuf_group_release (bd);
if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
200e4b0: 80 a6 20 00 cmp %i0, 0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200e4b4: c6 00 60 0c ld [ %g1 + 0xc ], %g3
200e4b8: 86 00 ff ff add %g3, -1, %g3
else
wake_buffer_waiters = true;
rtems_bdbuf_group_release (bd);
if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
200e4bc: 12 80 00 06 bne 200e4d4 <rtems_bdbuf_execute_transfer_request+0xb4>
200e4c0: c6 20 60 0c st %g3, [ %g1 + 0xc ]
200e4c4: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
200e4c8: 80 a0 60 09 cmp %g1, 9
200e4cc: 22 80 00 13 be,a 200e518 <rtems_bdbuf_execute_transfer_request+0xf8>
200e4d0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
200e4d4: 80 a0 a0 00 cmp %g2, 0
200e4d8: 12 80 00 05 bne 200e4ec <rtems_bdbuf_execute_transfer_request+0xcc>
200e4dc: e6 22 20 20 st %l3, [ %o0 + 0x20 ]
200e4e0: 7f ff fd e8 call 200dc80 <rtems_bdbuf_discard_buffer.part.4>
200e4e4: 01 00 00 00 nop
200e4e8: c8 06 60 10 ld [ %i1 + 0x10 ], %g4
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.write_errors;
}
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
200e4ec: ba 07 60 01 inc %i5
200e4f0: 80 a1 00 1d cmp %g4, %i5
200e4f4: 08 80 00 12 bleu 200e53c <rtems_bdbuf_execute_transfer_request+0x11c><== ALWAYS TAKEN
200e4f8: b8 07 20 10 add %i4, 0x10, %i4
{
rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;
200e4fc: d0 07 20 24 ld [ %i4 + 0x24 ], %o0
bool waiters = bd->waiters;
200e500: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
if (waiters)
200e504: 80 a0 a0 00 cmp %g2, 0
200e508: 32 bf ff e9 bne,a 200e4ac <rtems_bdbuf_execute_transfer_request+0x8c>
200e50c: a8 10 20 01 mov 1, %l4
wake_transfer_waiters = true;
else
wake_buffer_waiters = true;
200e510: 10 bf ff e7 b 200e4ac <rtems_bdbuf_execute_transfer_request+0x8c>
200e514: b6 10 20 01 mov 1, %i3
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e518: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
200e51c: e2 22 00 00 st %l1, [ %o0 ]
tail->previous = the_node;
200e520: d0 24 20 48 st %o0, [ %l0 + 0x48 ]
old_last->next = the_node;
200e524: d0 20 40 00 st %o0, [ %g1 ]
the_node->previous = old_last;
200e528: c2 22 20 04 st %g1, [ %o0 + 4 ]
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.write_errors;
}
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
200e52c: ba 07 60 01 inc %i5
200e530: 80 a1 00 1d cmp %g4, %i5
200e534: 18 bf ff f2 bgu 200e4fc <rtems_bdbuf_execute_transfer_request+0xdc>
200e538: b8 07 20 10 add %i4, 0x10, %i4
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
200e53c: 80 8d 20 ff btst 0xff, %l4
200e540: 12 80 00 2c bne 200e5f0 <rtems_bdbuf_execute_transfer_request+0x1d0>
200e544: 11 00 80 89 sethi %hi(0x2022400), %o0
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
if (wake_buffer_waiters)
200e548: 80 8e e0 ff btst 0xff, %i3
200e54c: 12 80 00 18 bne 200e5ac <rtems_bdbuf_execute_transfer_request+0x18c>
200e550: 11 00 80 89 sethi %hi(0x2022400), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
if (!cache_locked)
200e554: 80 a6 a0 00 cmp %i2, 0
200e558: 02 80 00 1a be 200e5c0 <rtems_bdbuf_execute_transfer_request+0x1a0>
200e55c: 01 00 00 00 nop
rtems_bdbuf_unlock_cache ();
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
200e560: 80 a6 20 0d cmp %i0, 0xd
200e564: 02 80 00 04 be 200e574 <rtems_bdbuf_execute_transfer_request+0x154>
200e568: 80 a6 20 00 cmp %i0, 0
200e56c: 32 80 00 02 bne,a 200e574 <rtems_bdbuf_execute_transfer_request+0x154>
200e570: b0 10 20 1b mov 0x1b, %i0
return sc;
else
return RTEMS_IO_ERROR;
}
200e574: 81 c7 e0 08 ret
200e578: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
200e57c: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
++dd->stats.write_transfers;
200e580: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
200e584: 84 00 80 04 add %g2, %g4, %g2
++dd->stats.write_transfers;
200e588: 82 00 60 01 inc %g1
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
200e58c: c4 27 60 5c st %g2, [ %i5 + 0x5c ]
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
200e590: 80 a6 20 00 cmp %i0, 0
200e594: 02 bf ff ba be 200e47c <rtems_bdbuf_execute_transfer_request+0x5c>
200e598: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
++dd->stats.write_errors;
200e59c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
200e5a0: 82 00 60 01 inc %g1
200e5a4: 10 bf ff b6 b 200e47c <rtems_bdbuf_execute_transfer_request+0x5c>
200e5a8: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
if (wake_transfer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
if (wake_buffer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200e5ac: 7f ff fc 52 call 200d6f4 <rtems_bdbuf_wake>
200e5b0: 90 12 23 80 or %o0, 0x380, %o0
if (!cache_locked)
200e5b4: 80 a6 a0 00 cmp %i2, 0
200e5b8: 32 bf ff eb bne,a 200e564 <rtems_bdbuf_execute_transfer_request+0x144>
200e5bc: 80 a6 20 0d cmp %i0, 0xd
rtems_bdbuf_unlock_cache ();
200e5c0: 7f ff fb ac call 200d470 <rtems_bdbuf_unlock_cache>
200e5c4: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
200e5c8: 10 bf ff e7 b 200e564 <rtems_bdbuf_execute_transfer_request+0x144>
200e5cc: 80 a6 20 0d cmp %i0, 0xd
/* Statistics */
if (req->req == RTEMS_BLKDEV_REQ_READ)
{
dd->stats.read_blocks += req->bufnum;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
200e5d0: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
200e5d4: 82 00 60 01 inc %g1
200e5d8: 10 bf ff a9 b 200e47c <rtems_bdbuf_execute_transfer_request+0x5c>
200e5dc: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
rtems_bdbuf_unlock_cache ();
200e5e0: 7f ff fb a4 call 200d470 <rtems_bdbuf_unlock_cache>
200e5e4: 01 00 00 00 nop
/* The return value will be ignored for transfer requests */
dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
200e5e8: 10 bf ff 93 b 200e434 <rtems_bdbuf_execute_transfer_request+0x14>
200e5ec: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
200e5f0: 7f ff fc 41 call 200d6f4 <rtems_bdbuf_wake>
200e5f4: 90 12 23 78 or %o0, 0x378, %o0
if (wake_buffer_waiters)
200e5f8: 10 bf ff d5 b 200e54c <rtems_bdbuf_execute_transfer_request+0x12c>
200e5fc: 80 8e e0 ff btst 0xff, %i3
0200d3d0 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
200d3d0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
200d3d4: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
200d3d8: 7f ff f0 9f call 2009654 <rtems_fatal> <== NOT EXECUTED
200d3dc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
0200d430 <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
200d430: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
200d434: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
200d438: 7f ff ff e6 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d43c: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
0200f200 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200f200: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
200f204: 7f ff f8 85 call 200d418 <rtems_bdbuf_lock_cache>
200f208: b8 10 20 04 mov 4, %i4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200f20c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
200f210: 80 a6 40 01 cmp %i1, %g1
200f214: 0a 80 00 07 bcs 200f230 <rtems_bdbuf_get+0x30> <== ALWAYS TAKEN
200f218: ba 10 20 00 clr %i5
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
200f21c: 7f ff f8 95 call 200d470 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200f220: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
*bd_ptr = bd;
200f224: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
return sc;
}
200f228: 81 c7 e0 08 ret <== NOT EXECUTED
200f22c: 81 e8 00 00 restore <== NOT EXECUTED
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200f230: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
200f234: 80 a2 60 00 cmp %o1, 0
200f238: 26 80 00 29 bl,a 200f2dc <rtems_bdbuf_get+0xdc> <== NEVER TAKEN
200f23c: d6 06 20 24 ld [ %i0 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200f240: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200f244: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
200f248: 90 10 00 18 mov %i0, %o0
200f24c: 7f ff fb df call 200e1c8 <rtems_bdbuf_get_buffer_for_access>
200f250: 92 02 40 01 add %o1, %g1, %o1
200f254: ba 10 00 08 mov %o0, %i5
switch (bd->state)
200f258: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200f25c: 80 a2 20 02 cmp %o0, 2
200f260: 02 80 00 17 be 200f2bc <rtems_bdbuf_get+0xbc>
200f264: 80 a2 20 07 cmp %o0, 7
200f268: 02 80 00 06 be 200f280 <rtems_bdbuf_get+0x80>
200f26c: 80 a2 20 01 cmp %o0, 1
200f270: 02 80 00 0c be 200f2a0 <rtems_bdbuf_get+0xa0> <== ALWAYS TAKEN
200f274: 82 10 20 05 mov 5, %g1
* record of this so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
200f278: 7f ff f8 6e call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200f27c: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f280: 82 10 20 04 mov 4, %g1
200f284: b8 10 20 00 clr %i4
200f288: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
200f28c: 7f ff f8 79 call 200d470 <rtems_bdbuf_unlock_cache>
200f290: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
200f294: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
200f298: 81 c7 e0 08 ret
200f29c: 81 e8 00 00 restore
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f2a0: b8 10 20 00 clr %i4
200f2a4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
200f2a8: 7f ff f8 72 call 200d470 <rtems_bdbuf_unlock_cache>
200f2ac: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
200f2b0: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
200f2b4: 81 c7 e0 08 ret
200f2b8: 81 e8 00 00 restore
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f2bc: 82 10 20 03 mov 3, %g1
200f2c0: b8 10 20 00 clr %i4
200f2c4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
200f2c8: 7f ff f8 6a call 200d470 <rtems_bdbuf_unlock_cache>
200f2cc: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
200f2d0: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
200f2d4: 81 c7 e0 08 ret
200f2d8: 81 e8 00 00 restore
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200f2dc: 94 10 20 00 clr %o2 <== NOT EXECUTED
200f2e0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200f2e4: 40 00 3a 96 call 201dd3c <__muldi3> <== NOT EXECUTED
200f2e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
200f2ec: d6 06 20 20 ld [ %i0 + 0x20 ], %o3 <== NOT EXECUTED
200f2f0: 40 00 3c a4 call 201e580 <__udivdi3> <== NOT EXECUTED
200f2f4: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200f2f8: 10 bf ff d4 b 200f248 <rtems_bdbuf_get+0x48> <== NOT EXECUTED
200f2fc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
0200e1c8 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200e1c8: 9d e3 bf a0 save %sp, -96, %sp
200e1cc: 3b 00 80 89 sethi %hi(0x2022400), %i5
200e1d0: b8 10 00 18 mov %i0, %i4
200e1d4: ba 17 63 0c or %i5, 0x30c, %i5
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e1d8: a6 10 00 1d mov %i5, %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);
200e1dc: a0 07 60 6c add %i5, 0x6c, %l0
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
200e1e0: b4 07 60 64 add %i5, 0x64, %i2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200e1e4: b6 07 60 40 add %i5, 0x40, %i3
* It is essential that we wait here without a special wait count and
* without the group in use. Otherwise we could trigger a wait ping
* pong with another recycle waiter. The state of the buffer is
* arbitrary afterwards.
*/
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
200e1e8: a2 07 60 74 add %i5, 0x74, %l1
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200e1ec: a4 07 60 50 add %i5, 0x50, %l2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e1f0: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
200e1f4: 92 10 00 1c mov %i4, %o1
200e1f8: 7f ff fd 26 call 200d690 <rtems_bdbuf_avl_search.isra.0>
200e1fc: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
200e200: b0 92 20 00 orcc %o0, 0, %i0
200e204: 02 80 00 34 be 200e2d4 <rtems_bdbuf_get_buffer_for_access+0x10c>
200e208: 90 10 00 1c mov %i4, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
200e20c: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
200e210: c2 07 20 34 ld [ %i4 + 0x34 ], %g1
200e214: c4 00 a0 08 ld [ %g2 + 8 ], %g2
200e218: 80 a0 80 01 cmp %g2, %g1
200e21c: 12 80 00 0c bne 200e24c <rtems_bdbuf_get_buffer_for_access+0x84>
200e220: 2d 00 80 34 sethi %hi(0x200d000), %l6
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);
200e224: 3b 00 80 89 sethi %hi(0x2022400), %i5
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e228: 39 00 80 34 sethi %hi(0x200d000), %i4
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
200e22c: ba 17 63 78 or %i5, 0x378, %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);
200e230: b6 07 7f f8 add %i5, -8, %i3
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e234: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200e238: 80 a2 20 0a cmp %o0, 0xa
200e23c: 08 80 00 4c bleu 200e36c <rtems_bdbuf_get_buffer_for_access+0x1a4><== ALWAYS TAKEN
200e240: 84 17 21 c8 or %i4, 0x1c8, %g2
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_7);
200e244: 7f ff fc 7b call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200e248: 92 10 20 13 mov 0x13, %o1 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e24c: aa 10 20 08 mov 8, %l5
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200e250: a8 07 60 5c add %i5, 0x5c, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e254: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200e258: 80 a2 20 0a cmp %o0, 0xa
200e25c: 08 80 00 04 bleu 200e26c <rtems_bdbuf_get_buffer_for_access+0xa4><== ALWAYS TAKEN
200e260: 82 15 a1 f4 or %l6, 0x1f4, %g1
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_8);
200e264: 7f ff fc 73 call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200e268: 92 10 20 14 mov 0x14, %o1 <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e26c: 91 2a 20 02 sll %o0, 2, %o0
200e270: c2 00 40 08 ld [ %g1 + %o0 ], %g1
200e274: 81 c0 40 00 jmp %g1
200e278: 01 00 00 00 nop
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)
200e27c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200e280: 80 a0 60 00 cmp %g1, 0
200e284: 12 80 00 1f bne 200e300 <rtems_bdbuf_get_buffer_for_access+0x138><== ALWAYS TAKEN
200e288: 01 00 00 00 nop
{
if (bd->group->bds_per_group != dd->bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200e28c: 7f ff fe a0 call 200dd0c <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
200e290: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200e294: c2 07 60 40 ld [ %i5 + 0x40 ], %g1 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e298: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200e29c: f6 26 20 04 st %i3, [ %i0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
200e2a0: f0 27 60 40 st %i0, [ %i5 + 0x40 ] <== NOT EXECUTED
the_node->next = before_node;
200e2a4: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
before_node->previous = the_node;
200e2a8: f0 20 60 04 st %i0, [ %g1 + 4 ] <== 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);
200e2ac: 7f ff fd 12 call 200d6f4 <rtems_bdbuf_wake> <== NOT EXECUTED
200e2b0: 90 07 60 74 add %i5, 0x74, %o0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e2b4: d0 07 60 3c ld [ %i5 + 0x3c ], %o0 <== NOT EXECUTED
200e2b8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
200e2bc: 7f ff fc f5 call 200d690 <rtems_bdbuf_avl_search.isra.0> <== NOT EXECUTED
200e2c0: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
if (bd != NULL)
200e2c4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
200e2c8: 32 bf ff d2 bne,a 200e210 <rtems_bdbuf_get_buffer_for_access+0x48><== NOT EXECUTED
200e2cc: c4 06 20 28 ld [ %i0 + 0x28 ], %g2 <== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200e2d0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
200e2d4: 7f ff fe a0 call 200dd54 <rtems_bdbuf_get_buffer_from_lru_list>
200e2d8: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
200e2dc: b0 92 20 00 orcc %o0, 0, %i0
200e2e0: 32 bf ff d2 bne,a 200e228 <rtems_bdbuf_get_buffer_for_access+0x60>
200e2e4: 3b 00 80 89 sethi %hi(0x2022400), %i5
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200e2e8: c2 04 e0 4c ld [ %l3 + 0x4c ], %g1
200e2ec: 80 a0 40 12 cmp %g1, %l2
200e2f0: 02 80 00 04 be 200e300 <rtems_bdbuf_get_buffer_for_access+0x138>
200e2f4: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200e2f8: 7f ff fc 64 call 200d488 <rtems_bdbuf_wake_swapper>
200e2fc: 01 00 00 00 nop
* It is essential that we wait here without a special wait count and
* without the group in use. Otherwise we could trigger a wait ping
* pong with another recycle waiter. The state of the buffer is
* arbitrary afterwards.
*/
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
200e300: 7f ff fc 8c call 200d530 <rtems_bdbuf_anonymous_wait>
200e304: 90 10 00 11 mov %l1, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e308: 10 bf ff bb b 200e1f4 <rtems_bdbuf_get_buffer_for_access+0x2c>
200e30c: d0 07 60 3c ld [ %i5 + 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);
200e310: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e314: 7f ff fc a5 call 200d5a8 <rtems_bdbuf_wait> <== NOT EXECUTED
200e318: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e31c: 10 bf ff cf b 200e258 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
200e320: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200e324: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200e328: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e32c: ea 26 20 20 st %l5, [ %i0 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
200e330: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
200e334: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e338: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
200e33c: e8 26 00 00 st %l4, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
200e340: f0 27 60 60 st %i0, [ %i5 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
200e344: f0 20 40 00 st %i0, [ %g1 ] <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract_unprotected (&bd->link);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
200e348: 7f ff fc 50 call 200d488 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
200e34c: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e350: 10 bf ff c2 b 200e258 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
200e354: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
200e358: 90 10 00 18 mov %i0, %o0
200e35c: 7f ff fc 93 call 200d5a8 <rtems_bdbuf_wait>
200e360: 92 10 00 1a mov %i2, %o1
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e364: 10 bf ff bd b 200e258 <rtems_bdbuf_get_buffer_for_access+0x90>
200e368: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e36c: 83 2a 20 02 sll %o0, 2, %g1
200e370: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200e374: 81 c0 40 00 jmp %g1
200e378: 01 00 00 00 nop
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);
200e37c: 90 10 00 18 mov %i0, %o0
200e380: 7f ff fc 8a call 200d5a8 <rtems_bdbuf_wait>
200e384: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e388: 10 bf ff ac b 200e238 <rtems_bdbuf_get_buffer_for_access+0x70>
200e38c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200e390: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
200e394: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200e398: 84 00 bf ff add %g2, -1, %g2
200e39c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200e3a0: c6 06 00 00 ld [ %i0 ], %g3
previous = the_node->previous;
200e3a4: c4 06 20 04 ld [ %i0 + 4 ], %g2
next->previous = previous;
200e3a8: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
200e3ac: c6 20 80 00 st %g3, [ %g2 ]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200e3b0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200e3b4: 84 00 a0 01 inc %g2
200e3b8: c4 20 60 0c st %g2, [ %g1 + 0xc ]
200e3bc: 81 c7 e0 08 ret
200e3c0: 81 e8 00 00 restore
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);
200e3c4: 90 10 00 18 mov %i0, %o0
200e3c8: 7f ff fc 78 call 200d5a8 <rtems_bdbuf_wait>
200e3cc: 92 10 00 1b mov %i3, %o1
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200e3d0: 10 bf ff 9a b 200e238 <rtems_bdbuf_get_buffer_for_access+0x70>
200e3d4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200e3d8: 10 bf ff f2 b 200e3a0 <rtems_bdbuf_get_buffer_for_access+0x1d8>
200e3dc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
200e3e0: 10 bf ff f4 b 200e3b0 <rtems_bdbuf_get_buffer_for_access+0x1e8>
200e3e4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
0200e16c <rtems_bdbuf_get_buffer_for_read_ahead>:
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_read_ahead (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200e16c: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200e170: 03 00 80 89 sethi %hi(0x2022400), %g1
200e174: d0 00 63 48 ld [ %g1 + 0x348 ], %o0 ! 2022748 <bdbuf_cache+0x3c>
200e178: 92 10 00 18 mov %i0, %o1
200e17c: 7f ff fd 45 call 200d690 <rtems_bdbuf_avl_search.isra.0>
200e180: 94 10 00 19 mov %i1, %o2
if (bd == NULL)
200e184: 80 a2 20 00 cmp %o0, 0
200e188: 02 80 00 04 be 200e198 <rtems_bdbuf_get_buffer_for_read_ahead+0x2c><== ALWAYS TAKEN
200e18c: 82 10 20 00 clr %g1
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
200e190: 81 c7 e0 08 ret <== NOT EXECUTED
200e194: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
if (bd == NULL)
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200e198: 90 10 00 18 mov %i0, %o0
200e19c: 7f ff fe ee call 200dd54 <rtems_bdbuf_get_buffer_from_lru_list>
200e1a0: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
200e1a4: 82 92 20 00 orcc %o0, 0, %g1
200e1a8: 02 bf ff fa be 200e190 <rtems_bdbuf_get_buffer_for_read_ahead+0x24><== NEVER TAKEN
200e1ac: 01 00 00 00 nop
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200e1b0: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
200e1b4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
200e1b8: 86 00 e0 01 inc %g3
200e1bc: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
200e1c0: 81 c7 e0 08 ret
200e1c4: 91 e8 00 01 restore %g0, %g1, %o0
0200dd54 <rtems_bdbuf_get_buffer_from_lru_list>:
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200dd54: 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;
200dd58: 35 00 80 89 sethi %hi(0x2022400), %i2
200dd5c: b4 16 a3 0c or %i2, 0x30c, %i2 ! 202270c <bdbuf_cache>
200dd60: fa 06 a0 40 ld [ %i2 + 0x40 ], %i5
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200dd64: a4 06 a0 44 add %i2, 0x44, %l2
200dd68: a6 06 a0 40 add %i2, 0x40, %l3
200dd6c: 80 a7 40 12 cmp %i5, %l2
200dd70: 12 80 00 07 bne 200dd8c <rtems_bdbuf_get_buffer_from_lru_list+0x38>
200dd74: a8 06 a0 74 add %i2, 0x74, %l4
}
node = rtems_chain_next (node);
}
return NULL;
200dd78: 10 80 00 6c b 200df28 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
200dd7c: ba 10 20 00 clr %i5
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200dd80: 80 a7 40 12 cmp %i5, %l2
200dd84: 22 80 00 69 be,a 200df28 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
200dd88: ba 10 20 00 clr %i5
bd->group->bds_per_group, dd->bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
200dd8c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200dd90: 80 a0 60 00 cmp %g1, 0
200dd94: 32 bf ff fb bne,a 200dd80 <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
200dd98: fa 07 40 00 ld [ %i5 ], %i5
{
if (bd->group->bds_per_group == dd->bds_per_group)
200dd9c: e0 07 60 28 ld [ %i5 + 0x28 ], %l0
200dda0: e2 06 20 34 ld [ %i0 + 0x34 ], %l1
200dda4: f6 04 20 08 ld [ %l0 + 8 ], %i3
200dda8: 80 a6 c0 11 cmp %i3, %l1
200ddac: 02 80 00 37 be 200de88 <rtems_bdbuf_get_buffer_from_lru_list+0x134>
200ddb0: 01 00 00 00 nop
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
empty_bd = bd;
}
else if (bd->group->users == 0)
200ddb4: c2 04 20 0c ld [ %l0 + 0xc ], %g1
200ddb8: 80 a0 60 00 cmp %g1, 0
200ddbc: 32 bf ff f1 bne,a 200dd80 <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
200ddc0: fa 07 40 00 ld [ %i5 ], %i5
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;
200ddc4: ec 06 a0 20 ld [ %i2 + 0x20 ], %l6
200ddc8: 92 10 00 1b mov %i3, %o1
200ddcc: 40 00 3e 84 call 201d7dc <.udiv>
200ddd0: 90 10 00 16 mov %l6, %o0
for (b = 0, bd = group->bdbuf;
200ddd4: 80 a6 e0 00 cmp %i3, 0
200ddd8: 02 80 00 0f be 200de14 <rtems_bdbuf_get_buffer_from_lru_list+0xc0><== NEVER TAKEN
200dddc: f8 04 20 10 ld [ %l0 + 0x10 ], %i4
200dde0: 83 2a 20 03 sll %o0, 3, %g1
200dde4: ab 2a 20 06 sll %o0, 6, %l5
200dde8: b6 10 20 00 clr %i3
200ddec: aa 25 40 01 sub %l5, %g1, %l5
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200ddf0: 7f ff ff c7 call 200dd0c <rtems_bdbuf_remove_from_tree_and_lru_list>
200ddf4: 90 10 00 1c mov %i4, %o0
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;
200ddf8: c2 04 20 08 ld [ %l0 + 8 ], %g1
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200ddfc: b6 06 e0 01 inc %i3
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;
200de00: 80 a6 c0 01 cmp %i3, %g1
200de04: 0a bf ff fb bcs 200ddf0 <rtems_bdbuf_get_buffer_from_lru_list+0x9c>
200de08: b8 07 00 15 add %i4, %l5, %i4
200de0c: ec 06 a0 20 ld [ %i2 + 0x20 ], %l6
200de10: f8 04 20 10 ld [ %l0 + 0x10 ], %i4
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;
200de14: e2 24 20 08 st %l1, [ %l0 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
200de18: 90 10 00 16 mov %l6, %o0
200de1c: 40 00 3e 70 call 201d7dc <.udiv>
200de20: 92 10 00 11 mov %l1, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
200de24: 83 2a 20 03 sll %o0, 3, %g1
200de28: 89 2a 20 06 sll %o0, 6, %g4
200de2c: 80 a4 60 01 cmp %l1, 1
200de30: 88 21 00 01 sub %g4, %g1, %g4
200de34: 08 80 00 10 bleu 200de74 <rtems_bdbuf_get_buffer_from_lru_list+0x120>
200de38: 82 07 00 04 add %i4, %g4, %g1
200de3c: 84 10 20 01 mov 1, %g2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200de40: c0 20 60 20 clr [ %g1 + 0x20 ]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200de44: c6 06 a0 40 ld [ %i2 + 0x40 ], %g3
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200de48: e6 20 60 04 st %l3, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200de4c: c2 26 a0 40 st %g1, [ %i2 + 0x40 ]
the_node->next = before_node;
200de50: c6 20 40 00 st %g3, [ %g1 ]
before_node->previous = the_node;
200de54: c2 20 e0 04 st %g1, [ %g3 + 4 ]
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200de58: 84 00 a0 01 inc %g2
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;
200de5c: 80 a0 80 11 cmp %g2, %l1
200de60: 12 bf ff f8 bne 200de40 <rtems_bdbuf_get_buffer_from_lru_list+0xec>
200de64: 82 00 40 04 add %g1, %g4, %g1
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200de68: 7f ff fe 23 call 200d6f4 <rtems_bdbuf_wake>
200de6c: 90 10 00 14 mov %l4, %o0
200de70: f8 04 20 10 ld [ %l0 + 0x10 ], %i4
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
200de74: 80 a7 20 00 cmp %i4, 0
200de78: 22 bf ff c2 be,a 200dd80 <rtems_bdbuf_get_buffer_from_lru_list+0x2c><== NEVER TAKEN
200de7c: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
return group->bdbuf;
200de80: 10 80 00 04 b 200de90 <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
200de84: ba 10 00 1c mov %i4, %i5
*/
if (bd->waiters == 0)
{
if (bd->group->bds_per_group == dd->bds_per_group)
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200de88: 7f ff ff a1 call 200dd0c <rtems_bdbuf_remove_from_tree_and_lru_list>
200de8c: 90 10 00 1d mov %i5, %o0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
200de90: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
200de94: c0 27 60 08 clr [ %i5 + 8 ]
bd->avl.right = NULL;
200de98: c0 27 60 0c clr [ %i5 + 0xc ]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
200de9c: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
200dea0: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
200dea4: 80 a0 60 00 cmp %g1, 0
200dea8: 02 80 00 5c be 200e018 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
200deac: c0 27 60 24 clr [ %i5 + 0x24 ]
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200deb0: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
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;
200deb4: 9e 07 bf 80 add %fp, -128, %o7
200deb8: 84 10 00 0f mov %o7, %g2
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
200debc: c2 20 80 00 st %g1, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
200dec0: b8 10 20 01 mov 1, %i4
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200dec4: b6 10 3f ff mov -1, %i3
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200dec8: 80 a0 c0 18 cmp %g3, %i0
200decc: 1a 80 00 0d bcc 200df00 <rtems_bdbuf_get_buffer_from_lru_list+0x1ac><== ALWAYS TAKEN
200ded0: 88 00 a0 04 add %g2, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
q = p->avl.right;
200ded4: c6 00 60 0c ld [ %g1 + 0xc ], %g3 <== NOT EXECUTED
if (q == NULL)
200ded8: 80 a0 e0 00 cmp %g3, 0
200dedc: 02 80 00 1d be 200df50 <rtems_bdbuf_get_buffer_from_lru_list+0x1fc>
200dee0: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
200dee4: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200dee8: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
200deec: 84 10 00 04 mov %g4, %g2
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
200def0: c2 20 80 00 st %g1, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200def4: 80 a0 c0 18 cmp %g3, %i0
200def8: 0a bf ff f7 bcs 200ded4 <rtems_bdbuf_get_buffer_from_lru_list+0x180><== NEVER TAKEN
200defc: 88 00 a0 04 add %g2, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
200df00: 80 a6 00 03 cmp %i0, %g3
200df04: 22 80 00 0b be,a 200df30 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc><== ALWAYS TAKEN
200df08: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
q = p->avl.left;
200df0c: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
if (q == NULL)
200df10: 80 a0 e0 00 cmp %g3, 0
200df14: 12 bf ff f4 bne 200dee4 <rtems_bdbuf_get_buffer_from_lru_list+0x190>
200df18: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
200df1c: fa 20 60 08 st %i5, [ %g1 + 8 ]
200df20: 10 80 00 0e b 200df58 <rtems_bdbuf_get_buffer_from_lru_list+0x204>
200df24: 88 10 3f ff mov -1, %g4
node = rtems_chain_next (node);
}
return NULL;
}
200df28: 81 c7 e0 08 ret
200df2c: 91 e8 00 1d restore %g0, %i5, %o0
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
200df30: 80 a6 40 03 cmp %i1, %g3
200df34: 38 bf ff e9 bgu,a 200ded8 <rtems_bdbuf_get_buffer_from_lru_list+0x184>
200df38: c6 00 60 0c ld [ %g1 + 0xc ], %g3
q = node;
p->avl.right = q = node;
break;
}
}
else if ((p->dd != dd) || (p->block != block))
200df3c: 80 a6 40 03 cmp %i1, %g3
200df40: 32 bf ff f4 bne,a 200df10 <rtems_bdbuf_get_buffer_from_lru_list+0x1bc><== ALWAYS TAKEN
200df44: c6 00 60 08 ld [ %g1 + 8 ], %g3
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RECYCLE);
200df48: 7f ff fd 22 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200df4c: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
p->avl.cache = 1;
q = p->avl.right;
if (q == NULL)
{
q = node;
p->avl.right = q = node;
200df50: fa 20 60 0c st %i5, [ %g1 + 0xc ]
200df54: 88 10 20 01 mov 1, %g4
}
p = q;
}
q->avl.left = q->avl.right = NULL;
200df58: c0 27 60 0c clr [ %i5 + 0xc ]
200df5c: c0 27 60 08 clr [ %i5 + 8 ]
q->avl.bal = 0;
200df60: c0 2f 60 11 clrb [ %i5 + 0x11 ]
200df64: 89 29 20 18 sll %g4, 0x18, %g4
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
200df68: b2 10 20 01 mov 1, %i1
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200df6c: 10 80 00 12 b 200dfb4 <rtems_bdbuf_get_buffer_from_lru_list+0x260>
200df70: b0 10 3f ff mov -1, %i0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
200df74: 86 10 00 01 mov %g1, %g3
200df78: b8 10 20 01 mov 1, %i4
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200df7c: 80 a0 80 0f cmp %g2, %o7
200df80: 28 80 00 1e bleu,a 200dff8 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
200df84: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
p = *--buf_prev;
200df88: c2 00 bf fc ld [ %g2 + -4 ], %g1
if (p->avl.cache == -1)
200df8c: c8 08 60 10 ldub [ %g1 + 0x10 ], %g4
200df90: 89 29 20 18 sll %g4, 0x18, %g4
200df94: b7 39 20 18 sra %g4, 0x18, %i3
200df98: 80 a6 ff ff cmp %i3, -1
200df9c: 22 80 00 03 be,a 200dfa8 <rtems_bdbuf_get_buffer_from_lru_list+0x254>
200dfa0: c6 20 60 08 st %g3, [ %g1 + 8 ]
{
p->avl.left = q;
}
else
{
p->avl.right = q;
200dfa4: c6 20 60 0c st %g3, [ %g1 + 0xc ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200dfa8: 80 8f 20 ff btst 0xff, %i4
200dfac: 02 80 00 13 be 200dff8 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
200dfb0: 84 00 bf fc add %g2, -4, %g2
{
if (p->avl.cache == -1)
200dfb4: 89 39 20 18 sra %g4, 0x18, %g4
200dfb8: 80 a1 3f ff cmp %g4, -1
200dfbc: 02 80 00 1e be 200e034 <rtems_bdbuf_get_buffer_from_lru_list+0x2e0>
200dfc0: c6 48 60 11 ldsb [ %g1 + 0x11 ], %g3
break;
}
}
else
{
switch (p->avl.bal)
200dfc4: 80 a0 e0 00 cmp %g3, 0
200dfc8: 22 bf ff eb be,a 200df74 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
200dfcc: f2 28 60 11 stb %i1, [ %g1 + 0x11 ]
200dfd0: 80 a0 e0 01 cmp %g3, 1
200dfd4: 02 80 00 1f be 200e050 <rtems_bdbuf_get_buffer_from_lru_list+0x2fc>
200dfd8: 80 a0 ff ff cmp %g3, -1
200dfdc: 22 80 00 0c be,a 200e00c <rtems_bdbuf_get_buffer_from_lru_list+0x2b8><== ALWAYS TAKEN
200dfe0: c0 28 60 11 clrb [ %g1 + 0x11 ]
200dfe4: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200dfe8: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
200dfec: 18 bf ff e7 bgu 200df88 <rtems_bdbuf_get_buffer_from_lru_list+0x234><== NOT EXECUTED
200dff0: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = p;
200dff4: c6 26 a0 3c st %g3, [ %i2 + 0x3c ] <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200dff8: 82 10 20 01 mov 1, %g1
200dffc: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
node = rtems_chain_next (node);
}
return NULL;
}
200e000: 81 c7 e0 08 ret
200e004: 91 e8 00 1d restore %g0, %i5, %o0
else
{
switch (p->avl.bal)
{
case -1:
p->avl.bal = 0;
200e008: c0 28 60 11 clrb [ %g1 + 0x11 ]
200e00c: 86 10 00 01 mov %g1, %g3
modified = false;
200e010: 10 bf ff db b 200df7c <rtems_bdbuf_get_buffer_from_lru_list+0x228>
200e014: b8 10 20 00 clr %i4
bool modified = false;
if (p == NULL)
{
*root = node;
200e018: fa 26 a0 3c st %i5, [ %i2 + 0x3c ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e01c: 82 10 20 01 mov 1, %g1
bool modified = false;
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
200e020: c0 27 60 08 clr [ %i5 + 8 ]
node->avl.right = NULL;
200e024: c0 27 60 0c clr [ %i5 + 0xc ]
node->avl.bal = 0;
200e028: c0 2f 60 11 clrb [ %i5 + 0x11 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e02c: 10 bf ff f5 b 200e000 <rtems_bdbuf_get_buffer_from_lru_list+0x2ac>
200e030: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
200e034: 80 a0 e0 00 cmp %g3, 0
200e038: 12 80 00 20 bne 200e0b8 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
200e03c: 80 a0 e0 01 cmp %g3, 1
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
200e040: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
200e044: 86 10 00 01 mov %g1, %g3
200e048: 10 bf ff cd b 200df7c <rtems_bdbuf_get_buffer_from_lru_list+0x228>
200e04c: b8 10 20 01 mov 1, %i4
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
200e050: c8 00 60 0c ld [ %g1 + 0xc ], %g4
if (p1->avl.bal == 1) /* simple RR-turn */
200e054: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
200e058: 80 a0 e0 01 cmp %g3, 1
200e05c: 02 80 00 32 be 200e124 <rtems_bdbuf_get_buffer_from_lru_list+0x3d0>
200e060: c6 01 20 08 ld [ %g4 + 8 ], %g3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200e064: f6 00 e0 0c ld [ %g3 + 0xc ], %i3
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200e068: f8 48 e0 11 ldsb [ %g3 + 0x11 ], %i4
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200e06c: f6 21 20 08 st %i3, [ %g4 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200e070: f6 00 e0 08 ld [ %g3 + 8 ], %i3
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
200e074: c8 20 e0 0c st %g4, [ %g3 + 0xc ]
p->avl.right = p2->avl.left;
200e078: f6 20 60 0c st %i3, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200e07c: 80 a7 20 01 cmp %i4, 1
200e080: 02 80 00 30 be 200e140 <rtems_bdbuf_get_buffer_from_lru_list+0x3ec><== NEVER TAKEN
200e084: c2 20 e0 08 st %g1, [ %g3 + 8 ]
200e088: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
200e08c: c2 48 e0 11 ldsb [ %g3 + 0x11 ], %g1
200e090: 80 a0 7f ff cmp %g1, -1
200e094: 22 80 00 06 be,a 200e0ac <rtems_bdbuf_get_buffer_from_lru_list+0x358><== NEVER TAKEN
200e098: f2 29 20 11 stb %i1, [ %g4 + 0x11 ] <== NOT EXECUTED
200e09c: c0 29 20 11 clrb [ %g4 + 0x11 ]
p = p2;
}
p->avl.bal = 0;
200e0a0: c0 28 e0 11 clrb [ %g3 + 0x11 ]
modified = false;
200e0a4: 10 bf ff b6 b 200df7c <rtems_bdbuf_get_buffer_from_lru_list+0x228>
200e0a8: b8 10 20 00 clr %i4
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
200e0ac: c0 28 e0 11 clrb [ %g3 + 0x11 ] <== NOT EXECUTED
modified = false;
200e0b0: 10 bf ff b3 b 200df7c <rtems_bdbuf_get_buffer_from_lru_list+0x228><== NOT EXECUTED
200e0b4: b8 10 20 00 clr %i4 <== NOT EXECUTED
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
200e0b8: 02 bf ff d4 be 200e008 <rtems_bdbuf_get_buffer_from_lru_list+0x2b4>
200e0bc: 80 a0 ff ff cmp %g3, -1
200e0c0: 32 bf ff ca bne,a 200dfe8 <rtems_bdbuf_get_buffer_from_lru_list+0x294><== NEVER TAKEN
200e0c4: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
200e0c8: c8 00 60 08 ld [ %g1 + 8 ], %g4
if (p1->avl.bal == -1) /* simple LL-turn */
200e0cc: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
200e0d0: 80 a0 ff ff cmp %g3, -1
200e0d4: 02 80 00 1d be 200e148 <rtems_bdbuf_get_buffer_from_lru_list+0x3f4>
200e0d8: c6 01 20 0c ld [ %g4 + 0xc ], %g3
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200e0dc: f6 00 e0 08 ld [ %g3 + 8 ], %i3
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
200e0e0: f8 48 e0 11 ldsb [ %g3 + 0x11 ], %i4
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200e0e4: f6 21 20 0c st %i3, [ %g4 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200e0e8: f6 00 e0 0c ld [ %g3 + 0xc ], %i3
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
200e0ec: c8 20 e0 08 st %g4, [ %g3 + 8 ]
p->avl.left = p2->avl.right;
200e0f0: f6 20 60 08 st %i3, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
200e0f4: 80 a7 3f ff cmp %i4, -1
200e0f8: 02 80 00 1b be 200e164 <rtems_bdbuf_get_buffer_from_lru_list+0x410>
200e0fc: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
200e100: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200e104: c2 48 e0 11 ldsb [ %g3 + 0x11 ], %g1
200e108: 80 a0 60 01 cmp %g1, 1
200e10c: 32 bf ff e5 bne,a 200e0a0 <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
200e110: c0 29 20 11 clrb [ %g4 + 0x11 ]
200e114: f0 29 20 11 stb %i0, [ %g4 + 0x11 ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
200e118: c0 28 e0 11 clrb [ %g3 + 0x11 ]
modified = false;
200e11c: 10 bf ff 98 b 200df7c <rtems_bdbuf_get_buffer_from_lru_list+0x228>
200e120: b8 10 20 00 clr %i4
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
200e124: c6 20 60 0c st %g3, [ %g1 + 0xc ]
p1->avl.left = p;
p->avl.bal = 0;
200e128: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
200e12c: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.bal = 0;
200e130: 86 10 00 04 mov %g4, %g3
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
modified = false;
200e134: b8 10 20 00 clr %i4
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
200e138: 10 bf ff 91 b 200df7c <rtems_bdbuf_get_buffer_from_lru_list+0x228>
200e13c: c0 28 e0 11 clrb [ %g3 + 0x11 ]
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200e140: 10 bf ff d3 b 200e08c <rtems_bdbuf_get_buffer_from_lru_list+0x338><== NOT EXECUTED
200e144: f0 28 60 11 stb %i0, [ %g1 + 0x11 ] <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
200e148: c6 20 60 08 st %g3, [ %g1 + 8 ]
p1->avl.right = p;
p->avl.bal = 0;
200e14c: c0 28 60 11 clrb [ %g1 + 0x11 ]
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
200e150: c2 21 20 0c st %g1, [ %g4 + 0xc ]
p->avl.bal = 0;
200e154: 86 10 00 04 mov %g4, %g3
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
modified = false;
200e158: b8 10 20 00 clr %i4
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
200e15c: 10 bf ff 88 b 200df7c <rtems_bdbuf_get_buffer_from_lru_list+0x228>
200e160: c0 28 e0 11 clrb [ %g3 + 0x11 ]
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
200e164: 10 bf ff e8 b 200e104 <rtems_bdbuf_get_buffer_from_lru_list+0x3b0>
200e168: f2 28 60 11 stb %i1, [ %g1 + 0x11 ]
0200edd4 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
200edd4: 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())
200edd8: 03 00 80 8b sethi %hi(0x2022c00), %g1
200eddc: c2 00 63 d8 ld [ %g1 + 0x3d8 ], %g1 ! 2022fd8 <_Per_CPU_Information+0x8>
200ede0: 80 a0 60 00 cmp %g1, 0
200ede4: 12 80 00 16 bne 200ee3c <rtems_bdbuf_init+0x68> <== NEVER TAKEN
200ede8: 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)
200edec: 3b 00 80 7f sethi %hi(0x201fc00), %i5
200edf0: ba 17 60 b8 or %i5, 0xb8, %i5 ! 201fcb8 <rtems_bdbuf_configuration>
200edf4: f4 07 60 28 ld [ %i5 + 0x28 ], %i2
200edf8: f6 07 60 24 ld [ %i5 + 0x24 ], %i3
200edfc: 90 10 00 1a mov %i2, %o0
200ee00: 92 10 00 1b mov %i3, %o1
200ee04: 40 00 3b 22 call 201da8c <.urem>
200ee08: b0 10 20 0a mov 0xa, %i0
200ee0c: 80 a2 20 00 cmp %o0, 0
200ee10: 12 80 00 fa bne 200f1f8 <rtems_bdbuf_init+0x424> <== NEVER TAKEN
200ee14: 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 ();
200ee18: 7f ff f9 a9 call 200d4bc <rtems_bdbuf_disable_preemption>
200ee1c: 33 00 80 89 sethi %hi(0x2022400), %i1
if (bdbuf_cache.initialised)
200ee20: b8 16 63 0c or %i1, 0x30c, %i4 ! 202270c <bdbuf_cache>
200ee24: c2 0f 20 95 ldub [ %i4 + 0x95 ], %g1
200ee28: 80 a0 60 00 cmp %g1, 0
200ee2c: 02 80 00 06 be 200ee44 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
200ee30: b0 10 00 08 mov %o0, %i0
{
rtems_bdbuf_restore_preemption (prev_mode);
200ee34: 7f ff f9 b0 call 200d4f4 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
200ee38: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
200ee3c: 81 c7 e0 08 ret <== NOT EXECUTED
200ee40: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
200ee44: 92 10 20 00 clr %o1
200ee48: 94 10 20 98 mov 0x98, %o2
200ee4c: 40 00 19 af call 2015508 <memset>
200ee50: 90 10 00 1c mov %i4, %o0
bdbuf_cache.initialised = true;
200ee54: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
200ee58: 90 10 00 18 mov %i0, %o0
200ee5c: 7f ff f9 a6 call 200d4f4 <rtems_bdbuf_restore_preemption>
200ee60: c2 2f 20 95 stb %g1, [ %i4 + 0x95 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee64: 82 07 20 0c add %i4, 0xc, %g1
200ee68: c2 27 20 08 st %g1, [ %i4 + 8 ]
head->previous = NULL;
tail->previous = head;
200ee6c: 82 07 20 08 add %i4, 8, %g1
200ee70: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee74: 82 07 20 50 add %i4, 0x50, %g1
head->previous = NULL;
tail->previous = head;
200ee78: 84 07 20 40 add %i4, 0x40, %g2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee7c: c2 27 20 4c st %g1, [ %i4 + 0x4c ]
200ee80: 82 07 20 5c add %i4, 0x5c, %g1
head->previous = NULL;
tail->previous = head;
200ee84: c4 27 20 48 st %g2, [ %i4 + 0x48 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee88: c2 27 20 58 st %g1, [ %i4 + 0x58 ]
head->previous = NULL;
tail->previous = head;
200ee8c: 84 07 20 4c add %i4, 0x4c, %g2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee90: 82 07 20 8c add %i4, 0x8c, %g1
head->previous = NULL;
tail->previous = head;
200ee94: c4 27 20 54 st %g2, [ %i4 + 0x54 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee98: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
head->previous = NULL;
tail->previous = head;
200ee9c: 84 07 20 58 add %i4, 0x58, %g2
200eea0: 82 07 20 88 add %i4, 0x88, %g1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200eea4: a0 07 20 44 add %i4, 0x44, %l0
*/
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;
200eea8: c0 27 20 38 clr [ %i4 + 0x38 ]
head->previous = NULL;
200eeac: c0 27 20 0c clr [ %i4 + 0xc ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200eeb0: e0 27 20 40 st %l0, [ %i4 + 0x40 ]
head->previous = NULL;
200eeb4: c0 27 20 44 clr [ %i4 + 0x44 ]
200eeb8: c0 27 20 50 clr [ %i4 + 0x50 ]
200eebc: c0 27 20 5c clr [ %i4 + 0x5c ]
tail->previous = head;
200eec0: c4 27 20 60 st %g2, [ %i4 + 0x60 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200eec4: c0 27 20 8c clr [ %i4 + 0x8c ]
rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
200eec8: 31 10 91 10 sethi %hi(0x42444000), %i0
tail->previous = head;
200eecc: c2 27 20 90 st %g1, [ %i4 + 0x90 ]
200eed0: 90 16 23 6c or %i0, 0x36c, %o0
200eed4: 92 10 20 01 mov 1, %o1
200eed8: 94 10 20 54 mov 0x54, %o2
200eedc: 96 10 20 00 clr %o3
200eee0: 7f ff e7 6f call 2008c9c <rtems_semaphore_create>
200eee4: 98 07 20 28 add %i4, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
200eee8: 80 a2 20 00 cmp %o0, 0
200eeec: 02 80 00 2d be 200efa0 <rtems_bdbuf_init+0x1cc> <== ALWAYS TAKEN
200eef0: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
200eef4: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
200eef8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200eefc: 12 80 00 25 bne 200ef90 <rtems_bdbuf_init+0x1bc> <== NOT EXECUTED
200ef00: 01 00 00 00 nop <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
if (bdbuf_cache.swapout != 0)
200ef04: d0 06 63 0c ld [ %i1 + 0x30c ], %o0 <== NOT EXECUTED
200ef08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200ef0c: 12 80 00 1e bne 200ef84 <rtems_bdbuf_init+0x1b0> <== NOT EXECUTED
200ef10: 01 00 00 00 nop <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
free (bdbuf_cache.buffers);
200ef14: 7f ff d6 5a call 200487c <free> <== NOT EXECUTED
200ef18: d0 07 20 18 ld [ %i4 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
200ef1c: 7f ff d6 58 call 200487c <free> <== NOT EXECUTED
200ef20: d0 07 20 80 ld [ %i4 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
200ef24: 7f ff d6 56 call 200487c <free> <== NOT EXECUTED
200ef28: d0 07 20 14 ld [ %i4 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
200ef2c: 7f ff e7 cd call 2008e60 <rtems_semaphore_delete> <== NOT EXECUTED
200ef30: d0 07 20 78 ld [ %i4 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
200ef34: 7f ff e7 cb call 2008e60 <rtems_semaphore_delete> <== NOT EXECUTED
200ef38: d0 07 20 68 ld [ %i4 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
200ef3c: 7f ff e7 c9 call 2008e60 <rtems_semaphore_delete> <== NOT EXECUTED
200ef40: d0 07 20 70 ld [ %i4 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
200ef44: 7f ff e7 c7 call 2008e60 <rtems_semaphore_delete> <== NOT EXECUTED
200ef48: d0 07 20 2c ld [ %i4 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
200ef4c: c2 07 20 28 ld [ %i4 + 0x28 ], %g1 <== NOT EXECUTED
200ef50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200ef54: 12 80 00 05 bne 200ef68 <rtems_bdbuf_init+0x194> <== NOT EXECUTED
200ef58: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
200ef5c: c0 2f 20 95 clrb [ %i4 + 0x95 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
200ef60: 81 c7 e0 08 ret <== NOT EXECUTED
200ef64: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
rtems_semaphore_delete (bdbuf_cache.sync_lock);
if (bdbuf_cache.lock != 0)
{
rtems_bdbuf_unlock_cache ();
200ef68: 7f ff f9 42 call 200d470 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200ef6c: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
200ef70: 7f ff e7 bc call 2008e60 <rtems_semaphore_delete> <== NOT EXECUTED
200ef74: d0 07 20 28 ld [ %i4 + 0x28 ], %o0 <== NOT EXECUTED
200ef78: c0 2f 20 95 clrb [ %i4 + 0x95 ] <== NOT EXECUTED
200ef7c: 81 c7 e0 08 ret <== NOT EXECUTED
200ef80: 81 e8 00 00 restore <== NOT EXECUTED
if (bdbuf_cache.read_ahead_task != 0)
rtems_task_delete (bdbuf_cache.read_ahead_task);
if (bdbuf_cache.swapout != 0)
rtems_task_delete (bdbuf_cache.swapout);
200ef84: 7f ff e8 c6 call 200929c <rtems_task_delete> <== NOT EXECUTED
200ef88: 01 00 00 00 nop <== NOT EXECUTED
200ef8c: 30 bf ff e2 b,a 200ef14 <rtems_bdbuf_init+0x140> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
rtems_task_delete (bdbuf_cache.read_ahead_task);
200ef90: 7f ff e8 c3 call 200929c <rtems_task_delete> <== NOT EXECUTED
200ef94: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
200ef98: 10 bf ff dc b 200ef08 <rtems_bdbuf_init+0x134> <== NOT EXECUTED
200ef9c: d0 06 63 0c ld [ %i1 + 0x30c ], %o0 <== NOT EXECUTED
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
goto error;
rtems_bdbuf_lock_cache ();
200efa0: 7f ff f9 1e call 200d418 <rtems_bdbuf_lock_cache>
200efa4: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
200efa8: 90 16 23 73 or %i0, 0x373, %o0
200efac: 92 10 20 01 mov 1, %o1
200efb0: 94 10 20 54 mov 0x54, %o2
200efb4: 96 10 20 00 clr %o3
200efb8: 7f ff e7 39 call 2008c9c <rtems_semaphore_create>
200efbc: 98 07 20 2c add %i4, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
200efc0: 80 a2 20 00 cmp %o0, 0
200efc4: 32 bf ff cd bne,a 200eef8 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
200efc8: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
200efcc: 90 16 23 61 or %i0, 0x361, %o0
200efd0: 92 10 20 00 clr %o1
200efd4: 94 10 20 24 mov 0x24, %o2
200efd8: 96 10 20 00 clr %o3
200efdc: 7f ff e7 30 call 2008c9c <rtems_semaphore_create>
200efe0: 98 07 20 68 add %i4, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200efe4: 80 a2 20 00 cmp %o0, 0
200efe8: 32 bf ff c4 bne,a 200eef8 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
200efec: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
200eff0: 90 16 23 74 or %i0, 0x374, %o0
200eff4: 92 10 20 00 clr %o1
200eff8: 94 10 20 24 mov 0x24, %o2
200effc: 96 10 20 00 clr %o3
200f000: 7f ff e7 27 call 2008c9c <rtems_semaphore_create>
200f004: 98 07 20 70 add %i4, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200f008: 80 a2 20 00 cmp %o0, 0
200f00c: 32 bf ff bb bne,a 200eef8 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
200f010: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
200f014: 90 16 23 62 or %i0, 0x362, %o0
200f018: 92 10 20 00 clr %o1
200f01c: 94 10 20 24 mov 0x24, %o2
200f020: 96 10 20 00 clr %o3
200f024: 7f ff e7 1e call 2008c9c <rtems_semaphore_create>
200f028: 98 07 20 78 add %i4, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200f02c: 80 a2 20 00 cmp %o0, 0
200f030: 32 bf ff b2 bne,a 200eef8 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
200f034: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
200f038: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200f03c: 40 00 39 e8 call 201d7dc <.udiv>
200f040: 92 10 00 1b mov %i3, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200f044: 92 10 00 1b mov %i3, %o1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
200f048: b0 10 00 08 mov %o0, %i0
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
200f04c: d0 27 20 1c st %o0, [ %i4 + 0x1c ]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200f050: 40 00 39 e3 call 201d7dc <.udiv>
200f054: 90 10 00 1a mov %i2, %o0
200f058: 82 10 00 08 mov %o0, %g1
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200f05c: 90 10 00 18 mov %i0, %o0
200f060: 92 10 00 01 mov %g1, %o1
200f064: 40 00 39 de call 201d7dc <.udiv>
200f068: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200f06c: 92 10 00 18 mov %i0, %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 =
200f070: d0 27 20 7c st %o0, [ %i4 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200f074: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200f078: 7f ff d5 30 call 2004538 <calloc>
200f07c: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
200f080: 80 a2 20 00 cmp %o0, 0
200f084: 02 bf ff 9c be 200eef4 <rtems_bdbuf_init+0x120> <== NEVER TAKEN
200f088: d0 27 20 14 st %o0, [ %i4 + 0x14 ]
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
200f08c: 90 10 20 14 mov 0x14, %o0
200f090: 7f ff d5 2a call 2004538 <calloc>
200f094: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
200f098: 80 a2 20 00 cmp %o0, 0
200f09c: 02 bf ff 96 be 200eef4 <rtems_bdbuf_init+0x120> <== NEVER TAKEN
200f0a0: d0 27 20 80 st %o0, [ %i4 + 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)
200f0a4: 92 10 00 1b mov %i3, %o1
200f0a8: 40 00 39 93 call 201d6f4 <.umul>
200f0ac: 90 10 00 18 mov %i0, %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,
200f0b0: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
200f0b4: 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,
200f0b8: 11 00 80 89 sethi %hi(0x2022400), %o0
200f0bc: 40 00 07 a3 call 2010f48 <rtems_memalign>
200f0c0: 90 12 23 24 or %o0, 0x324, %o0 ! 2022724 <bdbuf_cache+0x18>
200f0c4: 80 a2 20 00 cmp %o0, 0
200f0c8: 32 bf ff 8c bne,a 200eef8 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
200f0cc: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
/*
* 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,
200f0d0: f0 07 20 80 ld [ %i4 + 0x80 ], %i0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200f0d4: e2 07 20 14 ld [ %i4 + 0x14 ], %l1
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
200f0d8: ea 07 20 20 ld [ %i4 + 0x20 ], %l5
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200f0dc: e8 07 20 18 ld [ %i4 + 0x18 ], %l4
b < bdbuf_cache.buffer_min_count;
200f0e0: ee 07 20 1c ld [ %i4 + 0x1c ], %l7
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
200f0e4: ac 05 7f ff add %l5, -1, %l6
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200f0e8: b4 10 00 11 mov %l1, %i2
/*
* 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,
200f0ec: a6 10 00 18 mov %i0, %l3
200f0f0: a4 10 20 00 clr %l2
200f0f4: 80 a4 80 17 cmp %l2, %l7
200f0f8: 02 80 00 13 be 200f144 <rtems_bdbuf_init+0x370>
200f0fc: 90 10 00 12 mov %l2, %o0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
bd->group = group;
200f100: e6 26 a0 28 st %l3, [ %i2 + 0x28 ]
bd->buffer = buffer;
200f104: e8 26 a0 1c st %l4, [ %i2 + 0x1c ]
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
200f108: c0 26 a0 14 clr [ %i2 + 0x14 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200f10c: c2 07 20 48 ld [ %i4 + 0x48 ], %g1
the_node->next = tail;
200f110: e0 26 80 00 st %l0, [ %i2 ]
tail->previous = the_node;
200f114: f4 27 20 48 st %i2, [ %i4 + 0x48 ]
old_last->next = the_node;
200f118: f4 20 40 00 st %i2, [ %g1 ]
the_node->previous = old_last;
200f11c: c2 26 a0 04 st %g1, [ %i2 + 4 ]
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
200f120: 40 00 3a 5b call 201da8c <.urem>
200f124: 92 10 00 15 mov %l5, %o1
200f128: 80 a2 00 16 cmp %o0, %l6
200f12c: 22 80 00 02 be,a 200f134 <rtems_bdbuf_init+0x360>
200f130: a6 04 e0 14 add %l3, 0x14, %l3
* 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)
200f134: a4 04 a0 01 inc %l2
200f138: b4 06 a0 38 add %i2, 0x38, %i2
200f13c: 10 bf ff ee b 200f0f4 <rtems_bdbuf_init+0x320>
200f140: a8 05 00 1b add %l4, %i3, %l4
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200f144: c4 07 20 20 ld [ %i4 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
200f148: f6 07 20 7c ld [ %i4 + 0x7c ], %i3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
200f14c: 87 28 a0 03 sll %g2, 3, %g3
200f150: 89 28 a0 06 sll %g2, 6, %g4
200f154: 82 10 20 00 clr %g1
200f158: 86 21 00 03 sub %g4, %g3, %g3
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
200f15c: 80 a0 40 1b cmp %g1, %i3
200f160: 02 80 00 07 be 200f17c <rtems_bdbuf_init+0x3a8>
200f164: 82 00 60 01 inc %g1
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
200f168: e2 26 20 10 st %l1, [ %i0 + 0x10 ]
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200f16c: c4 26 20 08 st %g2, [ %i0 + 8 ]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
200f170: b0 06 20 14 add %i0, 0x14, %i0
bd += bdbuf_cache.max_bds_per_group)
200f174: 10 bf ff fa b 200f15c <rtems_bdbuf_init+0x388>
200f178: a2 04 40 03 add %l1, %g3, %l1
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200f17c: d2 07 60 08 ld [ %i5 + 8 ], %o1
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
200f180: b6 10 20 01 mov 1, %i3
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200f184: 11 10 94 d5 sethi %hi(0x42535400), %o0
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
200f188: f6 2f 20 04 stb %i3, [ %i4 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200f18c: 90 12 23 50 or %o0, 0x350, %o0
200f190: 96 10 20 00 clr %o3
200f194: 15 00 80 39 sethi %hi(0x200e400), %o2
200f198: 98 10 00 1c mov %i4, %o4
200f19c: 7f ff f9 a6 call 200d834 <rtems_bdbuf_create_task.constprop.9>
200f1a0: 94 12 a3 68 or %o2, 0x368, %o2
bdbuf_config.swapout_priority,
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_task,
0,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
200f1a4: 80 a2 20 00 cmp %o0, 0
200f1a8: 32 bf ff 54 bne,a 200eef8 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
200f1ac: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
200f1b0: 03 00 80 7f sethi %hi(0x201fc00), %g1
200f1b4: c2 00 60 b8 ld [ %g1 + 0xb8 ], %g1 ! 201fcb8 <rtems_bdbuf_configuration>
200f1b8: 80 a0 60 00 cmp %g1, 0
200f1bc: 02 80 00 0d be 200f1f0 <rtems_bdbuf_init+0x41c>
200f1c0: 11 10 94 91 sethi %hi(0x42524400), %o0
{
bdbuf_cache.read_ahead_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
200f1c4: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
if (sc != RTEMS_SUCCESSFUL)
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
{
bdbuf_cache.read_ahead_enabled = true;
200f1c8: f6 2f 20 94 stb %i3, [ %i4 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
200f1cc: 15 00 80 3b sethi %hi(0x200ec00), %o2
200f1d0: 90 12 20 41 or %o0, 0x41, %o0
200f1d4: 94 12 a0 80 or %o2, 0x80, %o2
200f1d8: 96 10 20 00 clr %o3
200f1dc: 7f ff f9 96 call 200d834 <rtems_bdbuf_create_task.constprop.9>
200f1e0: 98 07 20 84 add %i4, 0x84, %o4
bdbuf_config.read_ahead_priority,
RTEMS_BDBUF_READ_AHEAD_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_read_ahead_task,
0,
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
200f1e4: 80 a2 20 00 cmp %o0, 0
200f1e8: 32 bf ff 44 bne,a 200eef8 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
200f1ec: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
}
rtems_bdbuf_unlock_cache ();
200f1f0: 7f ff f8 a0 call 200d470 <rtems_bdbuf_unlock_cache>
200f1f4: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200f1f8: 81 c7 e0 08 ret
200f1fc: 81 e8 00 00 restore
0200d3e4 <rtems_bdbuf_lock>:
* @param lock The mutex to lock.
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
200d3e4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
200d3e8: 92 10 20 00 clr %o1
200d3ec: 90 10 00 18 mov %i0, %o0
200d3f0: 7f ff ee d3 call 2008f3c <rtems_semaphore_obtain>
200d3f4: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200d3f8: 80 a2 20 00 cmp %o0, 0
200d3fc: 12 80 00 04 bne 200d40c <rtems_bdbuf_lock+0x28> <== NEVER TAKEN
200d400: 01 00 00 00 nop
200d404: 81 c7 e0 08 ret
200d408: 81 e8 00 00 restore
rtems_bdbuf_fatal (fatal_error_code);
200d40c: 7f ff ff f1 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d410: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
0200f818 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
200f818: 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;
200f81c: b4 07 bf 74 add %fp, -140, %i2
200f820: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
200f824: c0 27 bf 78 clr [ %fp + -136 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200f828: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
200f82c: 7f ff f6 fb call 200d418 <rtems_bdbuf_lock_cache>
200f830: f4 27 bf 7c st %i2, [ %fp + -132 ]
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200f834: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
200f838: 80 a0 60 00 cmp %g1, 0
200f83c: 02 80 00 70 be 200f9fc <rtems_bdbuf_purge_dev+0x1e4> <== ALWAYS TAKEN
200f840: c4 06 20 68 ld [ %i0 + 0x68 ], %g2
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
200f844: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
200f848: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200f84c: c0 26 20 68 clr [ %i0 + 0x68 ] <== NOT EXECUTED
200f850: c0 26 20 64 clr [ %i0 + 0x64 ] <== NOT EXECUTED
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;
200f854: 03 00 80 89 sethi %hi(0x2022400), %g1 <== NOT EXECUTED
200f858: 82 10 63 0c or %g1, 0x30c, %g1 ! 202270c <bdbuf_cache>
200f85c: fa 00 60 3c ld [ %g1 + 0x3c ], %i5
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200f860: 84 10 3f ff mov -1, %g2
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
200f864: c0 27 bf 80 clr [ %fp + -128 ]
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200f868: c4 26 20 6c st %g2, [ %i0 + 0x6c ]
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
200f86c: 80 a7 60 00 cmp %i5, 0
200f870: 02 80 00 2e be 200f928 <rtems_bdbuf_purge_dev+0x110>
200f874: b8 07 bf 80 add %fp, -128, %i4
{
if (cur->dd == dd)
{
switch (cur->state)
200f878: 33 00 80 34 sethi %hi(0x200d000), %i1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f87c: a2 10 20 06 mov 6, %l1
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200f880: b2 16 62 20 or %i1, 0x220, %i1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f884: a4 10 20 0a mov 0xa, %l2
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);
200f888: 10 80 00 09 b 200f8ac <rtems_bdbuf_purge_dev+0x94>
200f88c: a0 00 60 6c add %g1, 0x6c, %l0
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
}
}
if (cur->avl.left != NULL)
200f890: c2 07 60 08 ld [ %i5 + 8 ], %g1
200f894: 80 a0 60 00 cmp %g1, 0
200f898: 22 80 00 0f be,a 200f8d4 <rtems_bdbuf_purge_dev+0xbc>
200f89c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
200f8a0: fa 27 20 04 st %i5, [ %i4 + 4 ]
200f8a4: ba 10 00 01 mov %g1, %i5
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
200f8a8: b8 07 20 04 add %i4, 4, %i4
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
200f8ac: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200f8b0: 80 a6 00 01 cmp %i0, %g1
200f8b4: 32 bf ff f8 bne,a 200f894 <rtems_bdbuf_purge_dev+0x7c>
200f8b8: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
switch (cur->state)
200f8bc: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200f8c0: 80 a0 60 0a cmp %g1, 0xa
200f8c4: 28 80 00 34 bleu,a 200f994 <rtems_bdbuf_purge_dev+0x17c> <== ALWAYS TAKEN
200f8c8: 83 28 60 02 sll %g1, 2, %g1
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_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
200f8cc: 7f ff f6 c1 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200f8d0: 90 10 20 17 mov 0x17, %o0 <== NOT EXECUTED
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
200f8d4: 80 a0 60 00 cmp %g1, 0
200f8d8: 32 bf ff f3 bne,a 200f8a4 <rtems_bdbuf_purge_dev+0x8c>
200f8dc: fa 27 20 04 st %i5, [ %i4 + 4 ]
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
200f8e0: c2 07 00 00 ld [ %i4 ], %g1
200f8e4: 80 a0 60 00 cmp %g1, 0
200f8e8: 32 80 00 06 bne,a 200f900 <rtems_bdbuf_purge_dev+0xe8>
200f8ec: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200f8f0: 10 80 00 0f b 200f92c <rtems_bdbuf_purge_dev+0x114>
200f8f4: d0 07 bf 74 ld [ %fp + -140 ], %o0
200f8f8: 82 10 00 02 mov %g2, %g1
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
200f8fc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200f900: 80 a0 80 1d cmp %g2, %i5
200f904: 02 80 00 04 be 200f914 <rtems_bdbuf_purge_dev+0xfc>
200f908: 80 a0 a0 00 cmp %g2, 0
200f90c: 32 bf ff e8 bne,a 200f8ac <rtems_bdbuf_purge_dev+0x94>
200f910: ba 10 00 02 mov %g2, %i5
{
/* Up */
cur = *prev;
--prev;
200f914: b8 07 3f fc add %i4, -4, %i4
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
200f918: c4 07 00 00 ld [ %i4 ], %g2
200f91c: 80 a0 a0 00 cmp %g2, 0
200f920: 12 bf ff f6 bne 200f8f8 <rtems_bdbuf_purge_dev+0xe0>
200f924: ba 10 00 01 mov %g1, %i5
200f928: d0 07 bf 74 ld [ %fp + -140 ], %o0
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
200f92c: 86 10 20 00 clr %g3
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f930: ba 10 20 01 mov 1, %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200f934: 80 a2 00 1b cmp %o0, %i3
200f938: 02 80 00 0f be 200f974 <rtems_bdbuf_purge_dev+0x15c>
200f93c: 80 88 e0 ff btst 0xff, %g3
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
200f940: c2 02 00 00 ld [ %o0 ], %g1
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
200f944: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
head->next = new_first;
200f948: c2 27 bf 74 st %g1, [ %fp + -140 ]
200f94c: 80 a0 a0 00 cmp %g2, 0
200f950: 12 80 00 28 bne 200f9f0 <rtems_bdbuf_purge_dev+0x1d8>
200f954: f4 20 60 04 st %i2, [ %g1 + 4 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f958: 7f ff f8 ca call 200dc80 <rtems_bdbuf_discard_buffer.part.4>
200f95c: fa 22 20 20 st %i5, [ %o0 + 0x20 ]
200f960: d0 07 bf 74 ld [ %fp + -140 ], %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200f964: 80 a2 00 1b cmp %o0, %i3
200f968: 12 bf ff f6 bne 200f940 <rtems_bdbuf_purge_dev+0x128>
200f96c: 86 10 20 01 mov 1, %g3
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
200f970: 80 88 e0 ff btst 0xff, %g3
200f974: 02 80 00 04 be 200f984 <rtems_bdbuf_purge_dev+0x16c>
200f978: 11 00 80 89 sethi %hi(0x2022400), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200f97c: 7f ff f7 5e call 200d6f4 <rtems_bdbuf_wake>
200f980: 90 12 23 80 or %o0, 0x380, %o0 ! 2022780 <bdbuf_cache+0x74>
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_read_ahead_reset (dd);
rtems_bdbuf_gather_for_purge (&purge_list, dd);
rtems_bdbuf_purge_list (&purge_list);
rtems_bdbuf_unlock_cache ();
200f984: 7f ff f6 bb call 200d470 <rtems_bdbuf_unlock_cache>
200f988: 01 00 00 00 nop
200f98c: 81 c7 e0 08 ret
200f990: 81 e8 00 00 restore
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200f994: c4 06 40 01 ld [ %i1 + %g1 ], %g2
200f998: 81 c0 80 00 jmp %g2
200f99c: 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);
200f9a0: 7f ff f7 55 call 200d6f4 <rtems_bdbuf_wake>
200f9a4: 90 10 00 10 mov %l0, %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200f9a8: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
200f9ac: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
200f9b0: 82 00 7f ff add %g1, -1, %g1
200f9b4: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200f9b8: c4 07 60 04 ld [ %i5 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200f9bc: c6 07 40 00 ld [ %i5 ], %g3
previous = the_node->previous;
next->previous = previous;
200f9c0: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
200f9c4: c6 20 80 00 st %g3, [ %g2 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200f9c8: c4 07 bf 7c ld [ %fp + -132 ], %g2
the_node->next = tail;
200f9cc: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
200f9d0: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
200f9d4: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
200f9d8: 10 bf ff ae b 200f890 <rtems_bdbuf_purge_dev+0x78>
200f9dc: c4 27 60 04 st %g2, [ %i5 + 4 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f9e0: 10 bf ff ac b 200f890 <rtems_bdbuf_purge_dev+0x78>
200f9e4: e2 27 60 20 st %l1, [ %i5 + 0x20 ]
200f9e8: 10 bf ff aa b 200f890 <rtems_bdbuf_purge_dev+0x78>
200f9ec: e4 27 60 20 st %l2, [ %i5 + 0x20 ]
200f9f0: fa 22 20 20 st %i5, [ %o0 + 0x20 ]
200f9f4: 10 bf ff d0 b 200f934 <rtems_bdbuf_purge_dev+0x11c>
200f9f8: 90 10 00 01 mov %g1, %o0
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200f9fc: 80 a0 a0 00 cmp %g2, 0
200fa00: 32 bf ff 92 bne,a 200f848 <rtems_bdbuf_purge_dev+0x30> <== NEVER TAKEN
200fa04: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
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;
200fa08: 10 bf ff 94 b 200f858 <rtems_bdbuf_purge_dev+0x40>
200fa0c: 03 00 80 89 sethi %hi(0x2022400), %g1
0200f300 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200f300: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
200f304: 7f ff f8 45 call 200d418 <rtems_bdbuf_lock_cache>
200f308: ba 10 00 18 mov %i0, %i5
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200f30c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
200f310: b8 10 20 00 clr %i4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200f314: 80 a6 40 01 cmp %i1, %g1
200f318: 0a 80 00 07 bcs 200f334 <rtems_bdbuf_read+0x34> <== ALWAYS TAKEN
200f31c: b0 10 20 04 mov 4, %i0
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
200f320: 7f ff f8 54 call 200d470 <rtems_bdbuf_unlock_cache>
200f324: 01 00 00 00 nop
*bd_ptr = bd;
200f328: f8 26 80 00 st %i4, [ %i2 ]
200f32c: 81 c7 e0 08 ret
200f330: 81 e8 00 00 restore
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200f334: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200f338: 80 a2 60 00 cmp %o1, 0
200f33c: 26 80 00 60 bl,a 200f4bc <rtems_bdbuf_read+0x1bc> <== NEVER TAKEN
200f340: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200f344: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200f348: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
{
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
200f34c: 90 10 00 1d mov %i5, %o0
200f350: 7f ff fb 9e call 200e1c8 <rtems_bdbuf_get_buffer_for_access>
200f354: 92 02 40 01 add %o1, %g1, %o1
200f358: b8 10 00 08 mov %o0, %i4
switch (bd->state)
200f35c: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200f360: 80 a2 20 02 cmp %o0, 2
200f364: 02 80 00 4f be 200f4a0 <rtems_bdbuf_read+0x1a0>
200f368: 80 a2 20 07 cmp %o0, 7
200f36c: 02 80 00 06 be 200f384 <rtems_bdbuf_read+0x84>
200f370: 80 a2 20 01 cmp %o0, 1
200f374: 22 80 00 28 be,a 200f414 <rtems_bdbuf_read+0x114> <== ALWAYS TAKEN
200f378: c4 07 60 48 ld [ %i5 + 0x48 ], %g2
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
200f37c: 7f ff f8 2d call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200f380: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
200f384: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f388: b0 10 20 00 clr %i0
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
200f38c: 82 00 60 01 inc %g1
200f390: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f394: 82 10 20 04 mov 4, %g1
200f398: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
200f39c: 37 00 80 89 sethi %hi(0x2022400), %i3
200f3a0: b6 16 e3 0c or %i3, 0x30c, %i3 ! 202270c <bdbuf_cache>
200f3a4: d0 06 e0 84 ld [ %i3 + 0x84 ], %o0
200f3a8: 80 a2 20 00 cmp %o0, 0
200f3ac: 02 bf ff dd be 200f320 <rtems_bdbuf_read+0x20>
200f3b0: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
200f3b4: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
200f3b8: 80 a6 40 01 cmp %i1, %g1
200f3bc: 12 bf ff d9 bne 200f320 <rtems_bdbuf_read+0x20>
200f3c0: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200f3c4: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
200f3c8: 80 a0 60 00 cmp %g1, 0
200f3cc: 12 bf ff d5 bne 200f320 <rtems_bdbuf_read+0x20> <== NEVER TAKEN
200f3d0: 01 00 00 00 nop
200f3d4: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
200f3d8: 80 a0 60 00 cmp %g1, 0
200f3dc: 12 bf ff d1 bne 200f320 <rtems_bdbuf_read+0x20> <== NEVER TAKEN
200f3e0: 01 00 00 00 nop
&& !rtems_bdbuf_is_read_ahead_active (dd))
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
200f3e4: c2 06 e0 88 ld [ %i3 + 0x88 ], %g1
200f3e8: b2 06 e0 8c add %i3, 0x8c, %i1
200f3ec: 80 a0 40 19 cmp %g1, %i1
200f3f0: 02 80 00 41 be 200f4f4 <rtems_bdbuf_read+0x1f4> <== ALWAYS TAKEN
200f3f4: 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;
200f3f8: c2 06 e0 90 ld [ %i3 + 0x90 ], %g1 <== NOT EXECUTED
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
200f3fc: 84 07 60 64 add %i5, 0x64, %g2
the_node->next = tail;
200f400: f2 27 60 64 st %i1, [ %i5 + 0x64 ]
tail->previous = the_node;
200f404: c4 26 e0 90 st %g2, [ %i3 + 0x90 ]
old_last->next = the_node;
200f408: c4 20 40 00 st %g2, [ %g1 ]
the_node->previous = old_last;
200f40c: 10 bf ff c5 b 200f320 <rtems_bdbuf_read+0x20>
200f410: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
200f414: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
200f418: 84 00 a0 01 inc %g2
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
200f41c: 80 a6 40 01 cmp %i1, %g1
200f420: 02 80 00 0e be 200f458 <rtems_bdbuf_read+0x158>
200f424: c4 27 60 48 st %g2, [ %i5 + 0x48 ]
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200f428: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
200f42c: 80 a0 60 00 cmp %g1, 0
200f430: 02 80 00 2c be 200f4e0 <rtems_bdbuf_read+0x1e0> <== ALWAYS TAKEN
200f434: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
200f438: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
200f43c: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200f440: c0 27 60 68 clr [ %i5 + 0x68 ] <== NOT EXECUTED
200f444: c0 27 60 64 clr [ %i5 + 0x64 ] <== NOT EXECUTED
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
200f448: 84 06 60 01 add %i1, 1, %g2 <== NOT EXECUTED
dd->read_ahead.next = block + 2;
200f44c: 82 06 60 02 add %i1, 2, %g1
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
200f450: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
200f454: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
rtems_bdbuf_set_read_ahead_trigger (dd, block);
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
200f458: 90 10 00 1d mov %i5, %o0
200f45c: 92 10 00 1c mov %i4, %o1
200f460: 7f ff fd cc call 200eb90 <rtems_bdbuf_execute_read_request>
200f464: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
200f468: b0 92 20 00 orcc %o0, 0, %i0
200f46c: 32 bf ff cc bne,a 200f39c <rtems_bdbuf_read+0x9c>
200f470: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200f474: c2 07 20 28 ld [ %i4 + 0x28 ], %g1
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200f478: c4 07 20 04 ld [ %i4 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200f47c: c6 07 00 00 ld [ %i4 ], %g3
200f480: c8 00 60 0c ld [ %g1 + 0xc ], %g4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f484: b6 10 20 03 mov 3, %i3
200f488: f6 27 20 20 st %i3, [ %i4 + 0x20 ]
previous = the_node->previous;
next->previous = previous;
200f48c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
200f490: c6 20 80 00 st %g3, [ %g2 ]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
200f494: 84 01 20 01 add %g4, 1, %g2
200f498: 10 bf ff c1 b 200f39c <rtems_bdbuf_read+0x9c>
200f49c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
200f4a0: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f4a4: b0 10 20 00 clr %i0
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
200f4a8: 82 00 60 01 inc %g1
200f4ac: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f4b0: 82 10 20 03 mov 3, %g1
200f4b4: 10 bf ff ba b 200f39c <rtems_bdbuf_read+0x9c>
200f4b8: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200f4bc: 94 10 20 00 clr %o2 <== NOT EXECUTED
200f4c0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200f4c4: 40 00 3a 1e call 201dd3c <__muldi3> <== NOT EXECUTED
200f4c8: 90 10 20 00 clr %o0 <== NOT EXECUTED
200f4cc: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
200f4d0: 40 00 3c 2c call 201e580 <__udivdi3> <== NOT EXECUTED
200f4d4: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200f4d8: 10 bf ff 9d b 200f34c <rtems_bdbuf_read+0x4c> <== NOT EXECUTED
200f4dc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200f4e0: 80 a0 a0 00 cmp %g2, 0
200f4e4: 32 bf ff d5 bne,a 200f438 <rtems_bdbuf_read+0x138> <== NEVER TAKEN
200f4e8: c4 07 60 68 ld [ %i5 + 0x68 ], %g2 <== NOT EXECUTED
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
200f4ec: 10 bf ff d8 b 200f44c <rtems_bdbuf_read+0x14c>
200f4f0: 84 06 60 01 add %i1, 1, %g2
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
200f4f4: 7f ff e5 59 call 2008a58 <rtems_event_send>
200f4f8: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
200f4fc: 80 a2 20 00 cmp %o0, 0
200f500: 22 bf ff bf be,a 200f3fc <rtems_bdbuf_read+0xfc> <== ALWAYS TAKEN
200f504: c2 06 e0 90 ld [ %i3 + 0x90 ], %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
200f508: 7f ff f7 b2 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200f50c: 90 10 20 07 mov 7, %o0 <== NOT EXECUTED
0200ec80 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
200ec80: 9d e3 bf a0 save %sp, -96, %sp
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
200ec84: 37 00 80 89 sethi %hi(0x2022400), %i3
200ec88: b6 16 e3 0c or %i3, 0x30c, %i3 ! 202270c <bdbuf_cache>
200ec8c: c2 0e e0 94 ldub [ %i3 + 0x94 ], %g1
200ec90: 80 a0 60 00 cmp %g1, 0
200ec94: 02 80 00 22 be 200ed1c <rtems_bdbuf_read_ahead_task+0x9c> <== NEVER TAKEN
200ec98: b0 06 e0 88 add %i3, 0x88, %i0
200ec9c: b2 06 e0 8c add %i3, 0x8c, %i1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200eca0: b4 10 00 1b mov %i3, %i2
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
{
uint32_t transfer_count = dd->block_count - block;
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
200eca4: 23 00 80 7f sethi %hi(0x201fc00), %l1
while (bdbuf_cache.read_ahead_enabled)
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
200eca8: 7f ff fa 53 call 200d5f4 <rtems_bdbuf_wait_for_event>
200ecac: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
200ecb0: 7f ff f9 da call 200d418 <rtems_bdbuf_lock_cache>
200ecb4: 01 00 00 00 nop
200ecb8: fa 06 e0 88 ld [ %i3 + 0x88 ], %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200ecbc: 80 a7 40 19 cmp %i5, %i1
200ecc0: 02 80 00 11 be 200ed04 <rtems_bdbuf_read_ahead_task+0x84>
200ecc4: 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;
200ecc8: c2 07 40 00 ld [ %i5 ], %g1
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
((char *) node - offsetof (rtems_disk_device, read_ahead.node));
rtems_blkdev_bnum block = dd->read_ahead.next;
200eccc: f8 07 60 0c ld [ %i5 + 0xc ], %i4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200ecd0: c4 07 7f c4 ld [ %i5 + -60 ], %g2
head->next = new_first;
200ecd4: c2 26 a0 88 st %g1, [ %i2 + 0x88 ]
200ecd8: 80 a7 00 02 cmp %i4, %g2
200ecdc: 0a 80 00 12 bcs 200ed24 <rtems_bdbuf_read_ahead_task+0xa4>
200ece0: f0 20 60 04 st %i0, [ %g1 + 4 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200ece4: c0 27 60 04 clr [ %i5 + 4 ]
200ece8: c0 27 40 00 clr [ %i5 ]
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200ecec: 82 10 3f ff mov -1, %g1
200ecf0: c2 27 60 08 st %g1, [ %i5 + 8 ]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200ecf4: fa 06 e0 88 ld [ %i3 + 0x88 ], %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200ecf8: 80 a7 40 19 cmp %i5, %i1
200ecfc: 32 bf ff f4 bne,a 200eccc <rtems_bdbuf_read_ahead_task+0x4c><== NEVER TAKEN
200ed00: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
}
}
rtems_bdbuf_unlock_cache ();
200ed04: 7f ff f9 db call 200d470 <rtems_bdbuf_unlock_cache>
200ed08: 01 00 00 00 nop
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
200ed0c: c2 0e a0 94 ldub [ %i2 + 0x94 ], %g1
200ed10: 80 a0 60 00 cmp %g1, 0
200ed14: 12 bf ff e5 bne 200eca8 <rtems_bdbuf_read_ahead_task+0x28><== ALWAYS TAKEN
200ed18: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
200ed1c: 7f ff e9 60 call 200929c <rtems_task_delete> <== NOT EXECUTED
200ed20: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200ed24: d2 07 7f cc ld [ %i5 + -52 ], %o1
200ed28: 80 a2 60 00 cmp %o1, 0
200ed2c: 26 80 00 21 bl,a 200edb0 <rtems_bdbuf_read_ahead_task+0x130><== NEVER TAKEN
200ed30: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200ed34: 93 2f 00 09 sll %i4, %o1, %o1
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200ed38: c2 07 7f b4 ld [ %i5 + -76 ], %g1
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
200ed3c: a0 07 7f 9c add %i5, -100, %l0
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_buffer *bd =
200ed40: 92 02 40 01 add %o1, %g1, %o1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200ed44: c0 27 60 04 clr [ %i5 + 4 ]
200ed48: c0 27 40 00 clr [ %i5 ]
200ed4c: 7f ff fd 08 call 200e16c <rtems_bdbuf_get_buffer_for_read_ahead>
200ed50: 90 10 00 10 mov %l0, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
200ed54: 92 92 20 00 orcc %o0, 0, %o1
200ed58: 02 bf ff d8 be 200ecb8 <rtems_bdbuf_read_ahead_task+0x38> <== NEVER TAKEN
200ed5c: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
200ed60: d4 07 7f c4 ld [ %i5 + -60 ], %o2
200ed64: 94 22 80 1c sub %o2, %i4, %o2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
200ed68: 80 a2 80 01 cmp %o2, %g1
200ed6c: 2a 80 00 0f bcs,a 200eda8 <rtems_bdbuf_read_ahead_task+0x128>
200ed70: 82 10 3f ff mov -1, %g1
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
dd->read_ahead.next = block + transfer_count;
200ed74: 84 00 40 1c add %g1, %i4, %g2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200ed78: 87 30 60 01 srl %g1, 1, %g3
dd->read_ahead.next = block + transfer_count;
200ed7c: c4 27 60 0c st %g2, [ %i5 + 0xc ]
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200ed80: b8 00 c0 1c add %g3, %i4, %i4
dd->read_ahead.next = block + transfer_count;
200ed84: 94 10 00 01 mov %g1, %o2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200ed88: f8 27 60 08 st %i4, [ %i5 + 8 ]
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
200ed8c: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200ed90: 90 10 00 10 mov %l0, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
200ed94: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200ed98: 7f ff ff 7e call 200eb90 <rtems_bdbuf_execute_read_request>
200ed9c: c2 27 7f e8 st %g1, [ %i5 + -24 ]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200eda0: 10 bf ff c7 b 200ecbc <rtems_bdbuf_read_ahead_task+0x3c>
200eda4: fa 06 e0 88 ld [ %i3 + 0x88 ], %i5
dd->read_ahead.trigger = block + transfer_count / 2;
dd->read_ahead.next = block + transfer_count;
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200eda8: 10 bf ff f9 b 200ed8c <rtems_bdbuf_read_ahead_task+0x10c>
200edac: c2 27 60 08 st %g1, [ %i5 + 8 ]
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200edb0: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
200edb4: 94 10 20 00 clr %o2 <== NOT EXECUTED
200edb8: 40 00 3b e1 call 201dd3c <__muldi3> <== NOT EXECUTED
200edbc: 90 10 20 00 clr %o0 <== NOT EXECUTED
200edc0: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
200edc4: 40 00 3d ef call 201e580 <__udivdi3> <== NOT EXECUTED
200edc8: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200edcc: 10 bf ff dc b 200ed3c <rtems_bdbuf_read_ahead_task+0xbc> <== NOT EXECUTED
200edd0: c2 07 7f b4 ld [ %i5 + -76 ], %g1 <== NOT EXECUTED
0200f514 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
200f514: 9d e3 bf a0 save %sp, -96, %sp
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
200f518: 80 a6 20 00 cmp %i0, 0
200f51c: 02 80 00 0f be 200f558 <rtems_bdbuf_release+0x44> <== NEVER TAKEN
200f520: 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();
200f524: 7f ff f7 bd call 200d418 <rtems_bdbuf_lock_cache>
200f528: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200f52c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200f530: 80 a2 20 04 cmp %o0, 4
200f534: 02 80 00 14 be 200f584 <rtems_bdbuf_release+0x70>
200f538: 01 00 00 00 nop
200f53c: 18 80 00 09 bgu 200f560 <rtems_bdbuf_release+0x4c>
200f540: 80 a2 20 06 cmp %o0, 6
200f544: 80 a2 20 03 cmp %o0, 3
200f548: 22 80 00 15 be,a 200f59c <rtems_bdbuf_release+0x88> <== ALWAYS TAKEN
200f54c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
200f550: 7f ff f7 b8 call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200f554: 92 10 20 0e mov 0xe, %o1 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
200f558: 81 c7 e0 08 ret <== NOT EXECUTED
200f55c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200f560: 18 bf ff fc bgu 200f550 <rtems_bdbuf_release+0x3c> <== NEVER TAKEN
200f564: 01 00 00 00 nop
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);
200f568: 90 10 00 18 mov %i0, %o0
200f56c: 7f ff f9 d2 call 200dcb4 <rtems_bdbuf_discard_buffer_after_access>
200f570: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200f574: 7f ff f7 bf call 200d470 <rtems_bdbuf_unlock_cache>
200f578: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
200f57c: 81 c7 e0 08 ret
200f580: 81 e8 00 00 restore
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
200f584: 7f ff f8 6b call 200d730 <rtems_bdbuf_add_to_modified_list_after_access>
200f588: 90 10 00 18 mov %i0, %o0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200f58c: 7f ff f7 b9 call 200d470 <rtems_bdbuf_unlock_cache>
200f590: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200f594: 81 c7 e0 08 ret
200f598: 81 e8 00 00 restore
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200f59c: 11 00 80 89 sethi %hi(0x2022400), %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
200f5a0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200f5a4: 90 12 23 0c or %o0, 0x30c, %o0
200f5a8: 84 00 bf ff add %g2, -1, %g2
200f5ac: 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;
200f5b0: 82 10 20 02 mov 2, %g1
the_node->next = tail;
200f5b4: 84 02 20 44 add %o0, 0x44, %g2
200f5b8: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200f5bc: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
200f5c0: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
200f5c4: f0 22 20 48 st %i0, [ %o0 + 0x48 ]
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)
200f5c8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
old_last->next = the_node;
the_node->previous = old_last;
200f5cc: c2 26 20 04 st %g1, [ %i0 + 4 ]
200f5d0: 80 a0 a0 00 cmp %g2, 0
200f5d4: 12 80 00 05 bne 200f5e8 <rtems_bdbuf_release+0xd4>
200f5d8: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200f5dc: 7f ff f8 46 call 200d6f4 <rtems_bdbuf_wake>
200f5e0: 90 02 20 74 add %o0, 0x74, %o0
200f5e4: 30 bf ff ea b,a 200f58c <rtems_bdbuf_release+0x78>
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200f5e8: 7f ff f8 43 call 200d6f4 <rtems_bdbuf_wake>
200f5ec: 90 02 20 64 add %o0, 0x64, %o0
200f5f0: 30 bf ff e7 b,a 200f58c <rtems_bdbuf_release+0x78>
0200f5f4 <rtems_bdbuf_release_modified>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
200f5f4: 9d e3 bf a0 save %sp, -96, %sp
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
200f5f8: 80 a6 20 00 cmp %i0, 0
200f5fc: 02 80 00 13 be 200f648 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
200f600: 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();
200f604: 7f ff f7 85 call 200d418 <rtems_bdbuf_lock_cache>
200f608: 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)
200f60c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200f610: 80 a2 20 03 cmp %o0, 3
200f614: 1a 80 00 04 bcc 200f624 <rtems_bdbuf_release_modified+0x30><== ALWAYS TAKEN
200f618: 80 a2 20 05 cmp %o0, 5
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
200f61c: 7f ff f7 85 call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200f620: 92 10 20 12 mov 0x12, %o1 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200f624: 18 80 00 0b bgu 200f650 <rtems_bdbuf_release_modified+0x5c>
200f628: 80 a2 20 06 cmp %o0, 6
{
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);
200f62c: 90 10 00 18 mov %i0, %o0
200f630: 7f ff f8 40 call 200d730 <rtems_bdbuf_add_to_modified_list_after_access>
200f634: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200f638: 7f ff f7 8e call 200d470 <rtems_bdbuf_unlock_cache>
200f63c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
200f640: 81 c7 e0 08 ret
200f644: 81 e8 00 00 restore
}
200f648: 81 c7 e0 08 ret <== NOT EXECUTED
200f64c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200f650: 12 bf ff f3 bne 200f61c <rtems_bdbuf_release_modified+0x28><== NEVER TAKEN
200f654: 01 00 00 00 nop
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
200f658: 90 10 00 18 mov %i0, %o0
200f65c: 7f ff f9 96 call 200dcb4 <rtems_bdbuf_discard_buffer_after_access>
200f660: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200f664: 7f ff f7 83 call 200d470 <rtems_bdbuf_unlock_cache>
200f668: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
200f66c: 81 c7 e0 08 ret
200f670: 81 e8 00 00 restore
0200d894 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
200d894: 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;
200d898: 35 00 80 89 sethi %hi(0x2022400), %i2
200d89c: b4 16 a3 0c or %i2, 0x30c, %i2 ! 202270c <bdbuf_cache>
200d8a0: fa 06 a0 3c ld [ %i2 + 0x3c ], %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));
200d8a4: b6 07 bf 80 add %fp, -128, %i3
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
200d8a8: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
200d8ac: e0 06 20 18 ld [ %i0 + 0x18 ], %l0
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));
200d8b0: 90 10 00 1b mov %i3, %o0
200d8b4: 92 10 20 00 clr %o1
200d8b8: 40 00 1f 14 call 2015508 <memset>
200d8bc: 94 10 20 80 mov 0x80, %o2
while (p != NULL)
200d8c0: 80 a7 60 00 cmp %i5, 0
200d8c4: 02 80 00 11 be 200d908 <rtems_bdbuf_remove_from_tree+0x74><== NEVER TAKEN
200d8c8: 84 10 00 1b mov %i3, %g2
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
200d8cc: 88 10 20 01 mov 1, %g4
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200d8d0: b2 10 3f ff mov -1, %i1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d8d4: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200d8d8: fa 20 80 00 st %i5, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d8dc: 80 a0 c0 1c cmp %g3, %i4
200d8e0: 0a 80 00 65 bcs 200da74 <rtems_bdbuf_remove_from_tree+0x1e0><== NEVER TAKEN
200d8e4: 82 00 a0 04 add %g2, 4, %g1
|| ((p->dd == dd) && (p->block < block)))
200d8e8: 80 a7 00 03 cmp %i4, %g3
200d8ec: 22 80 00 0a be,a 200d914 <rtems_bdbuf_remove_from_tree+0x80><== ALWAYS TAKEN
200d8f0: c6 07 60 18 ld [ %i5 + 0x18 ], %g3
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200d8f4: f2 2f 60 10 stb %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
p = p->avl.left;
200d8f8: fa 07 60 08 ld [ %i5 + 8 ], %i5
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
200d8fc: 80 a7 60 00 cmp %i5, 0
200d900: 12 bf ff f5 bne 200d8d4 <rtems_bdbuf_remove_from_tree+0x40><== ALWAYS TAKEN
200d904: 84 10 00 01 mov %g1, %g2
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
200d908: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
200d90c: 7f ff fe c9 call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200d910: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
200d914: 80 a4 00 03 cmp %l0, %g3
200d918: 38 80 00 58 bgu,a 200da78 <rtems_bdbuf_remove_from_tree+0x1e4>
200d91c: c8 2f 60 10 stb %g4, [ %i5 + 0x10 ]
{
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
200d920: 80 a4 00 03 cmp %l0, %g3
200d924: 32 bf ff f5 bne,a 200d8f8 <rtems_bdbuf_remove_from_tree+0x64>
200d928: f2 2f 60 10 stb %i1, [ %i5 + 0x10 ]
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200d92c: 9a 10 00 01 mov %g1, %o5
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
200d930: 80 a0 80 1b cmp %g2, %i3
200d934: 18 80 00 6a bgu 200dadc <rtems_bdbuf_remove_from_tree+0x248>
200d938: b0 10 20 00 clr %i0
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
200d93c: f2 07 60 0c ld [ %i5 + 0xc ], %i1
200d940: 80 a6 60 00 cmp %i1, 0
200d944: 22 80 00 6b be,a 200daf0 <rtems_bdbuf_remove_from_tree+0x25c>
200d948: c6 07 60 08 ld [ %i5 + 8 ], %g3
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
200d94c: c6 06 60 08 ld [ %i1 + 8 ], %g3
200d950: 84 10 00 19 mov %i1, %g2
200d954: 80 a0 e0 00 cmp %g3, 0
200d958: 12 80 00 06 bne 200d970 <rtems_bdbuf_remove_from_tree+0xdc>
200d95c: b8 10 3f ff mov -1, %i4
{
r->avl.left = q->avl.left;
200d960: 10 80 00 ba b 200dc48 <rtems_bdbuf_remove_from_tree+0x3b4>
200d964: c6 07 60 08 ld [ %i5 + 8 ], %g3
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
200d968: 84 10 00 03 mov %g3, %g2
200d96c: 86 10 00 04 mov %g4, %g3
200d970: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
*buf_prev++ = r = s;
200d974: c4 20 40 00 st %g2, [ %g1 ]
s = r->avl.left;
r->avl.cache = -1;
200d978: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
200d97c: 80 a1 20 00 cmp %g4, 0
200d980: 12 bf ff fa bne 200d968 <rtems_bdbuf_remove_from_tree+0xd4>
200d984: 82 00 60 04 add %g1, 4, %g1
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
200d988: de 07 60 08 ld [ %i5 + 8 ], %o7
r->avl.left = s->avl.right;
200d98c: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
200d990: c8 0f 60 11 ldub [ %i5 + 0x11 ], %g4
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
200d994: de 20 e0 08 st %o7, [ %g3 + 8 ]
r->avl.left = s->avl.right;
200d998: f8 20 a0 08 st %i4, [ %g2 + 8 ]
s->avl.right = q->avl.right;
200d99c: f2 20 e0 0c st %i1, [ %g3 + 0xc ]
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
200d9a0: 84 10 20 01 mov 1, %g2
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
200d9a4: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
s->avl.cache = 1;
200d9a8: c4 28 e0 10 stb %g2, [ %g3 + 0x10 ]
*t = q = s;
200d9ac: c6 23 7f fc st %g3, [ %o5 + -4 ]
}
}
if (p != NULL)
200d9b0: 80 a6 20 00 cmp %i0, 0
200d9b4: 22 80 00 07 be,a 200d9d0 <rtems_bdbuf_remove_from_tree+0x13c>
200d9b8: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
if (p->avl.cache == -1)
200d9bc: c4 4e 20 10 ldsb [ %i0 + 0x10 ], %g2
200d9c0: 80 a0 bf ff cmp %g2, -1
200d9c4: 22 80 00 03 be,a 200d9d0 <rtems_bdbuf_remove_from_tree+0x13c>
200d9c8: c6 26 20 08 st %g3, [ %i0 + 8 ]
{
p->avl.left = q;
}
else
{
p->avl.right = q;
200d9cc: c6 26 20 0c st %g3, [ %i0 + 0xc ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
200d9d0: 80 a0 40 1b cmp %g1, %i3
200d9d4: 08 80 00 26 bleu 200da6c <rtems_bdbuf_remove_from_tree+0x1d8>
200d9d8: b2 10 3f ff mov -1, %i1
200d9dc: c4 00 7f fc ld [ %g1 + -4 ], %g2
200d9e0: c8 08 a0 10 ldub [ %g2 + 0x10 ], %g4
200d9e4: 10 80 00 10 b 200da24 <rtems_bdbuf_remove_from_tree+0x190>
200d9e8: 89 29 20 18 sll %g4, 0x18, %g4
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
200d9ec: 86 10 00 02 mov %g2, %g3
modified = false;
200d9f0: ba 10 20 00 clr %i5
default:
break;
}
}
if (buf_prev > buf_stack)
200d9f4: 80 a0 40 1b cmp %g1, %i3
200d9f8: 28 80 00 1d bleu,a 200da6c <rtems_bdbuf_remove_from_tree+0x1d8>
200d9fc: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
q = *(buf_prev - 1);
200da00: c4 00 7f fc ld [ %g1 + -4 ], %g2
if (q->avl.cache == -1)
200da04: c8 08 a0 10 ldub [ %g2 + 0x10 ], %g4
200da08: 89 29 20 18 sll %g4, 0x18, %g4
200da0c: b9 39 20 18 sra %g4, 0x18, %i4
200da10: 80 a7 3f ff cmp %i4, -1
200da14: 02 80 00 47 be 200db30 <rtems_bdbuf_remove_from_tree+0x29c>
200da18: 80 8f 60 ff btst 0xff, %i5
*root = q;
}
modified = true;
while (modified)
200da1c: 02 80 00 14 be 200da6c <rtems_bdbuf_remove_from_tree+0x1d8>
200da20: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
else
{
break;
}
if (p->avl.cache == -1)
200da24: 89 39 20 18 sra %g4, 0x18, %g4
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
200da28: 82 00 7f fc add %g1, -4, %g1
else
{
break;
}
if (p->avl.cache == -1)
200da2c: 80 a1 3f ff cmp %g4, -1
200da30: 02 80 00 38 be 200db10 <rtems_bdbuf_remove_from_tree+0x27c>
200da34: c6 48 a0 11 ldsb [ %g2 + 0x11 ], %g3
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200da38: 80 a0 e0 00 cmp %g3, 0
200da3c: 22 bf ff ec be,a 200d9ec <rtems_bdbuf_remove_from_tree+0x158>
200da40: f2 28 a0 11 stb %i1, [ %g2 + 0x11 ]
200da44: 80 a0 e0 01 cmp %g3, 1
200da48: 02 80 00 42 be 200db50 <rtems_bdbuf_remove_from_tree+0x2bc>
200da4c: 80 a0 ff ff cmp %g3, -1
200da50: 22 80 00 0c be,a 200da80 <rtems_bdbuf_remove_from_tree+0x1ec><== ALWAYS TAKEN
200da54: c8 00 a0 08 ld [ %g2 + 8 ], %g4
200da58: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
default:
break;
}
}
if (buf_prev > buf_stack)
200da5c: 80 a0 40 1b cmp %g1, %i3 <== NOT EXECUTED
200da60: 18 bf ff e8 bgu 200da00 <rtems_bdbuf_remove_from_tree+0x16c><== NOT EXECUTED
200da64: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
q->avl.right = p;
}
}
else
{
*root = p;
200da68: c6 26 a0 3c st %g3, [ %i2 + 0x3c ] <== NOT EXECUTED
200da6c: 81 c7 e0 08 ret
200da70: 81 e8 00 00 restore
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
200da74: c8 2f 60 10 stb %g4, [ %i5 + 0x10 ] <== NOT EXECUTED
p = p->avl.right;
200da78: 10 bf ff a1 b 200d8fc <rtems_bdbuf_remove_from_tree+0x68>
200da7c: fa 07 60 0c ld [ %i5 + 0xc ], %i5
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
200da80: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
200da84: 80 a0 e0 00 cmp %g3, 0
200da88: 24 80 00 41 ble,a 200db8c <rtems_bdbuf_remove_from_tree+0x2f8>
200da8c: fa 01 20 0c ld [ %g4 + 0xc ], %i5
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
200da90: c6 01 20 0c ld [ %g4 + 0xc ], %g3
p1->avl.right = p2->avl.left;
200da94: f8 00 e0 08 ld [ %g3 + 8 ], %i4
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
200da98: fa 48 e0 11 ldsb [ %g3 + 0x11 ], %i5
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200da9c: f8 21 20 0c st %i4, [ %g4 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200daa0: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
200daa4: c8 20 e0 08 st %g4, [ %g3 + 8 ]
p->avl.left = p2->avl.right;
200daa8: f8 20 a0 08 st %i4, [ %g2 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
200daac: 80 a7 7f ff cmp %i5, -1
200dab0: 02 80 00 40 be 200dbb0 <rtems_bdbuf_remove_from_tree+0x31c>
200dab4: c4 20 e0 0c st %g2, [ %g3 + 0xc ]
200dab8: c0 28 a0 11 clrb [ %g2 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200dabc: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
200dac0: 80 a0 a0 01 cmp %g2, 1
200dac4: 22 80 00 42 be,a 200dbcc <rtems_bdbuf_remove_from_tree+0x338>
200dac8: f2 29 20 11 stb %i1, [ %g4 + 0x11 ]
200dacc: c0 29 20 11 clrb [ %g4 + 0x11 ]
p = p2;
p2->avl.bal = 0;
200dad0: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200dad4: 10 bf ff c8 b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200dad8: ba 10 20 01 mov 1, %i5
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
200dadc: f2 07 60 0c ld [ %i5 + 0xc ], %i1
200dae0: 80 a6 60 00 cmp %i1, 0
200dae4: 12 bf ff 9a bne 200d94c <rtems_bdbuf_remove_from_tree+0xb8>
200dae8: f0 00 7f f8 ld [ %g1 + -8 ], %i0
{
r = q->avl.left;
200daec: c6 07 60 08 ld [ %i5 + 8 ], %g3
if (r != NULL)
200daf0: 80 a0 e0 00 cmp %g3, 0
200daf4: 02 80 00 61 be 200dc78 <rtems_bdbuf_remove_from_tree+0x3e4>
200daf8: 80 a6 20 00 cmp %i0, 0
{
r->avl.bal = 0;
200dafc: c0 28 e0 11 clrb [ %g3 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
200db00: 12 bf ff af bne 200d9bc <rtems_bdbuf_remove_from_tree+0x128>
200db04: 82 10 00 02 mov %g2, %g1
p->avl.right = q;
}
}
else
{
*root = q;
200db08: 10 bf ff b2 b 200d9d0 <rtems_bdbuf_remove_from_tree+0x13c>
200db0c: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
200db10: 80 a0 e0 00 cmp %g3, 0
200db14: 12 80 00 0b bne 200db40 <rtems_bdbuf_remove_from_tree+0x2ac>
200db18: 80 a0 e0 01 cmp %g3, 1
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
200db1c: 88 10 20 01 mov 1, %g4
200db20: 86 10 00 02 mov %g2, %g3
200db24: c8 28 a0 11 stb %g4, [ %g2 + 0x11 ]
modified = false;
200db28: 10 bf ff b3 b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200db2c: ba 10 20 00 clr %i5
*root = q;
}
modified = true;
while (modified)
200db30: 12 bf ff bd bne 200da24 <rtems_bdbuf_remove_from_tree+0x190>
200db34: c6 20 a0 08 st %g3, [ %g2 + 8 ]
200db38: 81 c7 e0 08 ret
200db3c: 81 e8 00 00 restore
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
200db40: 02 80 00 08 be 200db60 <rtems_bdbuf_remove_from_tree+0x2cc>
200db44: 80 a0 ff ff cmp %g3, -1
200db48: 32 bf ff c5 bne,a 200da5c <rtems_bdbuf_remove_from_tree+0x1c8><== NEVER TAKEN
200db4c: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200db50: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200db54: 86 10 00 02 mov %g2, %g3
200db58: 10 bf ff a7 b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200db5c: ba 10 20 01 mov 1, %i5
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
200db60: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
if (p1->avl.bal >= 0) /* simple RR-turn */
200db64: fa 48 e0 11 ldsb [ %g3 + 0x11 ], %i5
200db68: 80 a7 60 00 cmp %i5, 0
200db6c: 26 80 00 24 bl,a 200dbfc <rtems_bdbuf_remove_from_tree+0x368>
200db70: fa 00 e0 08 ld [ %g3 + 8 ], %i5
{
p->avl.right = p1->avl.left;
200db74: f8 00 e0 08 ld [ %g3 + 8 ], %i4
p1->avl.left = p;
200db78: c4 20 e0 08 st %g2, [ %g3 + 8 ]
if (p1->avl.bal == 0)
200db7c: 12 80 00 17 bne 200dbd8 <rtems_bdbuf_remove_from_tree+0x344>
200db80: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
{
p1->avl.bal = -1;
200db84: 10 bf ff 9c b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200db88: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
200db8c: c4 21 20 0c st %g2, [ %g4 + 0xc ]
if (p1->avl.bal == 0)
200db90: 80 a0 e0 00 cmp %g3, 0
200db94: 12 80 00 15 bne 200dbe8 <rtems_bdbuf_remove_from_tree+0x354>
200db98: fa 20 a0 08 st %i5, [ %g2 + 8 ]
{
p1->avl.bal = 1;
200db9c: 84 10 20 01 mov 1, %g2
200dba0: 86 10 00 04 mov %g4, %g3
200dba4: c4 29 20 11 stb %g2, [ %g4 + 0x11 ]
modified = false;
200dba8: 10 bf ff 93 b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200dbac: ba 10 20 00 clr %i5
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
200dbb0: ba 10 20 01 mov 1, %i5
200dbb4: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200dbb8: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
200dbbc: 80 a0 a0 01 cmp %g2, 1
200dbc0: 32 bf ff c4 bne,a 200dad0 <rtems_bdbuf_remove_from_tree+0x23c><== ALWAYS TAKEN
200dbc4: c0 29 20 11 clrb [ %g4 + 0x11 ]
200dbc8: f2 29 20 11 stb %i1, [ %g4 + 0x11 ] <== NOT EXECUTED
p = p2;
p2->avl.bal = 0;
200dbcc: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200dbd0: 10 bf ff 89 b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200dbd4: ba 10 20 01 mov 1, %i5
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
200dbd8: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p1->avl.bal = 0;
200dbdc: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200dbe0: 10 bf ff 85 b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200dbe4: ba 10 20 01 mov 1, %i5
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
200dbe8: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p1->avl.bal = 0;
200dbec: c0 29 20 11 clrb [ %g4 + 0x11 ]
200dbf0: 86 10 00 04 mov %g4, %g3
200dbf4: 10 bf ff 80 b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200dbf8: ba 10 20 01 mov 1, %i5
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200dbfc: f0 07 60 0c ld [ %i5 + 0xc ], %i0
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200dc00: f8 4f 60 11 ldsb [ %i5 + 0x11 ], %i4
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200dc04: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200dc08: f0 07 60 08 ld [ %i5 + 8 ], %i0
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
200dc0c: c6 27 60 0c st %g3, [ %i5 + 0xc ]
p->avl.right = p2->avl.left;
200dc10: f0 20 a0 0c st %i0, [ %g2 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200dc14: 80 a7 20 01 cmp %i4, 1
200dc18: 02 80 00 16 be 200dc70 <rtems_bdbuf_remove_from_tree+0x3dc>
200dc1c: c4 27 60 08 st %g2, [ %i5 + 8 ]
200dc20: c0 28 a0 11 clrb [ %g2 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
200dc24: c4 4f 60 11 ldsb [ %i5 + 0x11 ], %g2
200dc28: 80 a0 bf ff cmp %g2, -1
200dc2c: 02 80 00 0f be 200dc68 <rtems_bdbuf_remove_from_tree+0x3d4><== NEVER TAKEN
200dc30: 84 10 20 01 mov 1, %g2
200dc34: c0 28 e0 11 clrb [ %g3 + 0x11 ]
p = p2;
p2->avl.bal = 0;
200dc38: c0 2f 60 11 clrb [ %i5 + 0x11 ]
200dc3c: 86 10 00 1d mov %i5, %g3
200dc40: 10 bf ff 6d b 200d9f4 <rtems_bdbuf_remove_from_tree+0x160>
200dc44: ba 10 20 01 mov 1, %i5
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
200dc48: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200dc4c: c6 26 60 08 st %g3, [ %i1 + 8 ]
r->avl.bal = q->avl.bal;
200dc50: c4 2e 60 11 stb %g2, [ %i1 + 0x11 ]
r->avl.cache = 1;
*buf_prev++ = q = r;
200dc54: f2 20 7f fc st %i1, [ %g1 + -4 ]
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
200dc58: 84 10 20 01 mov 1, %g2
*buf_prev++ = q = r;
200dc5c: 86 10 00 19 mov %i1, %g3
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
200dc60: 10 bf ff 54 b 200d9b0 <rtems_bdbuf_remove_from_tree+0x11c>
200dc64: c4 2e 60 10 stb %g2, [ %i1 + 0x10 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
200dc68: 10 bf ff f4 b 200dc38 <rtems_bdbuf_remove_from_tree+0x3a4><== NOT EXECUTED
200dc6c: c4 28 e0 11 stb %g2, [ %g3 + 0x11 ] <== NOT EXECUTED
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200dc70: 10 bf ff ed b 200dc24 <rtems_bdbuf_remove_from_tree+0x390>
200dc74: c8 28 a0 11 stb %g4, [ %g2 + 0x11 ]
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
{
r = q->avl.left;
if (r != NULL)
200dc78: 10 bf ff 4e b 200d9b0 <rtems_bdbuf_remove_from_tree+0x11c>
200dc7c: 82 10 00 02 mov %g2, %g1
0200dd0c <rtems_bdbuf_remove_from_tree_and_lru_list>:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
200dd0c: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
200dd10: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200dd14: 80 a2 20 00 cmp %o0, 0
200dd18: 22 80 00 0a be,a 200dd40 <rtems_bdbuf_remove_from_tree_and_lru_list+0x34>
200dd1c: c4 06 00 00 ld [ %i0 ], %g2
200dd20: 80 a2 20 02 cmp %o0, 2
200dd24: 02 80 00 04 be 200dd34 <rtems_bdbuf_remove_from_tree_and_lru_list+0x28><== ALWAYS TAKEN
200dd28: 01 00 00 00 nop
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
200dd2c: 7f ff fd c1 call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200dd30: 92 10 20 16 mov 0x16, %o1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
200dd34: 7f ff fe d8 call 200d894 <rtems_bdbuf_remove_from_tree>
200dd38: 90 10 00 18 mov %i0, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200dd3c: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
200dd40: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
200dd44: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200dd48: c4 20 40 00 st %g2, [ %g1 ]
200dd4c: 81 c7 e0 08 ret
200dd50: 81 e8 00 00 restore
0200d4f4 <rtems_bdbuf_restore_preemption>:
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200d4f4: 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);
200d4f8: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200d4fc: 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);
200d500: 90 10 00 18 mov %i0, %o0
200d504: 94 07 a0 44 add %fp, 0x44, %o2
200d508: 40 00 12 74 call 2011ed8 <rtems_task_mode>
200d50c: 92 12 63 ff or %o1, 0x3ff, %o1
if (sc != RTEMS_SUCCESSFUL)
200d510: 80 a2 20 00 cmp %o0, 0
200d514: 12 80 00 04 bne 200d524 <rtems_bdbuf_restore_preemption+0x30><== NEVER TAKEN
200d518: 01 00 00 00 nop
200d51c: 81 c7 e0 08 ret
200d520: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
200d524: 7f ff ff ab call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d528: 90 10 20 06 mov 6, %o0 <== NOT EXECUTED
0200fa10 <rtems_bdbuf_set_block_size>:
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
200fa10: 9d e3 bf a0 save %sp, -96, %sp
/*
* We do not care about the synchronization status since we will purge the
* device later.
*/
if (sync)
200fa14: 80 a6 a0 00 cmp %i2, 0
200fa18: 12 80 00 43 bne 200fb24 <rtems_bdbuf_set_block_size+0x114>
200fa1c: 01 00 00 00 nop
rtems_bdbuf_syncdev (dd);
rtems_bdbuf_lock_cache ();
200fa20: 7f ff f6 7e call 200d418 <rtems_bdbuf_lock_cache>
200fa24: b8 10 20 0a mov 0xa, %i4 ! a <PROM_START+0xa>
if (block_size > 0)
200fa28: 80 a6 60 00 cmp %i1, 0
200fa2c: 12 80 00 06 bne 200fa44 <rtems_bdbuf_set_block_size+0x34>
200fa30: 03 00 80 7f sethi %hi(0x201fc00), %g1
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
200fa34: 7f ff f6 8f call 200d470 <rtems_bdbuf_unlock_cache>
200fa38: b0 10 00 1c mov %i4, %i0
return sc;
}
200fa3c: 81 c7 e0 08 ret
200fa40: 81 e8 00 00 restore
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
200fa44: 82 10 60 b8 or %g1, 0xb8, %g1
200fa48: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
200fa4c: 80 a6 40 02 cmp %i1, %g2
200fa50: 18 bf ff f9 bgu 200fa34 <rtems_bdbuf_set_block_size+0x24> <== NEVER TAKEN
200fa54: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
200fa58: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
200fa5c: 40 00 37 60 call 201d7dc <.udiv>
200fa60: 90 06 7f ff add %i1, -1, %o0
200fa64: 90 02 20 01 inc %o0
for (bds_per_size = 1;
200fa68: 80 a2 20 01 cmp %o0, 1
200fa6c: 08 80 00 06 bleu 200fa84 <rtems_bdbuf_set_block_size+0x74>
200fa70: 92 10 20 01 mov 1, %o1
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
200fa74: 93 2a 60 01 sll %o1, 1, %o1
if (size > bdbuf_config.buffer_max)
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
for (bds_per_size = 1;
200fa78: 80 a2 00 09 cmp %o0, %o1
200fa7c: 38 bf ff ff bgu,a 200fa78 <rtems_bdbuf_set_block_size+0x68>
200fa80: 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;
200fa84: 03 00 80 89 sethi %hi(0x2022400), %g1
200fa88: d0 00 63 2c ld [ %g1 + 0x32c ], %o0 ! 202272c <bdbuf_cache+0x20>
200fa8c: 40 00 37 54 call 201d7dc <.udiv>
200fa90: b8 10 20 0a mov 0xa, %i4
if (block_size > 0)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
200fa94: 80 a2 20 00 cmp %o0, 0
200fa98: 02 bf ff e7 be 200fa34 <rtems_bdbuf_set_block_size+0x24> <== NEVER TAKEN
200fa9c: b4 10 00 08 mov %o0, %i2
{
int block_to_media_block_shift = 0;
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
200faa0: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
200faa4: 90 10 00 19 mov %i1, %o0
200faa8: 92 10 00 1c mov %i4, %o1
200faac: 40 00 37 4c call 201d7dc <.udiv>
200fab0: ba 10 20 00 clr %i5
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
200fab4: 80 a2 20 01 cmp %o0, 1
200fab8: 08 80 00 08 bleu 200fad8 <rtems_bdbuf_set_block_size+0xc8>
200fabc: b6 10 00 08 mov %o0, %i3
200fac0: 84 10 20 01 mov 1, %g2
{
++block_to_media_block_shift;
200fac4: ba 07 60 01 inc %i5
{
int block_to_media_block_shift = 0;
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
200fac8: 83 28 80 1d sll %g2, %i5, %g1
200facc: 80 a6 c0 01 cmp %i3, %g1
200fad0: 38 bf ff fe bgu,a 200fac8 <rtems_bdbuf_set_block_size+0xb8>
200fad4: ba 07 60 01 inc %i5
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
200fad8: b9 2f 00 1d sll %i4, %i5, %i4
200fadc: 80 a7 00 19 cmp %i4, %i1
200fae0: 32 80 00 02 bne,a 200fae8 <rtems_bdbuf_set_block_size+0xd8><== NEVER TAKEN
200fae4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
200fae8: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
200faec: 92 10 00 1b mov %i3, %o1
200faf0: 40 00 37 3b call 201d7dc <.udiv>
200faf4: f2 26 20 24 st %i1, [ %i0 + 0x24 ]
200faf8: d0 26 20 28 st %o0, [ %i0 + 0x28 ]
dd->media_blocks_per_block = media_blocks_per_block;
dd->block_to_media_block_shift = block_to_media_block_shift;
dd->bds_per_group = bds_per_group;
rtems_bdbuf_purge_dev (dd);
200fafc: 90 10 00 18 mov %i0, %o0
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
dd->media_blocks_per_block = media_blocks_per_block;
200fb00: f6 26 20 2c st %i3, [ %i0 + 0x2c ]
dd->block_to_media_block_shift = block_to_media_block_shift;
200fb04: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
dd->bds_per_group = bds_per_group;
200fb08: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
rtems_bdbuf_purge_dev (dd);
200fb0c: 7f ff ff 43 call 200f818 <rtems_bdbuf_purge_dev>
200fb10: b8 10 20 00 clr %i4
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
200fb14: 7f ff f6 57 call 200d470 <rtems_bdbuf_unlock_cache>
200fb18: b0 10 00 1c mov %i4, %i0
return sc;
}
200fb1c: 81 c7 e0 08 ret
200fb20: 81 e8 00 00 restore
/*
* We do not care about the synchronization status since we will purge the
* device later.
*/
if (sync)
rtems_bdbuf_syncdev (dd);
200fb24: 7f ff ff 26 call 200f7bc <rtems_bdbuf_syncdev>
200fb28: 90 10 00 18 mov %i0, %o0
200fb2c: 30 bf ff bd b,a 200fa20 <rtems_bdbuf_set_block_size+0x10>
0200d24c <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
200d24c: 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;
200d250: c2 06 40 00 ld [ %i1 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200d254: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
200d258: 80 a0 40 19 cmp %g1, %i1
200d25c: 02 80 00 2e be 200d314 <rtems_bdbuf_swapout_modified_processing+0xc8>
200d260: 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))
200d264: 12 80 00 57 bne 200d3c0 <rtems_bdbuf_swapout_modified_processing+0x174>
200d268: 9e 10 20 00 clr %o7
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
200d26c: 05 00 80 89 sethi %hi(0x2022400), %g2
200d270: d8 00 a3 80 ld [ %g2 + 0x380 ], %o4 ! 2022780 <bdbuf_cache+0x74>
200d274: 9e 0b e0 ff and %o7, 0xff, %o7
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d278: 96 10 20 09 mov 9, %o3
* 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))
200d27c: 80 a3 e0 00 cmp %o7, 0
200d280: 32 80 00 3b bne,a 200d36c <rtems_bdbuf_swapout_modified_processing+0x120>
200d284: c4 06 00 00 ld [ %i0 ], %g2
200d288: 80 a6 e0 00 cmp %i3, 0
200d28c: 02 80 00 07 be 200d2a8 <rtems_bdbuf_swapout_modified_processing+0x5c>
200d290: 80 a3 20 00 cmp %o4, 0
200d294: c4 06 00 00 ld [ %i0 ], %g2
200d298: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
200d29c: 80 a0 80 03 cmp %g2, %g3
200d2a0: 02 80 00 34 be 200d370 <rtems_bdbuf_swapout_modified_processing+0x124>
200d2a4: 80 a3 20 00 cmp %o4, 0
|| rtems_bdbuf_has_buffer_waiters ())
200d2a8: 32 80 00 31 bne,a 200d36c <rtems_bdbuf_swapout_modified_processing+0x120>
200d2ac: c4 06 00 00 ld [ %i0 ], %g2
bd->hold_timer = 0;
if (bd->hold_timer)
200d2b0: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
200d2b4: 80 a0 a0 00 cmp %g2, 0
200d2b8: 02 80 00 0b be 200d2e4 <rtems_bdbuf_swapout_modified_processing+0x98><== NEVER TAKEN
200d2bc: 80 a7 20 00 cmp %i4, 0
{
if (update_timers)
200d2c0: 22 80 00 12 be,a 200d308 <rtems_bdbuf_swapout_modified_processing+0xbc>
200d2c4: c2 00 40 00 ld [ %g1 ], %g1
{
if (bd->hold_timer > timer_delta)
200d2c8: 80 a0 80 1d cmp %g2, %i5
200d2cc: 28 80 00 3a bleu,a 200d3b4 <rtems_bdbuf_swapout_modified_processing+0x168>
200d2d0: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
200d2d4: 84 20 80 1d sub %g2, %i5, %g2
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
200d2d8: 80 a0 a0 00 cmp %g2, 0
200d2dc: 12 80 00 0a bne 200d304 <rtems_bdbuf_swapout_modified_processing+0xb8><== ALWAYS TAKEN
200d2e0: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
200d2e4: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
200d2e8: c6 00 60 14 ld [ %g1 + 0x14 ], %g3 <== NOT EXECUTED
/*
* 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)
200d2ec: 80 a0 a0 00 cmp %g2, 0
200d2f0: 22 80 00 24 be,a 200d380 <rtems_bdbuf_swapout_modified_processing+0x134>
200d2f4: 84 10 00 03 mov %g3, %g2
*dd_ptr = bd->dd;
if (bd->dd == *dd_ptr)
200d2f8: 80 a0 c0 02 cmp %g3, %g2
200d2fc: 22 80 00 08 be,a 200d31c <rtems_bdbuf_swapout_modified_processing+0xd0><== ALWAYS TAKEN
200d300: c4 00 60 04 ld [ %g1 + 4 ], %g2
node = next_node;
}
else
{
node = node->next;
200d304: c2 00 40 00 ld [ %g1 ], %g1
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
200d308: 80 a0 40 19 cmp %g1, %i1
200d30c: 12 bf ff dd bne 200d280 <rtems_bdbuf_swapout_modified_processing+0x34>
200d310: 80 a3 e0 00 cmp %o7, 0
200d314: 81 c7 e0 08 ret
200d318: 81 e8 00 00 restore
if (*dd_ptr == BDBUF_INVALID_DEV)
*dd_ptr = bd->dd;
if (bd->dd == *dd_ptr)
{
rtems_chain_node* next_node = node->next;
200d31c: da 00 40 00 ld [ %g1 ], %o5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d320: d6 20 60 20 st %o3, [ %g1 + 0x20 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
200d324: c4 23 60 04 st %g2, [ %o5 + 4 ]
previous->next = next;
200d328: da 20 80 00 st %o5, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
200d32c: c4 06 a0 08 ld [ %i2 + 8 ], %g2
while (node && !rtems_chain_is_head (transfer, tnode))
200d330: 80 a0 80 1a cmp %g2, %i2
200d334: 22 80 00 1a be,a 200d39c <rtems_bdbuf_swapout_modified_processing+0x150>
200d338: c4 06 80 00 ld [ %i2 ], %g2
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
200d33c: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
200d340: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
200d344: 80 a1 00 03 cmp %g4, %g3
200d348: 28 80 00 11 bleu,a 200d38c <rtems_bdbuf_swapout_modified_processing+0x140>
200d34c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200d350: c6 00 80 00 ld [ %g2 ], %g3
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200d354: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200d358: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
200d35c: c6 20 40 00 st %g3, [ %g1 ]
before_node->previous = the_node;
200d360: c2 20 e0 04 st %g1, [ %g3 + 4 ]
200d364: 10 bf ff e9 b 200d308 <rtems_bdbuf_swapout_modified_processing+0xbc>
200d368: 82 10 00 0d mov %o5, %g1
200d36c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
/*
* 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)
200d370: 80 a0 a0 00 cmp %g2, 0
200d374: 12 bf ff e1 bne 200d2f8 <rtems_bdbuf_swapout_modified_processing+0xac>
200d378: c0 20 60 2c clr [ %g1 + 0x2c ]
*dd_ptr = bd->dd;
200d37c: 84 10 00 03 mov %g3, %g2
200d380: c6 26 00 00 st %g3, [ %i0 ]
200d384: 10 bf ff dd b 200d2f8 <rtems_bdbuf_swapout_modified_processing+0xac>
200d388: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
200d38c: 80 a0 80 1a cmp %g2, %i2
200d390: 32 bf ff ec bne,a 200d340 <rtems_bdbuf_swapout_modified_processing+0xf4>
200d394: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200d398: c4 06 80 00 ld [ %i2 ], %g2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200d39c: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200d3a0: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
200d3a4: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
200d3a8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
200d3ac: 10 bf ff d7 b 200d308 <rtems_bdbuf_swapout_modified_processing+0xbc>
200d3b0: 82 10 00 0d mov %o5, %g1
200d3b4: c4 06 00 00 ld [ %i0 ], %g2
200d3b8: 10 bf ff cd b 200d2ec <rtems_bdbuf_swapout_modified_processing+0xa0>
200d3bc: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
200d3c0: c4 06 00 00 ld [ %i0 ], %g2
200d3c4: 80 a0 00 02 cmp %g0, %g2
200d3c8: 10 bf ff a9 b 200d26c <rtems_bdbuf_swapout_modified_processing+0x20>
200d3cc: 9e 60 3f ff subx %g0, -1, %o7
0200e768 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
200e768: 9d e3 bf 78 save %sp, -136, %sp
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
200e76c: 23 00 80 7f sethi %hi(0x201fc00), %l1
200e770: a2 14 60 b8 or %l1, 0xb8, %l1 ! 201fcb8 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200e774: 7f ff fb b2 call 200d63c <rtems_bdbuf_swapout_writereq_alloc>
200e778: f6 04 60 0c ld [ %l1 + 0xc ], %i3
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200e77c: 03 00 80 7f sethi %hi(0x201fc00), %g1
200e780: d2 00 60 7c ld [ %g1 + 0x7c ], %o1 ! 201fc7c <Configuration+0xc>
200e784: 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 ();
200e788: d0 27 bf fc st %o0, [ %fp + -4 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e78c: b4 07 bf e8 add %fp, -24, %i2
200e790: b0 07 bf ec add %fp, -20, %i0
head->previous = NULL;
200e794: c0 27 bf ec clr [ %fp + -20 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e798: f0 27 bf e8 st %i0, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
200e79c: f4 27 bf f0 st %i2, [ %fp + -16 ]
rtems_chain_initialize_empty (&transfer.bds);
transfer.dd = BDBUF_INVALID_DEV;
200e7a0: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
200e7a4: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200e7a8: 91 2e e0 07 sll %i3, 7, %o0
200e7ac: 90 22 00 01 sub %o0, %g1, %o0
200e7b0: 90 02 00 1b add %o0, %i3, %o0
200e7b4: 40 00 3c 0a call 201d7dc <.udiv>
200e7b8: 91 2a 20 03 sll %o0, 3, %o0
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
200e7bc: 7f ff fb 17 call 200d418 <rtems_bdbuf_lock_cache>
200e7c0: ac 10 00 08 mov %o0, %l6
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200e7c4: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
200e7c8: b2 10 20 61 mov 0x61, %i1
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200e7cc: 80 a0 60 00 cmp %g1, 0
200e7d0: 02 80 00 c3 be 200eadc <rtems_bdbuf_swapout_task+0x374> <== ALWAYS TAKEN
200e7d4: a4 00 60 61 add %g1, 0x61, %l2
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e7d8: 21 00 80 89 sethi %hi(0x2022400), %l0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200e7dc: 29 10 91 1b sethi %hi(0x42446c00), %l4 <== NOT EXECUTED
200e7e0: a0 14 23 0c or %l0, 0x30c, %l0 <== NOT EXECUTED
200e7e4: 27 00 80 3a sethi %hi(0x200e800), %l3 <== NOT EXECUTED
the_node->next = tail;
200e7e8: ae 04 20 0c add %l0, 0xc, %l7 <== NOT EXECUTED
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
200e7ec: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200e7f0: a8 15 23 00 or %l4, 0x300, %l4 <== NOT EXECUTED
200e7f4: a6 14 e2 fc or %l3, 0x2fc, %l3 <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
200e7f8: 7f ff d9 69 call 2004d9c <malloc> <== NOT EXECUTED
200e7fc: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
200e800: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
200e804: 02 80 00 bb be 200eaf0 <rtems_bdbuf_swapout_task+0x388> <== NOT EXECUTED
200e808: 01 00 00 00 nop <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e80c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED
the_node->next = tail;
200e810: ee 27 40 00 st %l7, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
200e814: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
200e818: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
200e81c: fa 24 20 10 st %i5, [ %l0 + 0x10 ] <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200e820: 7f ff fb 87 call 200d63c <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
200e824: ea 2f 60 0c stb %l5, [ %i5 + 0xc ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200e828: d2 04 60 18 ld [ %l1 + 0x18 ], %o1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
200e82c: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
200e830: 84 07 60 14 add %i5, 0x14, %g2 <== NOT EXECUTED
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200e834: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200e838: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
200e83c: 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;
200e840: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
200e844: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200e848: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200e84c: 90 16 40 14 or %i1, %l4, %o0 <== NOT EXECUTED
200e850: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
200e854: 98 07 60 08 add %i5, 8, %o4 <== NOT EXECUTED
200e858: 7f ff fb f7 call 200d834 <rtems_bdbuf_create_task.constprop.9><== NOT EXECUTED
200e85c: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
bdbuf_config.swapout_worker_priority,
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
200e860: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e864: 12 80 00 a1 bne 200eae8 <rtems_bdbuf_swapout_task+0x380> <== NOT EXECUTED
200e868: b2 06 60 01 inc %i1 <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200e86c: 80 a6 40 12 cmp %i1, %l2 <== NOT EXECUTED
200e870: 12 bf ff e2 bne 200e7f8 <rtems_bdbuf_swapout_task+0x90> <== NOT EXECUTED
200e874: 01 00 00 00 nop <== NOT EXECUTED
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
200e878: 7f ff fa fe call 200d470 <rtems_bdbuf_unlock_cache>
200e87c: 01 00 00 00 nop
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200e880: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200e884: 80 a0 60 00 cmp %g1, 0
200e888: 02 80 00 75 be 200ea5c <rtems_bdbuf_swapout_task+0x2f4> <== NEVER TAKEN
200e88c: 82 07 20 08 add %i4, 8, %g1
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200e890: a2 07 20 4c add %i4, 0x4c, %l1
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200e894: aa 07 20 58 add %i4, 0x58, %l5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200e898: a8 07 20 0c add %i4, 0xc, %l4
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200e89c: e2 27 bf dc st %l1, [ %fp + -36 ]
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
200e8a0: c2 27 bf d8 st %g1, [ %fp + -40 ]
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
200e8a4: b2 10 20 01 mov 1, %i1
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
200e8a8: a0 10 20 01 mov 1, %l0
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
200e8ac: 7f ff fa db call 200d418 <rtems_bdbuf_lock_cache>
200e8b0: 01 00 00 00 nop
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
200e8b4: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
200e8b8: 80 a0 60 00 cmp %g1, 0
200e8bc: 32 80 00 2f bne,a 200e978 <rtems_bdbuf_swapout_task+0x210>
200e8c0: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200e8c4: e6 07 20 08 ld [ %i4 + 8 ], %l3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200e8c8: 80 a4 c0 14 cmp %l3, %l4
200e8cc: 02 80 00 7b be 200eab8 <rtems_bdbuf_swapout_task+0x350> <== ALWAYS TAKEN
200e8d0: c2 07 bf d8 ld [ %fp + -40 ], %g1
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
200e8d4: c4 04 c0 00 ld [ %l3 ], %g2 <== NOT EXECUTED
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get_unprotected (&bdbuf_cache.swapout_workers);
if (worker)
transfer = &worker->transfer;
200e8d8: ba 04 e0 10 add %l3, 0x10, %i5 <== NOT EXECUTED
head->next = new_first;
200e8dc: c4 27 20 08 st %g2, [ %i4 + 8 ] <== NOT EXECUTED
new_first->previous = head;
200e8e0: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== 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 );
200e8e4: ae 07 60 04 add %i5, 4, %l7
/*
* 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,
200e8e8: a4 07 60 0c add %i5, 0xc, %l2
200e8ec: 96 10 20 01 mov 1, %o3
200e8f0: 98 10 20 00 clr %o4
200e8f4: 9a 10 00 1b mov %i3, %o5
200e8f8: 90 10 00 12 mov %l2, %o0
200e8fc: 94 10 00 1d mov %i5, %o2
head->next = tail;
200e900: ee 27 40 00 st %l7, [ %i5 ]
head->previous = NULL;
200e904: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
200e908: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
200e90c: c0 27 60 0c clr [ %i5 + 0xc ]
transfer->syncing = bdbuf_cache.sync_active;
200e910: c0 2f 60 10 clrb [ %i5 + 0x10 ]
/*
* 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,
200e914: 13 00 80 89 sethi %hi(0x2022400), %o1
200e918: 7f ff fa 4d call 200d24c <rtems_bdbuf_swapout_modified_processing>
200e91c: 92 12 63 64 or %o1, 0x364, %o1 ! 2022764 <bdbuf_cache+0x58>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200e920: d2 07 bf dc ld [ %fp + -36 ], %o1
200e924: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
200e928: 90 10 00 12 mov %l2, %o0
200e92c: 94 10 00 1d mov %i5, %o2
200e930: 98 0e 60 01 and %i1, 1, %o4
200e934: 7f ff fa 46 call 200d24c <rtems_bdbuf_swapout_modified_processing>
200e938: 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 ();
200e93c: 7f ff fa cd call 200d470 <rtems_bdbuf_unlock_cache>
200e940: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200e944: c6 07 40 00 ld [ %i5 ], %g3
200e948: 80 a0 c0 17 cmp %g3, %l7
200e94c: 02 80 00 28 be 200e9ec <rtems_bdbuf_swapout_task+0x284>
200e950: 80 a4 e0 00 cmp %l3, 0
{
if (worker)
200e954: 02 80 00 22 be 200e9dc <rtems_bdbuf_swapout_task+0x274> <== ALWAYS TAKEN
200e958: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
200e95c: d0 04 e0 08 ld [ %l3 + 8 ], %o0 <== NOT EXECUTED
200e960: 7f ff e8 3e call 2008a58 <rtems_event_send> <== NOT EXECUTED
200e964: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200e968: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e96c: 12 80 00 56 bne 200eac4 <rtems_bdbuf_swapout_task+0x35c> <== NOT EXECUTED
200e970: b2 10 20 00 clr %i1 <== NOT EXECUTED
200e974: 30 bf ff ce b,a 200e8ac <rtems_bdbuf_swapout_task+0x144> <== NOT EXECUTED
/*
* 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,
200e978: 96 10 20 01 mov 1, %o3
* 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)
transfer->dd = bdbuf_cache.sync_device;
200e97c: c2 27 bf f4 st %g1, [ %fp + -12 ]
/*
* 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,
200e980: 98 10 20 00 clr %o4
200e984: 9a 10 00 1b mov %i3, %o5
200e988: 90 07 bf f4 add %fp, -12, %o0
200e98c: 92 10 00 15 mov %l5, %o1
200e990: 94 10 00 1a mov %i2, %o2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e994: f0 27 bf e8 st %i0, [ %fp + -24 ]
head->previous = NULL;
200e998: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
200e99c: f4 27 bf f0 st %i2, [ %fp + -16 ]
200e9a0: 7f ff fa 2b call 200d24c <rtems_bdbuf_swapout_modified_processing>
200e9a4: e0 2f bf f8 stb %l0, [ %fp + -8 ]
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200e9a8: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
200e9ac: 90 07 bf f4 add %fp, -12, %o0
200e9b0: 92 10 00 11 mov %l1, %o1
200e9b4: 94 10 00 1a mov %i2, %o2
200e9b8: 98 0e 60 01 and %i1, 1, %o4
200e9bc: 7f ff fa 24 call 200d24c <rtems_bdbuf_swapout_modified_processing>
200e9c0: 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 ();
200e9c4: 7f ff fa ab call 200d470 <rtems_bdbuf_unlock_cache>
200e9c8: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200e9cc: c2 07 bf e8 ld [ %fp + -24 ], %g1
200e9d0: 80 a0 40 18 cmp %g1, %i0
200e9d4: 02 80 00 06 be 200e9ec <rtems_bdbuf_swapout_task+0x284>
200e9d8: ba 10 00 1a mov %i2, %i5
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
}
else
{
rtems_bdbuf_swapout_write (transfer);
200e9dc: 7f ff ff 09 call 200e600 <rtems_bdbuf_swapout_write>
200e9e0: 90 10 00 1d mov %i5, %o0
200e9e4: 10 bf ff b2 b 200e8ac <rtems_bdbuf_swapout_task+0x144>
200e9e8: b2 10 20 00 clr %i1
}
transfered_buffers = true;
}
if (bdbuf_cache.sync_active && !transfered_buffers)
200e9ec: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
200e9f0: 80 a0 60 00 cmp %g1, 0
200e9f4: 02 80 00 0f be 200ea30 <rtems_bdbuf_swapout_task+0x2c8>
200e9f8: 90 10 20 04 mov 4, %o0
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
200e9fc: 7f ff fa 87 call 200d418 <rtems_bdbuf_lock_cache>
200ea00: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
200ea04: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
200ea08: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
200ea0c: 7f ff fa 99 call 200d470 <rtems_bdbuf_unlock_cache>
200ea10: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
200ea14: 80 a7 60 00 cmp %i5, 0
200ea18: 02 80 00 06 be 200ea30 <rtems_bdbuf_swapout_task+0x2c8> <== NEVER TAKEN
200ea1c: 90 10 20 04 mov 4, %o0
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
200ea20: 90 10 00 1d mov %i5, %o0
200ea24: 7f ff e9 c0 call 2009124 <rtems_event_system_send>
200ea28: 13 20 00 00 sethi %hi(0x80000000), %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200ea2c: 90 10 20 04 mov 4, %o0
200ea30: 92 10 20 00 clr %o1
200ea34: 94 10 00 16 mov %l6, %o2
200ea38: 7f ff e7 a4 call 20088c8 <rtems_event_receive>
200ea3c: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
200ea40: 80 a2 20 06 cmp %o0, 6
200ea44: 12 80 00 22 bne 200eacc <rtems_bdbuf_swapout_task+0x364>
200ea48: 80 a2 20 00 cmp %o0, 0
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200ea4c: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200ea50: 80 a0 60 00 cmp %g1, 0
200ea54: 12 bf ff 95 bne 200e8a8 <rtems_bdbuf_swapout_task+0x140> <== ALWAYS TAKEN
200ea58: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
200ea5c: 7f ff fa 6f call 200d418 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200ea60: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200ea64: 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))
200ea68: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
200ea6c: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200ea70: 02 80 00 0a be 200ea98 <rtems_bdbuf_swapout_task+0x330> <== NOT EXECUTED
200ea74: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
200ea78: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
200ea7c: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
200ea80: 7f ff e7 f6 call 2008a58 <rtems_event_send> <== NOT EXECUTED
200ea84: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200ea88: 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))
200ea8c: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200ea90: 32 bf ff fb bne,a 200ea7c <rtems_bdbuf_swapout_task+0x314><== NOT EXECUTED
200ea94: 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 ();
200ea98: 7f ff fa 76 call 200d470 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200ea9c: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
200eaa0: 7f ff d7 77 call 200487c <free> <== NOT EXECUTED
200eaa4: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200eaa8: 7f ff e9 fd call 200929c <rtems_task_delete> <== NOT EXECUTED
200eaac: 90 10 20 00 clr %o0 <== NOT EXECUTED
200eab0: 81 c7 e0 08 ret <== NOT EXECUTED
200eab4: 81 e8 00 00 restore <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200eab8: a6 10 20 00 clr %l3
/*
* 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,
200eabc: 10 bf ff 8a b 200e8e4 <rtems_bdbuf_swapout_task+0x17c>
200eac0: ba 10 00 1a mov %i2, %i5
if (worker)
{
rtems_status_code sc = rtems_event_send (worker->id,
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
200eac4: 7f ff fa 43 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200eac8: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
200eacc: 22 bf ff e1 be,a 200ea50 <rtems_bdbuf_swapout_task+0x2e8><== ALWAYS TAKEN
200ead0: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
200ead4: 7f ff fa 3f call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ead8: 90 10 20 18 mov 0x18, %o0 <== NOT EXECUTED
200eadc: 39 00 80 89 sethi %hi(0x2022400), %i4
200eae0: 10 bf ff 66 b 200e878 <rtems_bdbuf_swapout_task+0x110>
200eae4: b8 17 23 0c or %i4, 0x30c, %i4 ! 202270c <bdbuf_cache>
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
200eae8: 7f ff fa 3a call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200eaec: 90 10 20 0d mov 0xd, %o0 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
200eaf0: 7f ff fa 38 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200eaf4: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
0200eafc <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)
{
200eafc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
200eb00: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200eb04: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200eb08: 02 80 00 1b be 200eb74 <rtems_bdbuf_swapout_worker_task+0x78><== NOT EXECUTED
200eb0c: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
200eb10: 39 00 80 89 sethi %hi(0x2022400), %i4 <== NOT EXECUTED
200eb14: b6 06 20 10 add %i0, 0x10, %i3 <== NOT EXECUTED
200eb18: b8 17 23 0c or %i4, 0x30c, %i4 <== NOT EXECUTED
200eb1c: b2 06 20 14 add %i0, 0x14, %i1 <== NOT EXECUTED
200eb20: b4 07 20 0c add %i4, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
200eb24: 7f ff fa b4 call 200d5f4 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
200eb28: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
200eb2c: 7f ff fe b5 call 200e600 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
200eb30: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200eb34: 7f ff fa 39 call 200d418 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200eb38: 01 00 00 00 nop <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200eb3c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200eb40: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200eb44: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200eb48: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
200eb4c: fa 27 20 10 st %i5, [ %i4 + 0x10 ] <== NOT EXECUTED
old_last->next = the_node;
200eb50: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
200eb54: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200eb58: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
200eb5c: 7f ff fa 45 call 200d470 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200eb60: f6 27 60 18 st %i3, [ %i5 + 0x18 ] <== 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)
200eb64: c2 0f 60 0c ldub [ %i5 + 0xc ], %g1 <== NOT EXECUTED
200eb68: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200eb6c: 12 bf ff ee bne 200eb24 <rtems_bdbuf_swapout_worker_task+0x28><== NOT EXECUTED
200eb70: 01 00 00 00 nop <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
200eb74: d0 07 60 24 ld [ %i5 + 0x24 ], %o0 <== NOT EXECUTED
200eb78: 7f ff d7 41 call 200487c <free> <== NOT EXECUTED
200eb7c: b0 10 20 00 clr %i0 <== NOT EXECUTED
free (worker);
200eb80: 7f ff d7 3f call 200487c <free> <== NOT EXECUTED
200eb84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200eb88: 7f ff e9 c5 call 200929c <rtems_task_delete> <== NOT EXECUTED
200eb8c: 81 e8 00 00 restore <== NOT EXECUTED
0200e600 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
200e600: 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;
200e604: 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 );
200e608: ba 06 20 04 add %i0, 4, %i5
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))
200e60c: 80 a0 40 1d cmp %g1, %i5
200e610: 02 80 00 4f be 200e74c <rtems_bdbuf_swapout_write+0x14c> <== NEVER TAKEN
200e614: b8 10 20 00 clr %i4
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
200e618: e0 06 20 0c ld [ %i0 + 0xc ], %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;
200e61c: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200e620: c4 04 20 08 ld [ %l0 + 8 ], %g2
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
200e624: f4 04 20 2c ld [ %l0 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200e628: e2 00 a0 0c ld [ %g2 + 0xc ], %l1
* 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;
200e62c: 84 10 20 0c mov 0xc, %g2
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200e630: a2 0c 60 01 and %l1, 1, %l1
* 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;
200e634: c4 22 60 0c st %g2, [ %o1 + 0xc ]
transfer->write_req->bufnum = 0;
200e638: c0 22 60 10 clr [ %o1 + 0x10 ]
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200e63c: b6 10 20 0c mov 0xc, %i3
* 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) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
200e640: 10 80 00 23 b 200e6cc <rtems_bdbuf_swapout_write+0xcc>
200e644: 25 00 80 7f sethi %hi(0x201fc00), %l2
200e648: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200e64c: c8 02 60 10 ld [ %o1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
200e650: f2 00 60 1c ld [ %g1 + 0x1c ], %i1
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
200e654: de 04 20 24 ld [ %l0 + 0x24 ], %o7
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
200e658: b8 01 20 01 add %g4, 1, %i4
200e65c: f8 22 60 10 st %i4, [ %o1 + 0x10 ]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200e660: 89 29 20 04 sll %g4, 4, %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200e664: b8 10 00 03 mov %g3, %i4
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200e668: 88 01 20 18 add %g4, 0x18, %g4
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
200e66c: 9a 10 20 00 clr %o5
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200e670: 86 02 40 04 add %o1, %g4, %g3
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200e674: f8 22 40 04 st %i4, [ %o1 + %g4 ]
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
200e678: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
200e67c: de 20 e0 04 st %o7, [ %g3 + 4 ]
buf->buffer = bd->buffer;
200e680: f2 20 e0 08 st %i1, [ %g3 + 8 ]
200e684: 82 10 00 02 mov %g2, %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) ||
200e688: 80 a7 40 01 cmp %i5, %g1
200e68c: 02 80 00 07 be 200e6a8 <rtems_bdbuf_swapout_write+0xa8>
200e690: 84 14 a0 b8 or %l2, 0xb8, %g2
200e694: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
200e698: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200e69c: 80 a0 c0 02 cmp %g3, %g2
200e6a0: 0a 80 00 1e bcs 200e718 <rtems_bdbuf_swapout_write+0x118>
200e6a4: 80 8b 60 ff btst 0xff, %o5
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
200e6a8: 90 10 00 10 mov %l0, %o0
200e6ac: 7f ff ff 5d call 200e420 <rtems_bdbuf_execute_transfer_request>
200e6b0: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200e6b4: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
200e6b8: c2 06 00 00 ld [ %i0 ], %g1
200e6bc: f6 22 60 0c st %i3, [ %o1 + 0xc ]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200e6c0: 80 a7 40 01 cmp %i5, %g1
200e6c4: 02 80 00 19 be 200e728 <rtems_bdbuf_swapout_write+0x128>
200e6c8: c0 22 60 10 clr [ %o1 + 0x10 ]
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
200e6cc: c4 00 40 00 ld [ %g1 ], %g2
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
200e6d0: 80 a4 60 00 cmp %l1, 0
head->next = new_first;
200e6d4: c4 26 00 00 st %g2, [ %i0 ]
200e6d8: 02 bf ff dc be 200e648 <rtems_bdbuf_swapout_write+0x48>
200e6dc: f0 20 a0 04 st %i0, [ %g2 + 4 ]
200e6e0: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
200e6e4: 80 a0 e0 00 cmp %g3, 0
200e6e8: 02 bf ff d9 be 200e64c <rtems_bdbuf_swapout_write+0x4c>
200e6ec: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
200e6f0: 88 07 00 1a add %i4, %i2, %g4
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
200e6f4: 80 a0 c0 04 cmp %g3, %g4
200e6f8: 02 bf ff d5 be 200e64c <rtems_bdbuf_swapout_write+0x4c>
200e6fc: 9a 10 20 01 mov 1, %o5
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200e700: f0 20 60 04 st %i0, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200e704: c2 26 00 00 st %g1, [ %i0 ]
the_node->next = before_node;
200e708: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
200e70c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
bd->block != last_block + media_blocks_per_block)
{
rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);
write = true;
200e710: 10 bf ff de b 200e688 <rtems_bdbuf_swapout_write+0x88>
200e714: c2 06 00 00 ld [ %i0 ], %g1
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
200e718: 12 bf ff e4 bne 200e6a8 <rtems_bdbuf_swapout_write+0xa8>
200e71c: 80 a7 40 01 cmp %i5, %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
200e720: 32 bf ff ec bne,a 200e6d0 <rtems_bdbuf_swapout_write+0xd0><== ALWAYS TAKEN
200e724: c4 00 40 00 ld [ %g1 ], %g2
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
200e728: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
200e72c: 80 a0 60 00 cmp %g1, 0
200e730: 02 80 00 0c be 200e760 <rtems_bdbuf_swapout_write+0x160>
200e734: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
200e738: d0 04 20 08 ld [ %l0 + 8 ], %o0
200e73c: 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 &&
200e740: 80 88 60 02 btst 2, %g1
200e744: 32 80 00 04 bne,a 200e754 <rtems_bdbuf_swapout_write+0x154><== NEVER TAKEN
200e748: c2 04 20 38 ld [ %l0 + 0x38 ], %g1 <== NOT EXECUTED
200e74c: 81 c7 e0 08 ret
200e750: 81 e8 00 00 restore
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
200e754: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
200e758: 9f c0 40 00 call %g1 <== NOT EXECUTED
200e75c: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e760: 81 c7 e0 08 ret
200e764: 81 e8 00 00 restore
0200d63c <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
200d63c: 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)));
200d640: 03 00 80 7f sethi %hi(0x201fc00), %g1
200d644: d0 00 60 bc ld [ %g1 + 0xbc ], %o0 ! 201fcbc <rtems_bdbuf_configuration+0x4>
200d648: 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 =
200d64c: 7f ff dd d4 call 2004d9c <malloc>
200d650: 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)
200d654: ba 92 20 00 orcc %o0, 0, %i5
200d658: 02 80 00 0b be 200d684 <rtems_bdbuf_swapout_writereq_alloc+0x48><== NEVER TAKEN
200d65c: 82 10 20 01 mov 1, %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
200d660: c2 27 40 00 st %g1, [ %i5 ]
write_req->done = rtems_bdbuf_transfer_done;
200d664: 03 00 80 3b sethi %hi(0x200ec00), %g1
200d668: 82 10 60 64 or %g1, 0x64, %g1 ! 200ec64 <rtems_bdbuf_transfer_done>
write_req->io_task = rtems_task_self ();
return write_req;
}
200d66c: b0 10 00 1d mov %i5, %i0
if (!write_req)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
write_req->done = rtems_bdbuf_transfer_done;
write_req->io_task = rtems_task_self ();
200d670: 40 00 12 86 call 2012088 <rtems_task_self>
200d674: c2 27 60 04 st %g1, [ %i5 + 4 ]
200d678: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
return write_req;
}
200d67c: 81 c7 e0 08 ret
200d680: 81 e8 00 00 restore
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
200d684: 7f ff ff 53 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d688: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
0200f674 <rtems_bdbuf_sync>:
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
200f674: 9d e3 bf a0 save %sp, -96, %sp
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
200f678: 80 a6 20 00 cmp %i0, 0
200f67c: 02 80 00 30 be 200f73c <rtems_bdbuf_sync+0xc8> <== NEVER TAKEN
200f680: 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();
200f684: 7f ff f7 65 call 200d418 <rtems_bdbuf_lock_cache>
200f688: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200f68c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200f690: 80 a2 20 03 cmp %o0, 3
200f694: 1a 80 00 04 bcc 200f6a4 <rtems_bdbuf_sync+0x30> <== ALWAYS TAKEN
200f698: 80 a2 20 05 cmp %o0, 5
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
200f69c: 7f ff f7 65 call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200f6a0: 92 10 20 11 mov 0x11, %o1 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200f6a4: 08 80 00 0b bleu 200f6d0 <rtems_bdbuf_sync+0x5c>
200f6a8: 82 10 20 08 mov 8, %g1
200f6ac: 80 a2 20 06 cmp %o0, 6
200f6b0: 12 bf ff fb bne 200f69c <rtems_bdbuf_sync+0x28> <== NEVER TAKEN
200f6b4: 01 00 00 00 nop
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);
200f6b8: 7f ff f9 7f call 200dcb4 <rtems_bdbuf_discard_buffer_after_access>
200f6bc: 90 10 00 18 mov %i0, %o0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200f6c0: 7f ff f7 6c call 200d470 <rtems_bdbuf_unlock_cache>
200f6c4: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200f6c8: 81 c7 e0 08 ret
200f6cc: 81 e8 00 00 restore
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200f6d0: 3b 00 80 89 sethi %hi(0x2022400), %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f6d4: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200f6d8: ba 17 63 0c or %i5, 0x30c, %i5
200f6dc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
the_node->next = tail;
200f6e0: 84 07 60 5c add %i5, 0x5c, %g2
tail->previous = the_node;
200f6e4: f0 27 60 60 st %i0, [ %i5 + 0x60 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200f6e8: c4 26 00 00 st %g2, [ %i0 ]
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
200f6ec: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
200f6f0: c2 26 20 04 st %g1, [ %i0 + 4 ]
200f6f4: 80 a0 a0 00 cmp %g2, 0
200f6f8: 12 80 00 13 bne 200f744 <rtems_bdbuf_sync+0xd0>
200f6fc: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
rtems_bdbuf_wake_swapper ();
200f700: 7f ff f7 62 call 200d488 <rtems_bdbuf_wake_swapper>
200f704: 01 00 00 00 nop
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);
200f708: 13 00 80 89 sethi %hi(0x2022400), %o1
200f70c: b8 12 63 78 or %o1, 0x378, %i4 ! 2022778 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200f710: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200f714: 80 a2 20 01 cmp %o0, 1
200f718: 0a 80 00 07 bcs 200f734 <rtems_bdbuf_sync+0xc0> <== NEVER TAKEN
200f71c: 80 a2 20 07 cmp %o0, 7
200f720: 28 80 00 10 bleu,a 200f760 <rtems_bdbuf_sync+0xec>
200f724: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200f728: 80 a2 20 0a cmp %o0, 0xa
200f72c: 28 80 00 09 bleu,a 200f750 <rtems_bdbuf_sync+0xdc> <== ALWAYS TAKEN
200f730: 90 10 00 18 mov %i0, %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_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);
200f734: 7f ff f7 3f call 200d430 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200f738: 92 10 20 15 mov 0x15, %o1 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
200f73c: 81 c7 e0 08 ret <== NOT EXECUTED
200f740: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200f744: 7f ff f7 ec call 200d6f4 <rtems_bdbuf_wake>
200f748: 90 07 60 64 add %i5, 0x64, %o0
200f74c: 30 bf ff ed b,a 200f700 <rtems_bdbuf_sync+0x8c>
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);
200f750: 7f ff f7 96 call 200d5a8 <rtems_bdbuf_wait>
200f754: 92 10 00 1c mov %i4, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200f758: 10 bf ff ef b 200f714 <rtems_bdbuf_sync+0xa0>
200f75c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
200f760: 80 a0 60 00 cmp %g1, 0
200f764: 12 bf ff d7 bne 200f6c0 <rtems_bdbuf_sync+0x4c>
200f768: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
200f76c: 80 a0 60 01 cmp %g1, 1
200f770: 18 bf ff d4 bgu 200f6c0 <rtems_bdbuf_sync+0x4c> <== NEVER TAKEN
200f774: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
200f778: 02 80 00 06 be 200f790 <rtems_bdbuf_sync+0x11c>
200f77c: 01 00 00 00 nop
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200f780: 11 00 80 89 sethi %hi(0x2022400), %o0
200f784: 7f ff f7 dc call 200d6f4 <rtems_bdbuf_wake>
200f788: 90 12 23 80 or %o0, 0x380, %o0 ! 2022780 <bdbuf_cache+0x74>
200f78c: 30 bf ff cd b,a 200f6c0 <rtems_bdbuf_sync+0x4c>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
200f790: 7f ff f8 41 call 200d894 <rtems_bdbuf_remove_from_tree>
200f794: 90 10 00 18 mov %i0, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200f798: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200f79c: c0 26 20 20 clr [ %i0 + 0x20 ]
after_node->next = the_node;
200f7a0: f0 27 60 40 st %i0, [ %i5 + 0x40 ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200f7a4: 05 00 80 89 sethi %hi(0x2022400), %g2
200f7a8: 84 10 a3 4c or %g2, 0x34c, %g2 ! 202274c <bdbuf_cache+0x40>
200f7ac: c4 26 20 04 st %g2, [ %i0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
200f7b0: c2 26 00 00 st %g1, [ %i0 ]
before_node->previous = the_node;
200f7b4: 10 bf ff f3 b 200f780 <rtems_bdbuf_sync+0x10c>
200f7b8: f0 20 60 04 st %i0, [ %g1 + 4 ]
0200d444 <rtems_bdbuf_unlock>:
* @param lock The mutex to unlock.
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
200d444: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
200d448: 7f ff ef 0c call 2009078 <rtems_semaphore_release>
200d44c: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
200d450: 80 a2 20 00 cmp %o0, 0
200d454: 12 80 00 04 bne 200d464 <rtems_bdbuf_unlock+0x20> <== NEVER TAKEN
200d458: 01 00 00 00 nop
200d45c: 81 c7 e0 08 ret
200d460: 81 e8 00 00 restore
rtems_bdbuf_fatal (fatal_error_code);
200d464: 7f ff ff db call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d468: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
0200d5f4 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
200d5f4: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
200d5f8: 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;
200d5fc: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
200d600: 90 10 00 18 mov %i0, %o0
200d604: 94 10 20 00 clr %o2
200d608: 7f ff ec b0 call 20088c8 <rtems_event_receive>
200d60c: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
200d610: 80 a2 20 00 cmp %o0, 0
200d614: 12 80 00 07 bne 200d630 <rtems_bdbuf_wait_for_event+0x3c> <== NEVER TAKEN
200d618: c2 07 bf fc ld [ %fp + -4 ], %g1
200d61c: 80 a0 40 18 cmp %g1, %i0
200d620: 12 80 00 04 bne 200d630 <rtems_bdbuf_wait_for_event+0x3c> <== NEVER TAKEN
200d624: 01 00 00 00 nop
200d628: 81 c7 e0 08 ret
200d62c: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
200d630: 7f ff ff 68 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d634: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED
0200e3e8 <rtems_bdbuf_wait_for_transient_event>:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
static void
rtems_bdbuf_wait_for_transient_event (void)
{
200e3e8: 9d e3 bf 98 save %sp, -104, %sp
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
200e3ec: 11 20 00 00 sethi %hi(0x80000000), %o0
200e3f0: 92 10 20 00 clr %o1
200e3f4: 94 10 20 00 clr %o2
200e3f8: 40 00 0e 95 call 2011e4c <rtems_event_system_receive>
200e3fc: 96 07 bf fc add %fp, -4, %o3
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_event_transient_receive (RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200e400: 80 a2 20 00 cmp %o0, 0
200e404: 12 80 00 04 bne 200e414 <rtems_bdbuf_wait_for_transient_event+0x2c><== NEVER TAKEN
200e408: 01 00 00 00 nop
200e40c: 81 c7 e0 08 ret
200e410: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
200e414: 7f ff fb ef call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200e418: 90 10 20 1d mov 0x1d, %o0 <== NOT EXECUTED
0200d6f4 <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)
{
200d6f4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
200d6f8: c2 06 00 00 ld [ %i0 ], %g1
200d6fc: 80 a0 60 00 cmp %g1, 0
200d700: 12 80 00 04 bne 200d710 <rtems_bdbuf_wake+0x1c>
200d704: 01 00 00 00 nop
200d708: 81 c7 e0 08 ret
200d70c: 81 e8 00 00 restore
{
sc = rtems_semaphore_flush (waiters->sema);
200d710: 40 00 11 a2 call 2011d98 <rtems_semaphore_flush>
200d714: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
200d718: 80 a2 20 00 cmp %o0, 0
200d71c: 02 bf ff fb be 200d708 <rtems_bdbuf_wake+0x14> <== ALWAYS TAKEN
200d720: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
200d724: 7f ff ff 2b call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d728: 90 10 20 04 mov 4, %o0 ! 4 <PROM_START+0x4> <== NOT EXECUTED
0200d488 <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
200d488: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
200d48c: 03 00 80 89 sethi %hi(0x2022400), %g1
200d490: d0 00 63 0c ld [ %g1 + 0x30c ], %o0 ! 202270c <bdbuf_cache>
200d494: 7f ff ed 71 call 2008a58 <rtems_event_send>
200d498: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200d49c: 80 a2 20 00 cmp %o0, 0
200d4a0: 12 80 00 04 bne 200d4b0 <rtems_bdbuf_wake_swapper+0x28> <== NEVER TAKEN
200d4a4: 01 00 00 00 nop
200d4a8: 81 c7 e0 08 ret
200d4ac: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
200d4b0: 7f ff ff c8 call 200d3d0 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d4b4: 90 10 20 0b mov 0xb, %o0 <== NOT EXECUTED
02002eb0 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
2002eb0: 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;
2002eb4: 80 a6 60 00 cmp %i1, 0
2002eb8: 02 80 00 06 be 2002ed0 <rtems_bdpart_create+0x20> <== NEVER TAKEN
2002ebc: 90 10 00 18 mov %i0, %o0
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
2002ec0: c2 06 40 00 ld [ %i1 ], %g1
2002ec4: 80 a0 60 00 cmp %g1, 0
2002ec8: 22 80 00 12 be,a 2002f10 <rtems_bdpart_create+0x60> <== ALWAYS TAKEN
2002ecc: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
2002ed0: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2002ed4: a2 10 20 00 clr %l1 <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2002ed8: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
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) {
2002edc: 80 a7 20 00 cmp %i4, 0
2002ee0: 02 80 00 0a be 2002f08 <rtems_bdpart_create+0x58> <== NEVER TAKEN
2002ee4: b0 10 20 00 clr %i0
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
2002ee8: 80 a6 a0 00 cmp %i2, 0
2002eec: 02 80 00 07 be 2002f08 <rtems_bdpart_create+0x58> <== NEVER TAKEN
2002ef0: b0 10 20 09 mov 9, %i0
2002ef4: 80 a6 60 00 cmp %i1, 0
2002ef8: 02 80 00 04 be 2002f08 <rtems_bdpart_create+0x58> <== NEVER TAKEN
2002efc: 80 a6 e0 00 cmp %i3, 0
2002f00: 12 80 00 0a bne 2002f28 <rtems_bdpart_create+0x78> <== ALWAYS TAKEN
2002f04: 92 10 20 00 clr %o1
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
2002f08: 81 c7 e0 08 ret <== NOT EXECUTED
2002f0c: 81 e8 00 00 restore <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
2002f10: 80 a0 60 00 cmp %g1, 0
2002f14: 02 bf ff f0 be 2002ed4 <rtems_bdpart_create+0x24> <== NEVER TAKEN
2002f18: c0 27 bf fc clr [ %fp + -4 ]
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2002f1c: a2 10 20 01 mov 1, %l1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2002f20: 10 bf ff ef b 2002edc <rtems_bdpart_create+0x2c>
2002f24: a0 10 20 3f mov 0x3f, %l0
if (format == NULL || pt == NULL || dist == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
2002f28: 94 10 20 00 clr %o2
2002f2c: 40 00 01 3d call 2003420 <rtems_bdpart_get_disk_data>
2002f30: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
2002f34: b0 92 20 00 orcc %o0, 0, %i0
2002f38: 12 80 00 72 bne 2003100 <rtems_bdpart_create+0x250> <== NEVER TAKEN
2002f3c: 01 00 00 00 nop
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
2002f40: e4 06 c0 00 ld [ %i3 ], %l2
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
2002f44: ba 94 a0 00 orcc %l2, 0, %i5
2002f48: 12 80 00 0b bne 2002f74 <rtems_bdpart_create+0xc4> <== ALWAYS TAKEN
2002f4c: 82 10 20 00 clr %g1
return RTEMS_INVALID_NUMBER;
2002f50: 81 c7 e0 08 ret <== NOT EXECUTED
2002f54: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
2002f58: c4 06 c0 02 ld [ %i3 + %g2 ], %g2
2002f5c: 86 07 40 02 add %i5, %g2, %g3
if (dist_sum < prev_sum) {
2002f60: 80 a0 c0 1d cmp %g3, %i5
2002f64: 0a 80 00 0e bcs 2002f9c <rtems_bdpart_create+0xec> <== NEVER TAKEN
2002f68: 80 a0 a0 00 cmp %g2, 0
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
2002f6c: 02 80 00 0c be 2002f9c <rtems_bdpart_create+0xec> <== NEVER TAKEN
2002f70: ba 10 00 03 mov %g3, %i5
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
2002f74: 82 00 60 01 inc %g1
2002f78: 80 a0 40 1c cmp %g1, %i4
2002f7c: 12 bf ff f7 bne 2002f58 <rtems_bdpart_create+0xa8>
2002f80: 85 28 60 02 sll %g1, 2, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2002f84: c2 06 40 00 ld [ %i1 ], %g1
2002f88: 80 a0 60 00 cmp %g1, 0
2002f8c: 02 80 00 06 be 2002fa4 <rtems_bdpart_create+0xf4> <== ALWAYS TAKEN
2002f90: a2 8c 60 ff andcc %l1, 0xff, %l1
return RTEMS_NOT_IMPLEMENTED;
2002f94: 81 c7 e0 08 ret <== NOT EXECUTED
2002f98: 91 e8 20 18 restore %g0, 0x18, %o0 <== NOT EXECUTED
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
return RTEMS_INVALID_NUMBER;
2002f9c: 81 c7 e0 08 ret <== NOT EXECUTED
2002fa0: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2002fa4: 02 80 00 06 be 2002fbc <rtems_bdpart_create+0x10c> <== NEVER TAKEN
2002fa8: ec 07 bf fc ld [ %fp + -4 ], %l6
disk_end -= (disk_end % record_space);
2002fac: 90 10 00 16 mov %l6, %o0
2002fb0: 40 00 7f fa call 2022f98 <.urem>
2002fb4: 92 10 00 10 mov %l0, %o1
2002fb8: ac 25 80 08 sub %l6, %o0, %l6
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
2002fbc: 80 a7 20 04 cmp %i4, 4
2002fc0: 08 80 00 06 bleu 2002fd8 <rtems_bdpart_create+0x128> <== NEVER TAKEN
2002fc4: aa 10 00 10 mov %l0, %l5
overhead += (count - 3) * record_space;
2002fc8: 90 10 00 10 mov %l0, %o0
2002fcc: 40 00 7f 0d call 2022c00 <.umul>
2002fd0: 92 07 3f fd add %i4, -3, %o1
2002fd4: aa 02 00 10 add %o0, %l0, %l5
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
2002fd8: 80 a4 60 00 cmp %l1, 0
2002fdc: 02 80 00 07 be 2002ff8 <rtems_bdpart_create+0x148> <== NEVER TAKEN
2002fe0: 82 05 40 1c add %l5, %i4, %g1
overhead += (count - 1) * record_space;
2002fe4: 90 10 00 10 mov %l0, %o0
2002fe8: 40 00 7f 06 call 2022c00 <.umul>
2002fec: 92 07 3f ff add %i4, -1, %o1
2002ff0: aa 05 40 08 add %l5, %o0, %l5
}
/* Check disk space */
if ((overhead + count) > disk_end) {
2002ff4: 82 05 40 1c add %l5, %i4, %g1
2002ff8: 80 a0 40 16 cmp %g1, %l6
2002ffc: 08 80 00 04 bleu 200300c <rtems_bdpart_create+0x15c> <== ALWAYS TAKEN
2003000: aa 25 80 15 sub %l6, %l5, %l5
return RTEMS_IO_ERROR;
2003004: 81 c7 e0 08 ret <== NOT EXECUTED
2003008: 91 e8 20 1b restore %g0, 0x1b, %o0 <== NOT EXECUTED
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
200300c: 92 10 00 12 mov %l2, %o1
2003010: 40 00 7e fc call 2022c00 <.umul>
2003014: 90 10 00 15 mov %l5, %o0
if (s < free_space || s < dist [i]) {
2003018: 80 a5 40 08 cmp %l5, %o0
200301c: 18 bf ff e0 bgu 2002f9c <rtems_bdpart_create+0xec> <== NEVER TAKEN
2003020: 80 a4 80 08 cmp %l2, %o0
2003024: 18 bf ff de bgu 2002f9c <rtems_bdpart_create+0xec> <== NEVER TAKEN
2003028: 80 a7 20 04 cmp %i4, 4
200302c: 18 80 00 03 bgu 2003038 <rtems_bdpart_create+0x188> <== ALWAYS TAKEN
2003030: ae 10 20 01 mov 1, %l7
2003034: ae 10 20 00 clr %l7 <== NOT EXECUTED
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2003038: a8 06 a0 30 add %i2, 0x30, %l4
200303c: a6 10 00 1a mov %i2, %l3
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
2003040: a2 10 00 10 mov %l0, %l1
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2003044: b2 10 20 00 clr %i1
/* Align partition upwards */
s += record_space - (s % record_space);
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
2003048: 10 80 00 0b b 2003074 <rtems_bdpart_create+0x1c4>
200304c: ae 0d e0 ff and %l7, 0xff, %l7
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
2003050: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
2003054: a6 10 00 14 mov %l4, %l3
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
2003058: 40 00 7e ea call 2022c00 <.umul>
200305c: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
2003060: 80 a5 40 08 cmp %l5, %o0
2003064: 18 bf ff ce bgu 2002f9c <rtems_bdpart_create+0xec> <== NEVER TAKEN
2003068: 80 a4 80 08 cmp %l2, %o0
200306c: 18 bf ff cc bgu 2002f9c <rtems_bdpart_create+0xec> <== NEVER TAKEN
2003070: a8 05 20 30 add %l4, 0x30, %l4
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
2003074: 40 00 7f 1d call 2022ce8 <.udiv>
2003078: 92 10 00 1d mov %i5, %o1
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
200307c: 92 10 00 10 mov %l0, %o1
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
/* Ensure that the partition is not empty */
if (s == 0) {
2003080: 80 a2 20 00 cmp %o0, 0
2003084: 12 80 00 03 bne 2003090 <rtems_bdpart_create+0x1e0> <== ALWAYS TAKEN
2003088: a4 10 00 08 mov %o0, %l2
s = 1;
200308c: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
}
/* Align partition upwards */
s += record_space - (s % record_space);
2003090: 40 00 7f c2 call 2022f98 <.urem>
2003094: 90 10 00 12 mov %l2, %o0
2003098: a4 04 80 10 add %l2, %l0, %l2
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
200309c: 92 10 00 15 mov %l5, %o1
/* Align partition upwards */
s += record_space - (s % record_space);
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
20030a0: 82 10 20 01 mov 1, %g1
20030a4: 80 a6 60 02 cmp %i1, 2
20030a8: 18 80 00 03 bgu 20030b4 <rtems_bdpart_create+0x204>
20030ac: 90 24 80 08 sub %l2, %o0, %o0
20030b0: 82 10 20 00 clr %g1
20030b4: 80 88 60 ff btst 0xff, %g1
20030b8: 22 80 00 06 be,a 20030d0 <rtems_bdpart_create+0x220>
20030bc: e2 24 c0 00 st %l1, [ %l3 ]
20030c0: 80 a5 e0 00 cmp %l7, 0
20030c4: 32 80 00 02 bne,a 20030cc <rtems_bdpart_create+0x21c> <== ALWAYS TAKEN
20030c8: a2 04 40 10 add %l1, %l0, %l1
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
20030cc: e2 24 c0 00 st %l1, [ %l3 ]
pos += s;
20030d0: a2 04 40 08 add %l1, %o0, %l1
p->end = pos;
20030d4: e2 24 e0 04 st %l1, [ %l3 + 4 ]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
20030d8: b2 06 60 01 inc %i1
20030dc: 80 a7 00 19 cmp %i4, %i1
20030e0: 18 bf ff dc bgu 2003050 <rtems_bdpart_create+0x1a0>
20030e4: 83 2e 60 02 sll %i1, 2, %g1
pos += s;
p->end = pos;
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
20030e8: b8 07 3f ff add %i4, -1, %i4
20030ec: 83 2f 20 04 sll %i4, 4, %g1
20030f0: b9 2f 20 06 sll %i4, 6, %i4
20030f4: 82 27 00 01 sub %i4, %g1, %g1
20030f8: b4 06 80 01 add %i2, %g1, %i2
20030fc: ec 26 a0 04 st %l6, [ %i2 + 4 ]
2003100: 81 c7 e0 08 ret
2003104: 81 e8 00 00 restore
02003108 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
2003108: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
200310c: 11 00 80 95 sethi %hi(0x2025400), %o0
2003110: 40 00 4f 26 call 2016da8 <puts>
2003114: 90 12 21 70 or %o0, 0x170, %o0 ! 2025570 <Configuration_Initial_Extensions+0x510>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2003118: 80 a6 60 00 cmp %i1, 0
200311c: 02 80 00 3a be 2003204 <rtems_bdpart_dump+0xfc> <== NEVER TAKEN
2003120: 11 00 80 95 sethi %hi(0x2025400), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2003124: 29 00 80 95 sethi %hi(0x2025400), %l4
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
2003128: 37 00 80 95 sethi %hi(0x2025400), %i3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
200312c: 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";
2003130: 2b 00 80 95 sethi %hi(0x2025400), %l5
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2003134: a8 15 22 b0 or %l4, 0x2b0, %l4
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
2003138: 27 00 80 95 sethi %hi(0x2025400), %l3
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
200313c: 25 00 80 95 sethi %hi(0x2025400), %l2
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2003140: 23 00 80 95 sethi %hi(0x2025400), %l1
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
2003144: 21 00 80 95 sethi %hi(0x2025400), %l0
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
2003148: 35 00 80 95 sethi %hi(0x2025400), %i2
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
200314c: 10 80 00 19 b 20031b0 <rtems_bdpart_dump+0xa8>
2003150: b6 16 e2 b8 or %i3, 0x2b8, %i3
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) {
2003154: 80 a2 e0 0b cmp %o3, 0xb
2003158: 22 80 00 0e be,a 2003190 <rtems_bdpart_dump+0x88> <== ALWAYS TAKEN
200315c: 96 15 61 58 or %l5, 0x158, %o3
2003160: 18 80 00 2d bgu 2003214 <rtems_bdpart_dump+0x10c> <== NOT EXECUTED
2003164: 80 a2 e0 0e cmp %o3, 0xe <== NOT EXECUTED
2003168: 80 a2 e0 01 cmp %o3, 1 <== NOT EXECUTED
200316c: 02 80 00 36 be 2003244 <rtems_bdpart_dump+0x13c> <== NOT EXECUTED
2003170: 80 a2 e0 04 cmp %o3, 4 <== NOT EXECUTED
2003174: 22 80 00 07 be,a 2003190 <rtems_bdpart_dump+0x88> <== NOT EXECUTED
2003178: 96 16 a1 30 or %i2, 0x130, %o3 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
200317c: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
2003180: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
2003184: 40 00 4f c2 call 201708c <snprintf> <== NOT EXECUTED
2003188: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
type = type_buffer;
200318c: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
2003190: d2 06 00 00 ld [ %i0 ], %o1
2003194: d4 06 20 04 ld [ %i0 + 4 ], %o2
2003198: 40 00 4e ce call 2016cd0 <printf>
200319c: 90 10 00 1b mov %i3, %o0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
20031a0: ba 07 60 01 inc %i5
20031a4: 80 a7 40 19 cmp %i5, %i1
20031a8: 02 80 00 16 be 2003200 <rtems_bdpart_dump+0xf8>
20031ac: b0 06 20 30 add %i0, 0x30, %i0
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
20031b0: c0 2f bf c7 clrb [ %fp + -57 ]
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
20031b4: b8 06 20 08 add %i0, 8, %i4
20031b8: 92 07 bf c7 add %fp, -57, %o1
20031bc: 40 00 00 8d call 20033f0 <rtems_bdpart_to_mbr_partition_type>
20031c0: 90 10 00 1c mov %i4, %o0
20031c4: 80 8a 20 ff btst 0xff, %o0
20031c8: 12 bf ff e3 bne 2003154 <rtems_bdpart_dump+0x4c> <== ALWAYS TAKEN
20031cc: d6 0f bf c7 ldub [ %fp + -57 ], %o3
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
20031d0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20031d4: 40 00 2e 06 call 200e9ec <uuid_unparse_lower> <== NOT EXECUTED
20031d8: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
20031dc: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
20031e0: d4 06 20 04 ld [ %i0 + 4 ], %o2 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
20031e4: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
}
printf(
20031e8: 40 00 4e ba call 2016cd0 <printf> <== NOT EXECUTED
20031ec: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
20031f0: ba 07 60 01 inc %i5 <== NOT EXECUTED
20031f4: 80 a7 40 19 cmp %i5, %i1 <== NOT EXECUTED
20031f8: 12 bf ff ee bne 20031b0 <rtems_bdpart_dump+0xa8> <== NOT EXECUTED
20031fc: b0 06 20 30 add %i0, 0x30, %i0 <== NOT EXECUTED
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
2003200: 11 00 80 95 sethi %hi(0x2025400), %o0
2003204: 40 00 4e e9 call 2016da8 <puts>
2003208: 90 12 22 60 or %o0, 0x260, %o0 ! 2025660 <Configuration_Initial_Extensions+0x600>
200320c: 81 c7 e0 08 ret
2003210: 81 e8 00 00 restore
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) {
2003214: 02 80 00 0a be 200323c <rtems_bdpart_dump+0x134> <== NOT EXECUTED
2003218: 80 a2 e0 da cmp %o3, 0xda <== NOT EXECUTED
200321c: 02 80 00 06 be 2003234 <rtems_bdpart_dump+0x12c> <== NOT EXECUTED
2003220: 80 a2 e0 0c cmp %o3, 0xc <== NOT EXECUTED
2003224: 12 bf ff d7 bne 2003180 <rtems_bdpart_dump+0x78> <== NOT EXECUTED
2003228: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
200322c: 10 bf ff d9 b 2003190 <rtems_bdpart_dump+0x88> <== NOT EXECUTED
2003230: 96 14 61 48 or %l1, 0x148, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
2003234: 10 bf ff d7 b 2003190 <rtems_bdpart_dump+0x88> <== NOT EXECUTED
2003238: 96 14 a1 40 or %l2, 0x140, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
200323c: 10 bf ff d5 b 2003190 <rtems_bdpart_dump+0x88> <== NOT EXECUTED
2003240: 96 14 e1 60 or %l3, 0x160, %o3 <== NOT EXECUTED
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
2003244: 10 bf ff d3 b 2003190 <rtems_bdpart_dump+0x88> <== NOT EXECUTED
2003248: 96 14 21 38 or %l0, 0x138, %o3 <== NOT EXECUTED
02003420 <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
2003420: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum disk_begin = 0;
rtems_blkdev_bnum block_size = 0;
/* Open device file */
fd = open( disk_name, O_RDWR);
2003424: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
2003428: 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);
200342c: 40 00 0d d3 call 2006b78 <open>
2003430: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
2003434: ba 92 20 00 orcc %o0, 0, %i5
2003438: 16 80 00 07 bge 2003454 <rtems_bdpart_get_disk_data+0x34> <== ALWAYS TAKEN
200343c: 94 07 bf fc add %fp, -4, %o2
sc = RTEMS_INVALID_NAME;
2003440: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
*fd_ptr = fd;
*dd_ptr = dd;
} else {
close( fd);
2003444: 40 00 09 3d call 2005938 <close> <== NOT EXECUTED
2003448: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200344c: 81 c7 e0 08 ret <== NOT EXECUTED
2003450: 81 e8 00 00 restore <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
2003454: 13 10 01 10 sethi %hi(0x40044000), %o1
2003458: 40 00 0a 74 call 2005e28 <ioctl>
200345c: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <RAM_END+0x3dc44209>
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
2003460: 80 a2 20 00 cmp %o0, 0
2003464: 32 bf ff f8 bne,a 2003444 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
2003468: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
200346c: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
2003470: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
2003474: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
*disk_end = dd->size;
2003478: c4 26 c0 00 st %g2, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
200347c: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
2003480: 80 a0 a1 ff cmp %g2, 0x1ff
2003484: 08 bf ff f0 bleu 2003444 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
2003488: b0 10 20 1b mov 0x1b, %i0
sc = RTEMS_IO_ERROR;
goto error;
}
/* Check that we have do not have a logical disk */
if (disk_begin != 0) {
200348c: 80 a0 e0 00 cmp %g3, 0
2003490: 12 bf ff ed bne 2003444 <rtems_bdpart_get_disk_data+0x24> <== NEVER TAKEN
2003494: 80 a6 60 00 cmp %i1, 0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
2003498: 02 80 00 08 be 20034b8 <rtems_bdpart_get_disk_data+0x98>
200349c: 80 a6 a0 00 cmp %i2, 0
20034a0: 02 80 00 07 be 20034bc <rtems_bdpart_get_disk_data+0x9c> <== NEVER TAKEN
20034a4: b0 10 20 00 clr %i0
*fd_ptr = fd;
20034a8: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
20034ac: c2 26 80 00 st %g1, [ %i2 ]
20034b0: 81 c7 e0 08 ret
20034b4: 81 e8 00 00 restore
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
20034b8: b0 10 20 00 clr %i0
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
*fd_ptr = fd;
*dd_ptr = dd;
} else {
close( fd);
20034bc: 40 00 09 1f call 2005938 <close>
20034c0: 90 10 00 1d mov %i5, %o0
20034c4: 81 c7 e0 08 ret
20034c8: 81 e8 00 00 restore
02024bcc <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2024bcc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
2024bd0: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2024bd4: 40 00 7c 96 call 2043e2c <strrchr> <== NOT EXECUTED
2024bd8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024bdc: b8 10 00 08 mov %o0, %i4 <== 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);
2024be0: 40 00 78 70 call 2042da0 <strlen> <== NOT EXECUTED
2024be4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024be8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2024bec: 40 00 78 6d call 2042da0 <strlen> <== NOT EXECUTED
2024bf0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2024bf4: ba 10 00 18 mov %i0, %i5 <== 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);
2024bf8: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
2024bfc: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
2024c00: 7f ff 7a ea call 20037a8 <malloc> <== NOT EXECUTED
2024c04: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
2024c08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024c0c: 02 80 00 4f be 2024d48 <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
2024c10: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
2024c14: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2024c18: 40 00 79 1e call 2043090 <strncpy> <== NOT EXECUTED
2024c1c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
2024c20: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2024c24: 02 80 00 06 be 2024c3c <rtems_bdpart_mount+0x70> <== NOT EXECUTED
2024c28: a6 10 00 10 mov %l0, %l3 <== NOT EXECUTED
disk_file_name += 1;
2024c2c: ba 07 20 01 add %i4, 1, %i5 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
2024c30: 40 00 78 5c call 2042da0 <strlen> <== NOT EXECUTED
2024c34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2024c38: a6 10 00 08 mov %o0, %l3 <== 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);
2024c3c: a4 04 c0 11 add %l3, %l1, %l2 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
2024c40: 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);
2024c44: 7f ff 7a d9 call 20037a8 <malloc> <== NOT EXECUTED
2024c48: 90 04 a0 05 add %l2, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
2024c4c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024c50: 02 80 00 3a be 2024d38 <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
2024c54: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
2024c58: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2024c5c: 40 00 79 0d call 2043090 <strncpy> <== NOT EXECUTED
2024c60: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
2024c64: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2024c68: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2024c6c: 90 04 60 01 add %l1, 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] = '/';
2024c70: c2 2f 00 11 stb %g1, [ %i4 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2024c74: 90 07 00 08 add %i4, %o0, %o0 <== NOT EXECUTED
2024c78: 40 00 79 06 call 2043090 <strncpy> <== NOT EXECUTED
2024c7c: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2024c80: b0 04 a0 01 add %l2, 1, %i0 <== NOT EXECUTED
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);
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
2024c84: b6 06 40 10 add %i1, %l0, %i3 <== NOT EXECUTED
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) {
2024c88: ba 10 20 00 clr %i5 <== NOT EXECUTED
2024c8c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2024c90: 02 80 00 29 be 2024d34 <rtems_bdpart_mount+0x168> <== NOT EXECUTED
2024c94: b0 07 00 18 add %i4, %i0, %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2024c98: 21 00 81 7d sethi %hi(0x205f400), %l0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
2024c9c: 23 00 81 76 sethi %hi(0x205d800), %l1 <== NOT EXECUTED
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) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2024ca0: a0 14 20 60 or %l0, 0x60, %l0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
2024ca4: 10 80 00 04 b 2024cb4 <rtems_bdpart_mount+0xe8> <== NOT EXECUTED
2024ca8: a2 14 60 c8 or %l1, 0xc8, %l1 <== 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) {
2024cac: 22 80 00 23 be,a 2024d38 <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
2024cb0: b0 10 20 00 clr %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2024cb4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2024cb8: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2024cbc: ba 07 60 01 inc %i5 <== NOT EXECUTED
2024cc0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2024cc4: 40 00 74 bf call 2041fc0 <snprintf> <== NOT EXECUTED
2024cc8: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
2024ccc: 94 10 20 04 mov 4, %o2 <== 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) {
2024cd0: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
2024cd4: 92 10 00 1b mov %i3, %o1 <== 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) {
2024cd8: 14 80 00 1e bg 2024d50 <rtems_bdpart_mount+0x184> <== NOT EXECUTED
2024cdc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
2024ce0: 40 00 78 ec call 2043090 <strncpy> <== NOT EXECUTED
2024ce4: 01 00 00 00 nop <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
2024ce8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2024cec: 40 00 0f 67 call 2028a88 <rtems_mkdir> <== NOT EXECUTED
2024cf0: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
2024cf4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024cf8: 12 80 00 1c bne 2024d68 <rtems_bdpart_mount+0x19c> <== NOT EXECUTED
2024cfc: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
2024d00: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
2024d04: 96 10 20 00 clr %o3 <== NOT EXECUTED
2024d08: 98 10 20 00 clr %o4 <== NOT EXECUTED
2024d0c: 7f ff 7b 2d call 20039c0 <mount> <== NOT EXECUTED
2024d10: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
2024d14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024d18: 02 bf ff e5 be 2024cac <rtems_bdpart_mount+0xe0> <== NOT EXECUTED
2024d1c: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
rmdir( mount_point);
2024d20: 40 00 0f 2e call 20289d8 <rmdir> <== NOT EXECUTED
2024d24: 90 10 00 1c mov %i4, %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) {
2024d28: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
2024d2c: 12 bf ff e3 bne 2024cb8 <rtems_bdpart_mount+0xec> <== NOT EXECUTED
2024d30: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
2024d34: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2024d38: 7f ff 79 c2 call 2003440 <free> <== NOT EXECUTED
2024d3c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
2024d40: 7f ff 79 c0 call 2003440 <free> <== NOT EXECUTED
2024d44: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
2024d48: 81 c7 e0 08 ret <== NOT EXECUTED
2024d4c: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2024d50: 7f ff 79 bc call 2003440 <free> <== NOT EXECUTED
2024d54: 90 10 00 19 mov %i1, %o0 <== 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;
2024d58: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
2024d5c: 7f ff 79 b9 call 2003440 <free> <== NOT EXECUTED
2024d60: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2024d64: 30 bf ff f9 b,a 2024d48 <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2024d68: 7f ff 79 b6 call 2003440 <free> <== NOT EXECUTED
2024d6c: 90 10 00 19 mov %i1, %o0 <== 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;
2024d70: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
2024d74: 7f ff 79 b3 call 2003440 <free> <== NOT EXECUTED
2024d78: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2024d7c: 30 bf ff f3 b,a 2024d48 <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
02003940 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
2003940: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
2003944: d0 06 80 00 ld [ %i2 ], %o0
2003948: 80 a2 20 00 cmp %o0, 0
200394c: 22 80 00 07 be,a 2003968 <rtems_bdpart_new_record+0x28>
2003950: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_sync( *block);
2003954: 40 00 35 60 call 2010ed4 <rtems_bdbuf_sync>
2003958: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
200395c: ba 92 20 00 orcc %o0, 0, %i5
2003960: 12 80 00 17 bne 20039bc <rtems_bdpart_new_record+0x7c> <== NEVER TAKEN
2003964: 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);
2003968: 92 10 00 19 mov %i1, %o1
200396c: 40 00 34 7d call 2010b60 <rtems_bdbuf_read>
2003970: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003974: ba 92 20 00 orcc %o0, 0, %i5
2003978: 12 80 00 11 bne 20039bc <rtems_bdpart_new_record+0x7c> <== NEVER TAKEN
200397c: 01 00 00 00 nop
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2003980: c2 06 80 00 ld [ %i2 ], %g1
2003984: 80 a0 60 00 cmp %g1, 0
2003988: 02 80 00 0f be 20039c4 <rtems_bdpart_new_record+0x84> <== NEVER TAKEN
200398c: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
2003990: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003994: 40 00 4c 7c call 2016b84 <memset>
2003998: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
200399c: c2 06 80 00 ld [ %i2 ], %g1
20039a0: 84 10 20 55 mov 0x55, %g2
20039a4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20039a8: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
20039ac: c2 06 80 00 ld [ %i2 ], %g1
20039b0: 84 10 3f aa mov -86, %g2
20039b4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20039b8: c4 28 61 ff stb %g2, [ %g1 + 0x1ff ]
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
20039bc: 81 c7 e0 08 ret
20039c0: 91 e8 00 1d restore %g0, %i5, %o0
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
20039c4: 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;
}
20039c8: 81 c7 e0 08 ret <== NOT EXECUTED
20039cc: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
020034cc <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
20034cc: 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;
20034d0: 82 06 bf d0 add %i2, -48, %g1
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
20034d4: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
20034d8: 80 a6 e0 00 cmp %i3, 0
20034dc: 02 80 00 0a be 2003504 <rtems_bdpart_read+0x38> <== NEVER TAKEN
20034e0: c2 27 bf ec st %g1, [ %fp + -20 ]
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;
20034e4: 82 10 3f ff mov -1, %g1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
20034e8: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
20034ec: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
20034f0: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
20034f4: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
20034f8: 80 a6 a0 00 cmp %i2, 0
20034fc: 12 80 00 04 bne 200350c <rtems_bdpart_read+0x40> <== ALWAYS TAKEN
2003500: fa 06 c0 00 ld [ %i3 ], %i5
return RTEMS_INVALID_ADDRESS;
2003504: 81 c7 e0 08 ret <== NOT EXECUTED
2003508: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
const uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
200350c: 80 a6 60 00 cmp %i1, 0
2003510: 02 bf ff fd be 2003504 <rtems_bdpart_read+0x38> <== NEVER TAKEN
2003514: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
2003518: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
200351c: 92 07 bf f8 add %fp, -8, %o1
2003520: 94 07 bf fc add %fp, -4, %o2
2003524: 7f ff ff bf call 2003420 <rtems_bdpart_get_disk_data>
2003528: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
200352c: b0 92 20 00 orcc %o0, 0, %i0
2003530: 12 80 00 14 bne 2003580 <rtems_bdpart_read+0xb4> <== NEVER TAKEN
2003534: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
2003538: 92 10 20 00 clr %o1
200353c: 7f ff ff 44 call 200324c <rtems_bdpart_read_record>
2003540: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003544: b0 92 20 00 orcc %o0, 0, %i0
2003548: 02 80 00 10 be 2003588 <rtems_bdpart_read+0xbc> <== ALWAYS TAKEN
200354c: c4 07 bf e8 ld [ %fp + -24 ], %g2
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
2003550: d0 07 bf f8 ld [ %fp + -8 ], %o0
2003554: 80 a2 20 00 cmp %o0, 0
2003558: 26 80 00 05 bl,a 200356c <rtems_bdpart_read+0xa0> <== NEVER TAKEN
200355c: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
2003560: 40 00 08 f6 call 2005938 <close>
2003564: 01 00 00 00 nop
}
if (block != NULL) {
2003568: d0 07 bf e8 ld [ %fp + -24 ], %o0
200356c: 80 a2 20 00 cmp %o0, 0
2003570: 02 80 00 04 be 2003580 <rtems_bdpart_read+0xb4> <== NEVER TAKEN
2003574: 01 00 00 00 nop
rtems_bdbuf_release( block);
2003578: 40 00 35 ff call 2010d74 <rtems_bdbuf_release>
200357c: 01 00 00 00 nop
}
return esc;
}
2003580: 81 c7 e0 08 ret
2003584: 81 e8 00 00 restore
{
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);
2003588: 83 2f 60 04 sll %i5, 4, %g1
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
200358c: e2 00 a0 1c ld [ %g2 + 0x1c ], %l1
{
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);
2003590: b9 2f 60 06 sll %i5, 6, %i4
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2003594: a0 04 61 be add %l1, 0x1be, %l0
{
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);
2003598: b8 27 00 01 sub %i4, %g1, %i4
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
200359c: 90 10 00 10 mov %l0, %o0
{
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);
20035a0: b8 06 80 1c add %i2, %i4, %i4
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20035a4: 92 07 bf ec add %fp, -20, %o1
20035a8: 94 10 00 1c mov %i4, %o2
20035ac: 7f ff ff 54 call 20032fc <rtems_bdpart_read_mbr_partition>
20035b0: 96 07 bf f0 add %fp, -16, %o3
if (sc != RTEMS_SUCCESSFUL) {
20035b4: b0 92 20 00 orcc %o0, 0, %i0
20035b8: 32 bf ff e7 bne,a 2003554 <rtems_bdpart_read+0x88> <== NEVER TAKEN
20035bc: 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) {
20035c0: c2 07 bf ec ld [ %fp + -20 ], %g1
20035c4: c2 08 60 08 ldub [ %g1 + 8 ], %g1
20035c8: 80 a0 60 ee cmp %g1, 0xee
20035cc: 02 bf ff e1 be 2003550 <rtems_bdpart_read+0x84> <== NEVER TAKEN
20035d0: 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
20035d4: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
20035d8: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
20035dc: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
20035e0: 84 10 20 00 clr %g2
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
20035e4: 82 01 21 bb add %g4, 0x1bb, %g1
20035e8: 88 01 21 b7 add %g4, 0x1b7, %g4
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
20035ec: c6 08 40 00 ldub [ %g1 ], %g3
20035f0: 85 28 a0 08 sll %g2, 8, %g2
20035f4: 82 00 7f ff add %g1, -1, %g1
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
20035f8: 80 a0 40 04 cmp %g1, %g4
20035fc: 12 bf ff fc bne 20035ec <rtems_bdpart_read+0x120>
2003600: 84 00 c0 02 add %g3, %g2, %g2
/* 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
);
format->mbr.dos_compatibility = true;
2003604: 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(
2003608: c4 26 60 04 st %g2, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
200360c: c2 2e 60 08 stb %g1, [ %i1 + 8 ]
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
2003610: a2 04 61 ee add %l1, 0x1ee, %l1
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
2003614: a0 04 20 10 add %l0, 0x10, %l0
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2003618: 92 07 bf ec add %fp, -20, %o1
200361c: 90 10 00 10 mov %l0, %o0
2003620: 94 10 00 1c mov %i4, %o2
2003624: 7f ff ff 36 call 20032fc <rtems_bdpart_read_mbr_partition>
2003628: 96 07 bf f0 add %fp, -16, %o3
if (sc != RTEMS_SUCCESSFUL) {
200362c: 80 a2 20 00 cmp %o0, 0
2003630: 12 80 00 4a bne 2003758 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
2003634: 80 a4 00 11 cmp %l0, %l1
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) {
2003638: 32 bf ff f8 bne,a 2003618 <rtems_bdpart_read+0x14c>
200363c: a0 04 20 10 add %l0, 0x10, %l0
goto cleanup;
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
2003640: fa 07 bf f0 ld [ %fp + -16 ], %i5
while (ebr != 0) {
2003644: 80 a7 60 00 cmp %i5, 0
2003648: 02 80 00 2c be 20036f8 <rtems_bdpart_read+0x22c> <== NEVER TAKEN
200364c: c8 07 bf ec ld [ %fp + -20 ], %g4
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
2003650: d0 07 bf fc ld [ %fp + -4 ], %o0
2003654: 92 10 00 1d mov %i5, %o1
2003658: 7f ff fe fd call 200324c <rtems_bdpart_read_record>
200365c: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003660: 80 a2 20 00 cmp %o0, 0
2003664: 12 80 00 3d bne 2003758 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
2003668: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
200366c: 92 07 bf ec add %fp, -20, %o1
2003670: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003674: 94 10 00 1c mov %i4, %o2
2003678: 90 02 21 be add %o0, 0x1be, %o0
200367c: 7f ff ff 20 call 20032fc <rtems_bdpart_read_mbr_partition>
2003680: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
2003684: 80 a2 20 00 cmp %o0, 0
2003688: 12 80 00 34 bne 2003758 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
200368c: c8 07 bf ec ld [ %fp + -20 ], %g4
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
2003690: c2 01 00 00 ld [ %g4 ], %g1
2003694: 84 07 40 01 add %i5, %g1, %g2
if (tmp > p->begin) {
2003698: 80 a0 40 02 cmp %g1, %g2
200369c: 3a bf ff ad bcc,a 2003550 <rtems_bdpart_read+0x84> <== NEVER TAKEN
20036a0: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
20036a4: c2 01 20 04 ld [ %g4 + 4 ], %g1
20036a8: ba 07 40 01 add %i5, %g1, %i5
if (tmp > p->end) {
20036ac: 80 a0 40 1d cmp %g1, %i5
20036b0: 1a 80 00 28 bcc 2003750 <rtems_bdpart_read+0x284> <== NEVER TAKEN
20036b4: c4 21 00 00 st %g2, [ %g4 ]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
20036b8: c2 07 bf e8 ld [ %fp + -24 ], %g1
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
p->end = tmp;
20036bc: fa 21 20 04 st %i5, [ %g4 + 4 ]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
20036c0: f2 00 60 1c ld [ %g1 + 0x1c ], %i1
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
20036c4: 84 10 20 00 clr %g2
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
20036c8: 82 10 20 03 mov 3, %g1
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
20036cc: ba 06 61 d6 add %i1, 0x1d6, %i5
value = (value << 8) + data [i];
20036d0: c6 0f 40 01 ldub [ %i5 + %g1 ], %g3
20036d4: 85 28 a0 08 sll %g2, 8, %g2
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
20036d8: 82 00 7f ff add %g1, -1, %g1
20036dc: 80 a0 7f ff cmp %g1, -1
20036e0: 12 bf ff fc bne 20036d0 <rtems_bdpart_read+0x204>
20036e4: 84 00 c0 02 add %g3, %g2, %g2
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
20036e8: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
20036ec: 80 a0 60 05 cmp %g1, 5
20036f0: 02 80 00 11 be 2003734 <rtems_bdpart_read+0x268>
20036f4: 80 a0 a0 00 cmp %g2, 0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
20036f8: 82 21 00 1a sub %g4, %i2, %g1
20036fc: 83 38 60 04 sra %g1, 4, %g1
2003700: 85 28 60 02 sll %g1, 2, %g2
2003704: 82 00 80 01 add %g2, %g1, %g1
2003708: 85 28 60 04 sll %g1, 4, %g2
200370c: 82 00 40 02 add %g1, %g2, %g1
2003710: 85 28 60 08 sll %g1, 8, %g2
rtems_bdpart_partition *pt,
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2003714: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
2003718: 82 00 40 02 add %g1, %g2, %g1
200371c: 85 28 60 10 sll %g1, 0x10, %g2
2003720: 82 00 40 02 add %g1, %g2, %g1
2003724: 82 20 00 01 neg %g1
2003728: 82 00 60 01 inc %g1
200372c: 10 bf ff 89 b 2003550 <rtems_bdpart_read+0x84>
2003730: c2 26 c0 00 st %g1, [ %i3 ]
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
2003734: 02 bf ff f2 be 20036fc <rtems_bdpart_read+0x230> <== NEVER TAKEN
2003738: 82 21 00 1a sub %g4, %i2, %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
200373c: fa 07 bf f0 ld [ %fp + -16 ], %i5
2003740: ba 00 80 1d add %g2, %i5, %i5
if (tmp > ebr) {
2003744: 80 a7 40 02 cmp %i5, %g2
2003748: 18 bf ff c3 bgu 2003654 <rtems_bdpart_read+0x188> <== ALWAYS TAKEN
200374c: d0 07 bf fc ld [ %fp + -4 ], %o0
/* Adjust partition begin */
tmp = p->begin + ebr;
if (tmp > p->begin) {
p->begin = tmp;
} else {
esc = RTEMS_IO_ERROR;
2003750: 10 bf ff 80 b 2003550 <rtems_bdpart_read+0x84> <== NOT EXECUTED
2003754: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2003758: 10 bf ff 7e b 2003550 <rtems_bdpart_read+0x84> <== NOT EXECUTED
200375c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
020032fc <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
20032fc: 9d e3 bf a0 save %sp, -96, %sp
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
2003300: ba 10 20 00 clr %i5
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
2003304: 88 06 20 0b add %i0, 0xb, %g4
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2003308: b8 10 00 18 mov %i0, %i4
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
200330c: 82 10 00 04 mov %g4, %g1
2003310: 86 06 20 07 add %i0, 7, %g3
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
2003314: c4 08 40 00 ldub [ %g1 ], %g2
2003318: bb 2f 60 08 sll %i5, 8, %i5
200331c: 82 00 7f ff add %g1, -1, %g1
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
2003320: 80 a0 40 03 cmp %g1, %g3
2003324: 12 bf ff fc bne 2003314 <rtems_bdpart_read_mbr_partition+0x18>
2003328: ba 00 80 1d add %g2, %i5, %i5
200332c: 82 07 20 0f add %i4, 0xf, %g1
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
2003330: 84 10 20 00 clr %g2
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
2003334: c6 08 40 00 ldub [ %g1 ], %g3
2003338: 85 28 a0 08 sll %g2, 8, %g2
200333c: 82 00 7f ff add %g1, -1, %g1
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
2003340: 80 a0 40 04 cmp %g1, %g4
2003344: 12 bf ff fc bne 2003334 <rtems_bdpart_read_mbr_partition+0x38>
2003348: 84 00 c0 02 add %g3, %g2, %g2
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) {
200334c: e0 0f 20 04 ldub [ %i4 + 4 ], %l0
2003350: 80 a4 20 00 cmp %l0, 0
2003354: 02 80 00 0a be 200337c <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
2003358: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
200335c: c2 06 40 00 ld [ %i1 ], %g1
2003360: 80 a0 40 1a cmp %g1, %i2
2003364: 02 80 00 06 be 200337c <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
2003368: 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;
200336c: b4 00 80 1d add %g2, %i5, %i2
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
2003370: 80 a6 80 1d cmp %i2, %i5
2003374: 18 80 00 04 bgu 2003384 <rtems_bdpart_read_mbr_partition+0x88><== ALWAYS TAKEN
2003378: b0 10 20 1b mov 0x1b, %i0
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
}
200337c: 81 c7 e0 08 ret <== NOT EXECUTED
2003380: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
2003384: 80 a4 20 05 cmp %l0, 5
2003388: 12 80 00 08 bne 20033a8 <rtems_bdpart_read_mbr_partition+0xac>
200338c: 90 00 60 30 add %g1, 0x30, %o0
if (ep_begin != NULL) {
2003390: 80 a6 e0 00 cmp %i3, 0
2003394: 02 80 00 15 be 20033e8 <rtems_bdpart_read_mbr_partition+0xec><== NEVER TAKEN
2003398: 01 00 00 00 nop
*ep_begin = begin;
200339c: fa 26 c0 00 st %i5, [ %i3 ]
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
20033a0: 81 c7 e0 08 ret
20033a4: 91 e8 20 00 restore %g0, 0, %o0
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20033a8: 94 10 20 30 mov 0x30, %o2
20033ac: 92 10 20 00 clr %o1
20033b0: 40 00 4d f5 call 2016b84 <memset>
20033b4: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
20033b8: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
20033bc: 90 10 00 10 mov %l0, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
20033c0: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
20033c4: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
20033c8: 7f ff ff c4 call 20032d8 <rtems_bdpart_to_partition_type>
20033cc: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
20033d0: c2 06 40 00 ld [ %i1 ], %g1
20033d4: c4 0f 00 00 ldub [ %i4 ], %g2
20033d8: c0 20 60 28 clr [ %g1 + 0x28 ]
20033dc: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
}
return RTEMS_SUCCESSFUL;
20033e0: 81 c7 e0 08 ret
20033e4: 91 e8 20 00 restore %g0, 0, %o0
}
20033e8: 81 c7 e0 08 ret <== NOT EXECUTED
20033ec: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0200324c <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
200324c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
2003250: d0 06 80 00 ld [ %i2 ], %o0
2003254: 80 a2 20 00 cmp %o0, 0
2003258: 22 80 00 08 be,a 2003278 <rtems_bdpart_read_record+0x2c>
200325c: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release( *block);
2003260: 40 00 36 c5 call 2010d74 <rtems_bdbuf_release>
2003264: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003268: 80 a2 20 00 cmp %o0, 0
200326c: 12 80 00 13 bne 20032b8 <rtems_bdpart_read_record+0x6c> <== NEVER TAKEN
2003270: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
2003274: 90 10 00 18 mov %i0, %o0
2003278: 92 10 00 19 mov %i1, %o1
200327c: 40 00 36 39 call 2010b60 <rtems_bdbuf_read>
2003280: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003284: 80 a2 20 00 cmp %o0, 0
2003288: 12 80 00 0c bne 20032b8 <rtems_bdpart_read_record+0x6c> <== NEVER TAKEN
200328c: 01 00 00 00 nop
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2003290: c2 06 80 00 ld [ %i2 ], %g1
2003294: 80 a0 60 00 cmp %g1, 0
2003298: 22 80 00 0e be,a 20032d0 <rtems_bdpart_read_record+0x84> <== NEVER TAKEN
200329c: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
20032a0: c2 00 60 1c ld [ %g1 + 0x1c ], %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]
20032a4: c4 08 61 fe ldub [ %g1 + 0x1fe ], %g2
20032a8: 80 a0 a0 55 cmp %g2, 0x55
20032ac: 22 80 00 05 be,a 20032c0 <rtems_bdpart_read_record+0x74> <== ALWAYS TAKEN
20032b0: c2 08 61 ff ldub [ %g1 + 0x1ff ], %g1
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
20032b4: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
20032b8: 81 c7 e0 08 ret
20032bc: 91 e8 00 08 restore %g0, %o0, %o0
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]
20032c0: 80 a0 60 aa cmp %g1, 0xaa
20032c4: 32 bf ff fd bne,a 20032b8 <rtems_bdpart_read_record+0x6c><== NEVER TAKEN
20032c8: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
20032cc: 30 bf ff fb b,a 20032b8 <rtems_bdpart_read_record+0x6c>
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20032d0: 81 c7 e0 08 ret <== NOT EXECUTED
20032d4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02003760 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2003760: 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);
2003764: 90 10 00 18 mov %i0, %o0
2003768: 40 00 50 c4 call 2017a78 <strlen>
200376c: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
2003770: 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
)
{
2003774: ba 10 00 18 mov %i0, %i5
rtems_blkdev_bnum disk_end = 0;
dev_t disk = 0;
dev_t logical_disk = 0;
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
size_t disk_name_size = strlen( disk_name);
2003778: a4 10 00 08 mov %o0, %l2
size_t i = 0;
int fd = -1;
200377c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2003780: 90 10 00 18 mov %i0, %o0
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
size_t disk_name_size = strlen( disk_name);
size_t i = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
2003784: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2003788: 92 07 bf f8 add %fp, -8, %o1
200378c: 94 07 bf fc add %fp, -4, %o2
2003790: 7f ff ff 24 call 2003420 <rtems_bdpart_get_disk_data>
2003794: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003798: b0 92 20 00 orcc %o0, 0, %i0
200379c: 12 80 00 32 bne 2003864 <rtems_bdpart_register+0x104> <== NEVER TAKEN
20037a0: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
20037a4: 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;
20037a8: e2 00 60 04 ld [ %g1 + 4 ], %l1
20037ac: 40 00 08 63 call 2005938 <close>
20037b0: f6 00 40 00 ld [ %g1 ], %i3
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
20037b4: 90 04 a0 04 add %l2, 4, %o0
20037b8: 40 00 0a b9 call 200629c <malloc>
20037bc: b8 10 00 11 mov %l1, %i4
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
20037c0: 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) {
20037c4: 80 a2 20 00 cmp %o0, 0
20037c8: 02 80 00 27 be 2003864 <rtems_bdpart_register+0x104> <== NEVER TAKEN
20037cc: a0 10 00 08 mov %o0, %l0
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
20037d0: 92 10 00 1d mov %i5, %o1
20037d4: 40 00 51 31 call 2017c98 <strncpy>
20037d8: 94 10 00 12 mov %l2, %o2
/* 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);
20037dc: 31 00 80 95 sethi %hi(0x2025400), %i0
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
20037e0: a4 04 00 12 add %l0, %l2, %l2
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
20037e4: ba 10 20 00 clr %i5
20037e8: 80 a6 a0 00 cmp %i2, 0
20037ec: 12 80 00 06 bne 2003804 <rtems_bdpart_register+0xa4> <== ALWAYS TAKEN
20037f0: b0 16 22 e0 or %i0, 0x2e0, %i0
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
20037f4: 10 80 00 1a b 200385c <rtems_bdpart_register+0xfc> <== NOT EXECUTED
20037f8: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
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) {
20037fc: 02 80 00 1c be 200386c <rtems_bdpart_register+0x10c>
2003800: b2 06 60 30 add %i1, 0x30, %i1
/* 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);
2003804: 92 10 20 04 mov 4, %o1
2003808: 94 10 00 18 mov %i0, %o2
200380c: ba 07 60 01 inc %i5
2003810: 90 10 00 12 mov %l2, %o0
2003814: 40 00 4e 1e call 201708c <snprintf>
2003818: 96 10 00 1d mov %i5, %o3
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
int rv = 0;
/* New minor number */
++minor;
200381c: b8 07 20 01 inc %i4
/* 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);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2003820: 80 a2 20 03 cmp %o0, 3
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2003824: 92 10 00 1c mov %i4, %o1
2003828: 94 10 00 1b mov %i3, %o2
200382c: 96 10 00 11 mov %l1, %o3
/* 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);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2003830: 14 80 00 11 bg 2003874 <rtems_bdpart_register+0x114> <== NEVER TAKEN
2003834: 90 10 00 1b mov %i3, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2003838: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
200383c: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2003840: e0 23 a0 5c st %l0, [ %sp + 0x5c ]
2003844: 40 00 03 7d call 2004638 <rtems_disk_create_log>
2003848: 9a 23 40 0c sub %o5, %o4, %o5
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
200384c: 80 a2 20 00 cmp %o0, 0
2003850: 02 bf ff eb be 20037fc <rtems_bdpart_register+0x9c> <== ALWAYS TAKEN
2003854: 80 a7 40 1a cmp %i5, %i2
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2003858: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
200385c: 40 00 08 f3 call 2005c28 <free>
2003860: 90 10 00 10 mov %l0, %o0
return esc;
}
2003864: 81 c7 e0 08 ret
2003868: 81 e8 00 00 restore
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
200386c: 10 bf ff fc b 200385c <rtems_bdpart_register+0xfc>
2003870: b0 10 20 00 clr %i0
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);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
esc = RTEMS_INVALID_NAME;
2003874: 10 bf ff fa b 200385c <rtems_bdpart_register+0xfc> <== NOT EXECUTED
2003878: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
0200387c <rtems_bdpart_register_from_disk>:
return esc;
}
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
200387c: 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;
2003880: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2003884: 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;
2003888: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
200388c: 92 07 bc ec add %fp, -788, %o1
2003890: 94 07 bd 00 add %fp, -768, %o2
2003894: 7f ff ff 0e call 20034cc <rtems_bdpart_read>
2003898: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
200389c: 80 a2 20 00 cmp %o0, 0
20038a0: 12 80 00 05 bne 20038b4 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
20038a4: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
20038a8: 90 10 00 18 mov %i0, %o0
20038ac: 7f ff ff ad call 2003760 <rtems_bdpart_register>
20038b0: 92 07 bd 00 add %fp, -768, %o1
}
20038b4: 81 c7 e0 08 ret
20038b8: 91 e8 00 08 restore %g0, %o0, %o0
02024d80 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2024d80: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
2024d84: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2024d88: 40 00 7c 29 call 2043e2c <strrchr> <== NOT EXECUTED
2024d8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024d90: b8 10 00 08 mov %o0, %i4 <== 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);
2024d94: 40 00 78 03 call 2042da0 <strlen> <== NOT EXECUTED
2024d98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024d9c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2024da0: 40 00 78 00 call 2042da0 <strlen> <== NOT EXECUTED
2024da4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
2024da8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2024dac: 02 80 00 42 be 2024eb4 <rtems_bdpart_unmount+0x134> <== NOT EXECUTED
2024db0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
disk_file_name += 1;
2024db4: a2 07 20 01 add %i4, 1, %l1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
2024db8: 40 00 77 fa call 2042da0 <strlen> <== NOT EXECUTED
2024dbc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2024dc0: a0 10 00 08 mov %o0, %l0 <== 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);
2024dc4: b2 04 00 1d add %l0, %i5, %i1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
2024dc8: 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);
2024dcc: 7f ff 7a 77 call 20037a8 <malloc> <== NOT EXECUTED
2024dd0: 90 06 60 05 add %i1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
2024dd4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024dd8: 02 80 00 2b be 2024e84 <rtems_bdpart_unmount+0x104> <== NOT EXECUTED
2024ddc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
2024de0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2024de4: 40 00 78 ab call 2043090 <strncpy> <== NOT EXECUTED
2024de8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
2024dec: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2024df0: 90 07 60 01 add %i5, 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] = '/';
2024df4: c2 2f 00 1d stb %g1, [ %i4 + %i5 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2024df8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2024dfc: 90 07 00 08 add %i4, %o0, %o0 <== NOT EXECUTED
2024e00: 40 00 78 a4 call 2043090 <strncpy> <== NOT EXECUTED
2024e04: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2024e08: b2 06 60 01 inc %i1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2024e0c: 37 00 81 7d sethi %hi(0x205f400), %i3 <== 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) {
2024e10: ba 10 20 00 clr %i5 <== NOT EXECUTED
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);
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2024e14: b2 07 00 19 add %i4, %i1, %i1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2024e18: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2024e1c: 12 80 00 06 bne 2024e34 <rtems_bdpart_unmount+0xb4> <== NOT EXECUTED
2024e20: b6 16 e0 60 or %i3, 0x60, %i3 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
2024e24: 10 80 00 1c b 2024e94 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
2024e28: b0 10 20 00 clr %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) {
2024e2c: 02 80 00 1a be 2024e94 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
2024e30: b0 10 20 00 clr %i0 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2024e34: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2024e38: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2024e3c: ba 07 60 01 inc %i5 <== NOT EXECUTED
2024e40: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2024e44: 40 00 74 5f call 2041fc0 <snprintf> <== NOT EXECUTED
2024e48: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2024e4c: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2024e50: 14 80 00 15 bg 2024ea4 <rtems_bdpart_unmount+0x124> <== NOT EXECUTED
2024e54: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
2024e58: 40 00 10 95 call 20290ac <unmount> <== NOT EXECUTED
2024e5c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (rv == 0) {
2024e60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024e64: 12 bf ff f2 bne 2024e2c <rtems_bdpart_unmount+0xac> <== NOT EXECUTED
2024e68: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
2024e6c: 40 00 0e db call 20289d8 <rmdir> <== NOT EXECUTED
2024e70: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (rv != 0) {
2024e74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024e78: 02 bf ff ed be 2024e2c <rtems_bdpart_unmount+0xac> <== NOT EXECUTED
2024e7c: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
2024e80: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
2024e84: 7f ff 79 6f call 2003440 <free> <== NOT EXECUTED
2024e88: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
2024e8c: 81 c7 e0 08 ret <== NOT EXECUTED
2024e90: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
2024e94: 7f ff 79 6b call 2003440 <free> <== NOT EXECUTED
2024e98: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
2024e9c: 81 c7 e0 08 ret <== NOT EXECUTED
2024ea0: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
2024ea4: 7f ff 79 67 call 2003440 <free> <== NOT EXECUTED
2024ea8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
2024eac: 81 c7 e0 08 ret <== NOT EXECUTED
2024eb0: 81 e8 00 00 restore <== 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;
2024eb4: 10 bf ff c4 b 2024dc4 <rtems_bdpart_unmount+0x44> <== NOT EXECUTED
2024eb8: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
020038bc <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
20038bc: 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;
20038c0: 82 10 3f ff mov -1, %g1
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
20038c4: 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;
20038c8: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
20038cc: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
20038d0: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
20038d4: 92 07 bf f8 add %fp, -8, %o1
20038d8: 94 07 bf fc add %fp, -4, %o2
20038dc: 7f ff fe d1 call 2003420 <rtems_bdpart_get_disk_data>
20038e0: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
20038e4: b0 92 20 00 orcc %o0, 0, %i0
20038e8: 12 80 00 14 bne 2003938 <rtems_bdpart_unregister+0x7c> <== NEVER TAKEN
20038ec: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
20038f0: d0 07 bf f8 ld [ %fp + -8 ], %o0
20038f4: 40 00 08 11 call 2005938 <close>
20038f8: f8 18 40 00 ldd [ %g1 ], %i4
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
20038fc: 80 a6 a0 00 cmp %i2, 0
2003900: 12 80 00 05 bne 2003914 <rtems_bdpart_unregister+0x58> <== ALWAYS TAKEN
2003904: b4 06 80 1d add %i2, %i5, %i2
2003908: 30 80 00 0c b,a 2003938 <rtems_bdpart_unregister+0x7c> <== NOT EXECUTED
200390c: 02 80 00 0b be 2003938 <rtems_bdpart_unregister+0x7c>
2003910: 01 00 00 00 nop
/* New minor number */
++minor;
2003914: ba 07 60 01 inc %i5
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
2003918: 90 10 00 1c mov %i4, %o0
200391c: 40 00 02 cc call 200444c <rtems_disk_delete>
2003920: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
2003924: 80 a2 20 00 cmp %o0, 0
2003928: 02 bf ff f9 be 200390c <rtems_bdpart_unregister+0x50> <== ALWAYS TAKEN
200392c: 80 a7 40 1a cmp %i5, %i2
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
2003930: 81 c7 e0 08 ret <== NOT EXECUTED
2003934: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
2003938: 81 c7 e0 08 ret
200393c: 81 e8 00 00 restore
020039d0 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
20039d0: 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;
20039d4: 80 a6 60 00 cmp %i1, 0
20039d8: 02 80 00 06 be 20039f0 <rtems_bdpart_write+0x20> <== NEVER TAKEN
20039dc: 90 10 00 18 mov %i0, %o0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
20039e0: c2 06 40 00 ld [ %i1 ], %g1
20039e4: 80 a0 60 00 cmp %g1, 0
20039e8: 22 80 00 11 be,a 2003a2c <rtems_bdpart_write+0x5c> <== ALWAYS TAKEN
20039ec: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
20039f0: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
20039f4: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
20039f8: ba 10 20 00 clr %i5 <== NOT EXECUTED
&& 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 =
20039fc: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
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;
2003a00: 82 10 3f ff mov -1, %g1
rtems_disk_device *dd = NULL;
2003a04: c0 27 bf fc clr [ %fp + -4 ]
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;
2003a08: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
2003a0c: 80 a6 e0 00 cmp %i3, 0
2003a10: 02 80 00 4e be 2003b48 <rtems_bdpart_write+0x178> <== NEVER TAKEN
2003a14: b0 10 20 00 clr %i0
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
2003a18: 80 a6 a0 00 cmp %i2, 0
2003a1c: 12 80 00 0b bne 2003a48 <rtems_bdpart_write+0x78> <== ALWAYS TAKEN
2003a20: 80 a6 60 00 cmp %i1, 0
return RTEMS_INVALID_ADDRESS;
2003a24: 81 c7 e0 08 ret <== NOT EXECUTED
2003a28: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
{
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;
2003a2c: 80 a0 60 00 cmp %g1, 0
2003a30: 02 bf ff f1 be 20039f4 <rtems_bdpart_write+0x24> <== NEVER TAKEN
2003a34: c0 27 bf f0 clr [ %fp + -16 ]
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
2003a38: c0 27 bf f4 clr [ %fp + -12 ]
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2003a3c: ba 10 20 01 mov 1, %i5
&& 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 =
2003a40: 10 bf ff f0 b 2003a00 <rtems_bdpart_write+0x30>
2003a44: b8 10 20 3f mov 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
2003a48: 02 bf ff f7 be 2003a24 <rtems_bdpart_write+0x54> <== NEVER TAKEN
2003a4c: 92 07 bf f8 add %fp, -8, %o1
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2003a50: 94 07 bf fc add %fp, -4, %o2
2003a54: 7f ff fe 73 call 2003420 <rtems_bdpart_get_disk_data>
2003a58: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003a5c: b0 92 20 00 orcc %o0, 0, %i0
2003a60: 12 80 00 3a bne 2003b48 <rtems_bdpart_write+0x178> <== NEVER TAKEN
2003a64: ba 8f 60 ff andcc %i5, 0xff, %i5
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2003a68: 32 80 00 25 bne,a 2003afc <rtems_bdpart_write+0x12c> <== ALWAYS TAKEN
2003a6c: f0 07 bf f4 ld [ %fp + -12 ], %i0
2003a70: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
/* 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) {
2003a74: de 06 80 00 ld [ %i2 ], %o7
2003a78: 80 a3 c0 08 cmp %o7, %o0
2003a7c: 3a 80 00 27 bcc,a 2003b18 <rtems_bdpart_write+0x148> <== NEVER TAKEN
2003a80: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
2003a84: c2 06 a0 04 ld [ %i2 + 4 ], %g1
2003a88: 80 a2 00 01 cmp %o0, %g1
2003a8c: 0a 80 00 22 bcs 2003b14 <rtems_bdpart_write+0x144> <== NEVER TAKEN
2003a90: 80 a3 c0 01 cmp %o7, %g1
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
2003a94: 1a 80 00 20 bcc 2003b14 <rtems_bdpart_write+0x144> <== NEVER TAKEN
2003a98: a2 10 00 1a mov %i2, %l1
2003a9c: 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) {
2003aa0: 84 10 20 00 clr %g2
2003aa4: 84 00 a0 01 inc %g2
2003aa8: 80 a0 80 1b cmp %g2, %i3
2003aac: 22 80 00 29 be,a 2003b50 <rtems_bdpart_write+0x180>
2003ab0: c2 06 40 00 ld [ %i1 ], %g1
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) {
2003ab4: c6 00 60 30 ld [ %g1 + 0x30 ], %g3
2003ab8: 80 a0 c0 08 cmp %g3, %o0
2003abc: 3a 80 00 17 bcc,a 2003b18 <rtems_bdpart_write+0x148> <== NEVER TAKEN
2003ac0: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
2003ac4: c8 00 60 34 ld [ %g1 + 0x34 ], %g4
2003ac8: 80 a1 00 08 cmp %g4, %o0
2003acc: 18 80 00 12 bgu 2003b14 <rtems_bdpart_write+0x144> <== NEVER TAKEN
2003ad0: 80 a0 c0 04 cmp %g3, %g4
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
2003ad4: 1a 80 00 10 bcc 2003b14 <rtems_bdpart_write+0x144> <== NEVER TAKEN
2003ad8: 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) {
2003adc: 22 bf ff f2 be,a 2003aa4 <rtems_bdpart_write+0xd4> <== NEVER TAKEN
2003ae0: 82 00 60 30 add %g1, 0x30, %g1 <== NOT EXECUTED
2003ae4: c8 00 60 04 ld [ %g1 + 4 ], %g4
2003ae8: 80 a0 c0 04 cmp %g3, %g4
2003aec: 0a 80 00 0a bcs 2003b14 <rtems_bdpart_write+0x144> <== NEVER TAKEN
2003af0: 82 00 60 30 add %g1, 0x30, %g1
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
2003af4: 10 bf ff ed b 2003aa8 <rtems_bdpart_write+0xd8>
2003af8: 84 00 a0 01 inc %g2
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
2003afc: 92 10 00 1c mov %i4, %o1
2003b00: 40 00 7d 26 call 2022f98 <.urem>
2003b04: 90 10 00 18 mov %i0, %o0
2003b08: 90 26 00 08 sub %i0, %o0, %o0
2003b0c: 10 bf ff da b 2003a74 <rtems_bdpart_write+0xa4>
2003b10: d0 27 bf f4 st %o0, [ %fp + -12 ]
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) {
esc = RTEMS_INVALID_NUMBER;
2003b14: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
2003b18: d0 07 bf f8 ld [ %fp + -8 ], %o0
2003b1c: 80 a2 20 00 cmp %o0, 0
2003b20: 26 80 00 05 bl,a 2003b34 <rtems_bdpart_write+0x164> <== NEVER TAKEN
2003b24: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
2003b28: 40 00 07 84 call 2005938 <close>
2003b2c: 01 00 00 00 nop
}
if (block != NULL) {
2003b30: d0 07 bf f0 ld [ %fp + -16 ], %o0
2003b34: 80 a2 20 00 cmp %o0, 0
2003b38: 02 80 00 04 be 2003b48 <rtems_bdpart_write+0x178> <== NEVER TAKEN
2003b3c: 01 00 00 00 nop
rtems_bdbuf_sync( block);
2003b40: 40 00 34 e5 call 2010ed4 <rtems_bdbuf_sync>
2003b44: 01 00 00 00 nop
2003b48: 81 c7 e0 08 ret
2003b4c: 81 e8 00 00 restore
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2003b50: 80 a0 60 00 cmp %g1, 0
2003b54: 12 bf ff f1 bne 2003b18 <rtems_bdpart_write+0x148> <== NEVER TAKEN
2003b58: 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;
2003b5c: 80 a6 e0 04 cmp %i3, 4
2003b60: 08 80 00 03 bleu 2003b6c <rtems_bdpart_write+0x19c> <== NEVER TAKEN
2003b64: a0 10 00 1b mov %i3, %l0
2003b68: a0 10 20 03 mov 3, %l0
/*
* 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) {
2003b6c: 80 a7 60 00 cmp %i5, 0
2003b70: 02 80 00 06 be 2003b88 <rtems_bdpart_write+0x1b8> <== NEVER TAKEN
2003b74: 80 a4 00 1b cmp %l0, %i3
2003b78: 80 a3 e0 3f cmp %o7, 0x3f
2003b7c: 12 bf ff e7 bne 2003b18 <rtems_bdpart_write+0x148> <== NEVER TAKEN
2003b80: b0 10 20 0a mov 0xa, %i0
* 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) {
2003b84: 80 a4 00 1b cmp %l0, %i3
2003b88: 1a 80 00 1c bcc 2003bf8 <rtems_bdpart_write+0x228> <== NEVER TAKEN
2003b8c: 84 04 3f ff add %l0, -1, %g2
if ((pt [i].begin - pt [i - 1].end) < record_space) {
2003b90: 89 2c 20 06 sll %l0, 6, %g4
2003b94: 87 28 a0 04 sll %g2, 4, %g3
2003b98: 83 2c 20 04 sll %l0, 4, %g1
2003b9c: 85 28 a0 06 sll %g2, 6, %g2
2003ba0: 82 21 00 01 sub %g4, %g1, %g1
2003ba4: 84 20 80 03 sub %g2, %g3, %g2
2003ba8: c8 06 80 01 ld [ %i2 + %g1 ], %g4
2003bac: 84 06 80 02 add %i2, %g2, %g2
2003bb0: c6 00 a0 04 ld [ %g2 + 4 ], %g3
2003bb4: 84 06 80 01 add %i2, %g1, %g2
2003bb8: 82 21 00 03 sub %g4, %g3, %g1
2003bbc: 80 a7 00 01 cmp %i4, %g1
2003bc0: 18 bf ff d5 bgu 2003b14 <rtems_bdpart_write+0x144> <== NEVER TAKEN
2003bc4: 82 10 00 10 mov %l0, %g1
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
2003bc8: 10 80 00 09 b 2003bec <rtems_bdpart_write+0x21c>
2003bcc: 82 00 60 01 inc %g1
if ((pt [i].begin - pt [i - 1].end) < record_space) {
2003bd0: c8 00 e0 30 ld [ %g3 + 0x30 ], %g4
2003bd4: c6 00 e0 04 ld [ %g3 + 4 ], %g3
2003bd8: 86 21 00 03 sub %g4, %g3, %g3
2003bdc: 80 a7 00 03 cmp %i4, %g3
2003be0: 18 bf ff cd bgu 2003b14 <rtems_bdpart_write+0x144> <== NEVER TAKEN
2003be4: 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) {
2003be8: 82 00 60 01 inc %g1
2003bec: 80 a6 c0 01 cmp %i3, %g1
2003bf0: 18 bf ff f8 bgu 2003bd0 <rtems_bdpart_write+0x200>
2003bf4: 86 10 00 02 mov %g2, %g3
2003bf8: ba 10 00 1a mov %i2, %i5
2003bfc: b0 10 20 00 clr %i0
2003c00: 10 80 00 0c b 2003c30 <rtems_bdpart_write+0x260>
2003c04: a4 07 bf ef add %fp, -17, %l2
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2003c08: 80 a0 60 00 cmp %g1, 0
2003c0c: 12 80 00 10 bne 2003c4c <rtems_bdpart_write+0x27c> <== NEVER TAKEN
2003c10: b0 06 20 01 inc %i0
2003c14: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2003c18: 80 a0 60 ff cmp %g1, 0xff
2003c1c: 18 80 00 0c bgu 2003c4c <rtems_bdpart_write+0x27c> <== NEVER TAKEN
2003c20: ba 07 60 30 add %i5, 0x30, %i5
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
2003c24: 80 a6 00 1b cmp %i0, %i3
2003c28: 02 80 00 0b be 2003c54 <rtems_bdpart_write+0x284>
2003c2c: d0 07 bf fc ld [ %fp + -4 ], %o0
uint8_t type = 0;
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
2003c30: 90 07 60 08 add %i5, 8, %o0
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
2003c34: c0 2f bf ef clrb [ %fp + -17 ]
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
2003c38: 7f ff fd ee call 20033f0 <rtems_bdpart_to_mbr_partition_type>
2003c3c: 92 10 00 12 mov %l2, %o1
2003c40: 80 8a 20 ff btst 0xff, %o0
2003c44: 32 bf ff f1 bne,a 2003c08 <rtems_bdpart_write+0x238> <== ALWAYS TAKEN
2003c48: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2003c4c: 10 bf ff b3 b 2003b18 <rtems_bdpart_write+0x148> <== NOT EXECUTED
2003c50: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
2003c54: 92 10 20 00 clr %o1
2003c58: 7f ff ff 3a call 2003940 <rtems_bdpart_new_record>
2003c5c: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003c60: b0 92 20 00 orcc %o0, 0, %i0
2003c64: 12 bf ff ae bne 2003b1c <rtems_bdpart_write+0x14c> <== NEVER TAKEN
2003c68: d0 07 bf f8 ld [ %fp + -8 ], %o0
}
/* Write disk ID */
rtems_uint32_to_little_endian(
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2003c6c: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
2003c70: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2003c74: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
2003c78: 82 00 e1 b8 add %g3, 0x1b8, %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003c7c: 86 00 e1 bc add %g3, 0x1bc, %g3
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
2003c80: c4 28 40 00 stb %g2, [ %g1 ]
2003c84: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003c88: 80 a0 40 03 cmp %g1, %g3
2003c8c: 12 bf ff fd bne 2003c80 <rtems_bdpart_write+0x2b0>
2003c90: 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;
2003c94: c2 07 bf f0 ld [ %fp + -16 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003c98: 9f 2c 20 04 sll %l0, 4, %o7
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;
2003c9c: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003ca0: 99 2c 20 06 sll %l0, 6, %o4
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;
2003ca4: 9a 01 21 be add %g4, 0x1be, %o5
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003ca8: 98 23 00 0f sub %o4, %o7, %o4
2003cac: 88 01 21 ca add %g4, 0x1ca, %g4
2003cb0: b0 06 80 0c add %i2, %o4, %i0
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
data,
p->begin,
p->end - p->begin,
2003cb4: c4 04 40 00 ld [ %l1 ], %g2
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2003cb8: c6 04 60 04 ld [ %l1 + 4 ], %g3
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
2003cbc: f2 0c 60 08 ldub [ %l1 + 8 ], %i1
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2003cc0: fa 0c 60 2f ldub [ %l1 + 0x2f ], %i5
2003cc4: 86 20 c0 02 sub %g3, %g2, %g3
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003cc8: 82 01 3f fc add %g4, -4, %g1
data [i] = (uint8_t) value;
2003ccc: c4 28 40 00 stb %g2, [ %g1 ]
2003cd0: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003cd4: 80 a1 00 01 cmp %g4, %g1
2003cd8: 12 bf ff fd bne 2003ccc <rtems_bdpart_write+0x2fc>
2003cdc: 85 30 a0 08 srl %g2, 8, %g2
2003ce0: 84 01 20 04 add %g4, 4, %g2
2003ce4: 82 10 00 04 mov %g4, %g1
data [i] = (uint8_t) value;
2003ce8: c6 28 40 00 stb %g3, [ %g1 ]
2003cec: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003cf0: 80 a0 40 02 cmp %g1, %g2
2003cf4: 12 bf ff fd bne 2003ce8 <rtems_bdpart_write+0x318>
2003cf8: 87 30 e0 08 srl %g3, 8, %g3
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2003cfc: f2 29 3f f8 stb %i1, [ %g4 + -8 ]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2003d00: fa 29 3f f4 stb %i5, [ %g4 + -12 ]
2003d04: a2 04 60 30 add %l1, 0x30, %l1
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) {
2003d08: 80 a4 40 18 cmp %l1, %i0
2003d0c: 12 bf ff ea bne 2003cb4 <rtems_bdpart_write+0x2e4>
2003d10: 88 01 20 10 add %g4, 0x10, %g4
2003d14: 84 03 40 0f add %o5, %o7, %g2
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2003d18: 80 a4 00 1b cmp %l0, %i3
2003d1c: 02 bf ff 7f be 2003b18 <rtems_bdpart_write+0x148> <== NEVER TAKEN
2003d20: b0 10 20 00 clr %i0
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
2003d24: fa 06 80 0c ld [ %i2 + %o4 ], %i5
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2003d28: c6 07 bf f4 ld [ %fp + -12 ], %g3
/* 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;
2003d2c: ba 27 40 1c sub %i5, %i4, %i5
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
2003d30: 82 00 a0 08 add %g2, 8, %g1
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2003d34: 86 20 c0 1d sub %g3, %i5, %g3
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003d38: b2 00 a0 0c add %g2, 0xc, %i1
2003d3c: 88 10 00 1d mov %i5, %g4
data [i] = (uint8_t) value;
2003d40: c8 28 40 00 stb %g4, [ %g1 ]
2003d44: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003d48: 80 a0 40 19 cmp %g1, %i1
2003d4c: 12 bf ff fd bne 2003d40 <rtems_bdpart_write+0x370>
2003d50: 89 31 20 08 srl %g4, 8, %g4
2003d54: 88 00 a0 10 add %g2, 0x10, %g4
data [i] = (uint8_t) value;
2003d58: c6 28 40 00 stb %g3, [ %g1 ]
2003d5c: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003d60: 80 a0 40 04 cmp %g1, %g4
2003d64: 12 bf ff fd bne 2003d58 <rtems_bdpart_write+0x388>
2003d68: 87 30 e0 08 srl %g3, 8, %g3
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2003d6c: 82 10 20 05 mov 5, %g1
2003d70: c2 28 a0 04 stb %g1, [ %g2 + 4 ]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2003d74: 80 a4 00 1b cmp %l0, %i3
2003d78: 1a 80 00 44 bcc 2003e88 <rtems_bdpart_write+0x4b8> <== NEVER TAKEN
2003d7c: c0 2b 40 0f clrb [ %o5 + %o7 ]
2003d80: a4 04 20 01 add %l0, 1, %l2
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2003d84: b2 10 20 05 mov 5, %i1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003d88: 83 2c a0 04 sll %l2, 4, %g1
2003d8c: 85 2c a0 06 sll %l2, 6, %g2
2003d90: 82 20 80 01 sub %g2, %g1, %g1
2003d94: b4 06 80 01 add %i2, %g1, %i2
0
);
}
/* New EBR */
ebr = p->begin - record_space;
2003d98: d2 04 40 00 ld [ %l1 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
2003d9c: d0 07 bf fc ld [ %fp + -4 ], %o0
2003da0: 92 22 40 1c sub %o1, %i4, %o1
2003da4: 7f ff fe e7 call 2003940 <rtems_bdpart_new_record>
2003da8: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003dac: 80 a2 20 00 cmp %o0, 0
2003db0: 12 80 00 34 bne 2003e80 <rtems_bdpart_write+0x4b0> <== NEVER TAKEN
2003db4: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2003db8: c4 04 60 04 ld [ %l1 + 4 ], %g2
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
2003dbc: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2003dc0: c2 04 40 00 ld [ %l1 ], %g1
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
2003dc4: de 0c 60 08 ldub [ %l1 + 8 ], %o7
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2003dc8: f0 0c 60 2f ldub [ %l1 + 0x2f ], %i0
2003dcc: 84 20 80 01 sub %g2, %g1, %g2
data [i] = (uint8_t) value;
2003dd0: f8 28 e1 c6 stb %i4, [ %g3 + 0x1c6 ]
2003dd4: c0 28 e1 c7 clrb [ %g3 + 0x1c7 ]
2003dd8: c0 28 e1 c8 clrb [ %g3 + 0x1c8 ]
2003ddc: c0 28 e1 c9 clrb [ %g3 + 0x1c9 ]
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
2003de0: 88 00 e1 ca add %g3, 0x1ca, %g4
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003de4: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
2003de8: c4 29 00 01 stb %g2, [ %g4 + %g1 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003dec: 82 00 60 01 inc %g1
2003df0: 80 a0 60 04 cmp %g1, 4
2003df4: 12 bf ff fd bne 2003de8 <rtems_bdpart_write+0x418>
2003df8: 85 30 a0 08 srl %g2, 8, %g2
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2003dfc: de 28 e1 c2 stb %o7, [ %g3 + 0x1c2 ]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2003e00: 80 a4 80 1b cmp %l2, %i3
2003e04: 02 80 00 21 be 2003e88 <rtems_bdpart_write+0x4b8>
2003e08: f0 28 e1 be stb %i0, [ %g3 + 0x1be ]
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
2003e0c: 80 a4 00 12 cmp %l0, %l2
2003e10: 1a 80 00 19 bcc 2003e74 <rtems_bdpart_write+0x4a4> <== NEVER TAKEN
2003e14: a2 10 00 1a mov %i2, %l1
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
2003e18: c4 07 bf f0 ld [ %fp + -16 ], %g2
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
2003e1c: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
2003e20: f0 00 a0 1c ld [ %g2 + 0x1c ], %i0
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
2003e24: c4 07 bf f4 ld [ %fp + -12 ], %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;
2003e28: 82 20 40 1c sub %g1, %i4, %g1
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
2003e2c: 88 06 21 d6 add %i0, 0x1d6, %g4
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
2003e30: 86 20 40 1d sub %g1, %i5, %g3
2003e34: 84 20 80 01 sub %g2, %g1, %g2
2003e38: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
2003e3c: c6 29 00 01 stb %g3, [ %g4 + %g1 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003e40: 82 00 60 01 inc %g1
2003e44: 80 a0 60 04 cmp %g1, 4
2003e48: 12 bf ff fd bne 2003e3c <rtems_bdpart_write+0x46c>
2003e4c: 87 30 e0 08 srl %g3, 8, %g3
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
2003e50: 86 06 21 da add %i0, 0x1da, %g3
2003e54: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
2003e58: c4 28 c0 01 stb %g2, [ %g3 + %g1 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003e5c: 82 00 60 01 inc %g1
2003e60: 80 a0 60 04 cmp %g1, 4
2003e64: 12 bf ff fd bne 2003e58 <rtems_bdpart_write+0x488>
2003e68: 85 30 a0 08 srl %g2, 8, %g2
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2003e6c: f2 2e 21 d2 stb %i1, [ %i0 + 0x1d2 ]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2003e70: c0 2e 21 ce clrb [ %i0 + 0x1ce ]
2003e74: a4 04 a0 01 inc %l2
2003e78: 10 bf ff c8 b 2003d98 <rtems_bdpart_write+0x3c8>
2003e7c: b4 06 a0 30 add %i2, 0x30, %i2
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
if (sc != RTEMS_SUCCESSFUL) {
2003e80: 10 bf ff 26 b 2003b18 <rtems_bdpart_write+0x148> <== NOT EXECUTED
2003e84: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2003e88: 10 bf ff 24 b 2003b18 <rtems_bdpart_write+0x148>
2003e8c: b0 10 20 00 clr %i0
0200391c <rtems_blkdev_create_partition>:
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
200391c: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
2003920: 92 10 20 02 mov 2, %o1
2003924: 90 10 00 19 mov %i1, %o0
2003928: 40 00 0a 49 call 200624c <open>
200392c: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
}
} else {
sc = RTEMS_INVALID_ID;
2003930: b0 10 20 04 mov 4, %i0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
if (fd >= 0) {
2003934: 80 a2 20 00 cmp %o0, 0
2003938: 06 80 00 0a bl 2003960 <rtems_blkdev_create_partition+0x44>
200393c: ba 10 00 08 mov %o0, %i5
int rv;
struct stat st;
rv = fstat(fd, &st);
2003940: 40 00 06 99 call 20053a4 <fstat>
2003944: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
2003948: 80 a2 20 00 cmp %o0, 0
200394c: 02 80 00 07 be 2003968 <rtems_blkdev_create_partition+0x4c><== ALWAYS TAKEN
2003950: f2 07 bf c4 ld [ %fp + -60 ], %i1
2003954: b0 10 20 15 mov 0x15, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
2003958: 40 00 05 ad call 200500c <close>
200395c: 90 10 00 1d mov %i5, %o0
2003960: 81 c7 e0 08 ret
2003964: 81 e8 00 00 restore
if (fd >= 0) {
int rv;
struct stat st;
rv = fstat(fd, &st);
if (rv == 0 && S_ISBLK(st.st_mode)) {
2003968: 03 00 00 3c sethi %hi(0xf000), %g1
200396c: b2 0e 40 01 and %i1, %g1, %i1
2003970: 03 00 00 18 sethi %hi(0x6000), %g1
2003974: 80 a6 40 01 cmp %i1, %g1
2003978: 12 bf ff f8 bne 2003958 <rtems_blkdev_create_partition+0x3c>
200397c: b0 10 20 15 mov 0x15, %i0
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
2003980: 90 10 00 1d mov %i5, %o0
2003984: 94 07 bf b4 add %fp, -76, %o2
2003988: 13 10 01 10 sethi %hi(0x40044000), %o1
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_NOT_IMPLEMENTED;
200398c: b0 10 20 18 mov 0x18, %i0
2003990: 40 00 06 db call 20054fc <ioctl>
2003994: 92 12 62 09 or %o1, 0x209, %o1
rv = fstat(fd, &st);
if (rv == 0 && S_ISBLK(st.st_mode)) {
rtems_disk_device *phys_dd;
rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
if (rv == 0) {
2003998: 80 a2 20 00 cmp %o0, 0
200399c: 12 bf ff ef bne 2003958 <rtems_blkdev_create_partition+0x3c>
20039a0: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
20039a4: 40 00 07 f3 call 2005970 <malloc>
20039a8: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
20039ac: a0 92 20 00 orcc %o0, 0, %l0
20039b0: 02 80 00 17 be 2003a0c <rtems_blkdev_create_partition+0xf0>
20039b4: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
20039b8: 94 10 00 1a mov %i2, %o2
20039bc: 40 00 00 96 call 2003c14 <rtems_disk_init_log>
20039c0: 96 10 00 1b mov %i3, %o3
phys_dd,
media_block_begin,
media_block_count
);
if (sc == RTEMS_SUCCESSFUL) {
20039c4: b0 92 20 00 orcc %o0, 0, %i0
20039c8: 12 80 00 0e bne 2003a00 <rtems_blkdev_create_partition+0xe4>
20039cc: 90 10 00 1c mov %i4, %o0
ctx->fd = fd;
20039d0: fa 24 20 78 st %i5, [ %l0 + 0x78 ]
rv = IMFS_make_generic_node(
20039d4: 92 16 61 ff or %i1, 0x1ff, %o1
20039d8: 96 10 00 10 mov %l0, %o3
20039dc: 15 00 80 82 sethi %hi(0x2020800), %o2
20039e0: 40 00 03 cb call 200490c <IMFS_make_generic_node>
20039e4: 94 12 a0 30 or %o2, 0x30, %o2 ! 2020830 <rtems_blkdev_imfs_control>
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
20039e8: 80 a2 20 00 cmp %o0, 0
20039ec: 02 bf ff dd be 2003960 <rtems_blkdev_create_partition+0x44>
20039f0: 90 10 00 10 mov %l0, %o0
free(ctx);
20039f4: 40 00 06 42 call 20052fc <free>
20039f8: b0 10 20 0d mov 0xd, %i0
20039fc: 30 bf ff d7 b,a 2003958 <rtems_blkdev_create_partition+0x3c>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
2003a00: 40 00 06 3f call 20052fc <free>
2003a04: 90 10 00 10 mov %l0, %o0
2003a08: 30 bf ff d4 b,a 2003958 <rtems_blkdev_create_partition+0x3c>
}
} else {
sc = RTEMS_NO_MEMORY;
2003a0c: 10 bf ff d3 b 2003958 <rtems_blkdev_create_partition+0x3c>
2003a10: b0 10 20 1a mov 0x1a, %i0
0200ff2c <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)
{
200ff2c: 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;
200ff30: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
200ff34: 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;
200ff38: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
200ff3c: 03 30 06 10 sethi %hi(0xc0184000), %g1
200ff40: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
200ff44: 80 a2 40 01 cmp %o1, %g1
200ff48: 12 80 00 05 bne 200ff5c <rtems_blkdev_generic_ioctl+0x30> <== ALWAYS TAKEN
200ff4c: 82 10 3f ff mov -1, %g1
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
200ff50: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
200ff54: 81 c7 e0 08 ret <== NOT EXECUTED
200ff58: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
if (args->command != RTEMS_BLKIO_REQUEST)
{
args->ioctl_return = dd->ioctl(dd,
200ff5c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
200ff60: d4 06 a0 08 ld [ %i2 + 8 ], %o2
200ff64: 9f c0 40 00 call %g1
200ff68: b0 10 20 00 clr %i0
200ff6c: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
*/
args->ioctl_return = -1;
}
return RTEMS_SUCCESSFUL;
}
200ff70: 81 c7 e0 08 ret
200ff74: 81 e8 00 00 restore
0200fce8 <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)
{
200fce8: 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;
200fcec: 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);
200fcf0: 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;
200fcf4: e4 00 60 30 ld [ %g1 + 0x30 ], %l2
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200fcf8: 94 10 20 00 clr %o2
{
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;
200fcfc: e2 04 a0 24 ld [ %l2 + 0x24 ], %l1
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200fd00: 90 10 00 1c mov %i4, %o0
200fd04: 96 10 00 11 mov %l1, %o3
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;
200fd08: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200fd0c: 40 00 38 3e call 201de04 <__divdi3>
200fd10: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200fd14: 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);
200fd18: b2 10 00 09 mov %o1, %i1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200fd1c: 94 10 20 00 clr %o2
200fd20: 92 10 00 1d mov %i5, %o1
200fd24: 40 00 39 23 call 201e1b0 <__moddi3>
200fd28: 96 10 00 11 mov %l1, %o3
args->bytes_moved = 0;
200fd2c: c0 26 a0 1c clr [ %i2 + 0x1c ]
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200fd30: a0 10 00 09 mov %o1, %l0
args->bytes_moved = 0;
while (count > 0)
200fd34: 80 a6 e0 00 cmp %i3, 0
200fd38: 12 80 00 1a bne 200fda0 <rtems_blkdev_generic_read+0xb8> <== ALWAYS TAKEN
200fd3c: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
200fd40: 81 c7 e0 08 ret <== NOT EXECUTED
200fd44: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
200fd48: ba 24 40 10 sub %l1, %l0, %i5
200fd4c: 80 a7 40 1b cmp %i5, %i3
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
200fd50: 08 80 00 03 bleu 200fd5c <rtems_blkdev_generic_read+0x74> <== ALWAYS TAKEN
200fd54: c2 07 bf fc ld [ %fp + -4 ], %g1
200fd58: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
200fd5c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
200fd60: 94 10 00 1d mov %i5, %o2
200fd64: 40 00 15 ac call 2015414 <memcpy>
200fd68: 92 02 40 10 add %o1, %l0, %o1
rc = rtems_bdbuf_release(diskbuf);
200fd6c: d0 07 bf fc ld [ %fp + -4 ], %o0
200fd70: 7f ff fd e9 call 200f514 <rtems_bdbuf_release>
200fd74: b8 07 00 1d add %i4, %i5, %i4
args->bytes_moved += copy;
200fd78: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
200fd7c: b0 10 00 08 mov %o0, %i0
args->bytes_moved += copy;
200fd80: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
200fd84: 80 a2 20 00 cmp %o0, 0
200fd88: 12 80 00 0e bne 200fdc0 <rtems_blkdev_generic_read+0xd8> <== NEVER TAKEN
200fd8c: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
200fd90: b2 06 60 01 inc %i1
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)
200fd94: b6 a6 c0 1d subcc %i3, %i5, %i3
200fd98: 02 80 00 0c be 200fdc8 <rtems_blkdev_generic_read+0xe0> <== ALWAYS TAKEN
200fd9c: a0 10 20 00 clr %l0
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200fda0: 92 10 00 19 mov %i1, %o1
200fda4: 94 07 bf fc add %fp, -4, %o2
200fda8: 7f ff fd 56 call 200f300 <rtems_bdbuf_read>
200fdac: 90 10 00 12 mov %l2, %o0
200fdb0: b0 10 00 08 mov %o0, %i0
if (rc != RTEMS_SUCCESSFUL)
200fdb4: 80 a6 20 00 cmp %i0, 0
200fdb8: 02 bf ff e4 be 200fd48 <rtems_blkdev_generic_read+0x60> <== ALWAYS TAKEN
200fdbc: 90 10 00 1c mov %i4, %o0
blkofs = 0;
block++;
}
return rc;
}
200fdc0: 81 c7 e0 08 ret <== NOT EXECUTED
200fdc4: 81 e8 00 00 restore <== NOT EXECUTED
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
200fdc8: b0 10 20 00 clr %i0
200fdcc: 81 c7 e0 08 ret
200fdd0: 81 e8 00 00 restore
0200fdd4 <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)
{
200fdd4: 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;
200fdd8: 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);
200fddc: 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;
200fde0: e2 00 60 30 ld [ %g1 + 0x30 ], %l1
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200fde4: 94 10 20 00 clr %o2
{
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;
200fde8: e0 04 60 24 ld [ %l1 + 0x24 ], %l0
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200fdec: 90 10 00 1c mov %i4, %o0
200fdf0: 96 10 00 10 mov %l0, %o3
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;
200fdf4: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200fdf8: 40 00 38 03 call 201de04 <__divdi3>
200fdfc: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200fe00: 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);
200fe04: b0 10 00 09 mov %o1, %i0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200fe08: 94 10 20 00 clr %o2
200fe0c: 92 10 00 1d mov %i5, %o1
200fe10: 40 00 38 e8 call 201e1b0 <__moddi3>
200fe14: 96 10 00 10 mov %l0, %o3
args->bytes_moved = 0;
200fe18: c0 26 a0 1c clr [ %i2 + 0x1c ]
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200fe1c: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
while (count > 0)
200fe20: 80 a6 e0 00 cmp %i3, 0
200fe24: 12 80 00 21 bne 200fea8 <rtems_blkdev_generic_write+0xd4> <== ALWAYS TAKEN
200fe28: f2 06 a0 10 ld [ %i2 + 0x10 ], %i1
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
200fe2c: 10 80 00 2c b 200fedc <rtems_blkdev_generic_write+0x108> <== NOT EXECUTED
200fe30: 90 10 20 00 clr %o0 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
200fe34: 12 80 00 21 bne 200feb8 <rtems_blkdev_generic_write+0xe4> <== NEVER TAKEN
200fe38: 92 10 00 18 mov %i0, %o1
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200fe3c: 90 10 00 11 mov %l1, %o0
200fe40: 7f ff fc f0 call 200f200 <rtems_bdbuf_get>
200fe44: 94 07 bf fc add %fp, -4, %o2
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
200fe48: 80 a2 20 00 cmp %o0, 0
200fe4c: 12 80 00 21 bne 200fed0 <rtems_blkdev_generic_write+0xfc> <== NEVER TAKEN
200fe50: 92 10 00 19 mov %i1, %o1
break;
copy = block_size - blkofs;
200fe54: ba 24 00 1c sub %l0, %i4, %i5
200fe58: 80 a7 40 1b cmp %i5, %i3
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
200fe5c: 08 80 00 03 bleu 200fe68 <rtems_blkdev_generic_write+0x94><== ALWAYS TAKEN
200fe60: c2 07 bf fc ld [ %fp + -4 ], %g1
200fe64: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
200fe68: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
200fe6c: 94 10 00 1d mov %i5, %o2
200fe70: 40 00 15 69 call 2015414 <memcpy>
200fe74: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
200fe78: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
200fe7c: 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;
200fe80: 82 00 40 1d add %g1, %i5, %g1
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
200fe84: b2 06 40 1d add %i1, %i5, %i1
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
args->bytes_moved += copy;
rc = rtems_bdbuf_release_modified(diskbuf);
200fe88: 7f ff fd db call 200f5f4 <rtems_bdbuf_release_modified>
200fe8c: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
200fe90: 80 a2 20 00 cmp %o0, 0
200fe94: 12 80 00 0f bne 200fed0 <rtems_blkdev_generic_write+0xfc> <== NEVER TAKEN
200fe98: b6 a6 c0 1d subcc %i3, %i5, %i3
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
200fe9c: b0 06 20 01 inc %i0
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)
200fea0: 02 80 00 0e be 200fed8 <rtems_blkdev_generic_write+0x104> <== ALWAYS TAKEN
200fea4: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
200fea8: 80 a6 c0 10 cmp %i3, %l0
200feac: 1a bf ff e2 bcc 200fe34 <rtems_blkdev_generic_write+0x60> <== ALWAYS TAKEN
200feb0: 80 a7 20 00 cmp %i4, 0
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200feb4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
200feb8: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
200febc: 7f ff fd 11 call 200f300 <rtems_bdbuf_read> <== NOT EXECUTED
200fec0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
200fec4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200fec8: 02 bf ff e3 be 200fe54 <rtems_blkdev_generic_write+0x80> <== NOT EXECUTED
200fecc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
200fed0: 81 c7 e0 08 ret <== NOT EXECUTED
200fed4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
200fed8: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200fedc: 81 c7 e0 08 ret
200fee0: 91 e8 00 08 restore %g0, %o0, %o0
020037f8 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
20037f8: 9d e3 bf a0 save %sp, -96, %sp
20037fc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv = 0;
2003800: b0 10 20 00 clr %i0
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
rtems_status_code sc = rtems_bdbuf_syncdev(dd);
2003804: 40 00 32 eb call 20103b0 <rtems_bdbuf_syncdev>
2003808: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
200380c: 80 a2 20 00 cmp %o0, 0
2003810: 12 80 00 04 bne 2003820 <rtems_blkdev_imfs_fsync_or_fdatasync+0x28><== NEVER TAKEN
2003814: 01 00 00 00 nop
errno = EIO;
rv = -1;
}
return rv;
}
2003818: 81 c7 e0 08 ret
200381c: 81 e8 00 00 restore
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
rtems_status_code sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
errno = EIO;
2003820: 40 00 46 47 call 201513c <__errno> <== NOT EXECUTED
2003824: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003828: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
200382c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003830: 81 c7 e0 08 ret <== NOT EXECUTED
2003834: 81 e8 00 00 restore <== NOT EXECUTED
02003838 <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
2003838: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
200383c: 03 30 06 10 sethi %hi(0xc0184000), %g1
2003840: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
2003844: 80 a6 40 01 cmp %i1, %g1
2003848: 02 80 00 09 be 200386c <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
200384c: 92 10 00 19 mov %i1, %o1
2003850: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
2003854: 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);
2003858: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
200385c: 9f c0 40 00 call %g1
2003860: 94 10 00 1a mov %i2, %o2
2003864: 81 c7 e0 08 ret
2003868: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
200386c: 40 00 46 34 call 201513c <__errno> <== NOT EXECUTED
2003870: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003874: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003878: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
200387c: 81 c7 e0 08 ret <== NOT EXECUTED
2003880: 81 e8 00 00 restore <== NOT EXECUTED
0200366c <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
200366c: 9d e3 bf 98 save %sp, -104, %sp
2003670: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
2003674: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
2003678: 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);
200367c: 92 10 00 1d mov %i5, %o1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
2003680: e4 04 60 24 ld [ %l1 + 0x24 ], %l2
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003684: 90 10 00 1c mov %i4, %o0
2003688: a1 3c a0 1f sra %l2, 0x1f, %l0
200368c: 96 10 00 12 mov %l2, %o3
2003690: 40 00 6b d9 call 201e5f4 <__divdi3>
2003694: 94 10 00 10 mov %l0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003698: 94 10 00 10 mov %l0, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
200369c: b6 10 00 09 mov %o1, %i3
ssize_t block_offset = (ssize_t) (offset % block_size);
20036a0: 90 10 00 1c mov %i4, %o0
20036a4: 92 10 00 1d mov %i5, %o1
20036a8: 40 00 6c be call 201e9a0 <__moddi3>
20036ac: 96 10 00 12 mov %l2, %o3
char *dst = buffer;
while (remaining > 0) {
20036b0: ba 96 a0 00 orcc %i2, 0, %i5
20036b4: 04 80 00 23 ble 2003740 <rtems_blkdev_imfs_read+0xd4> <== NEVER TAKEN
20036b8: a0 10 00 09 mov %o1, %l0
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
20036bc: 92 10 00 1b mov %i3, %o1
20036c0: 94 07 bf fc add %fp, -4, %o2
20036c4: 40 00 32 0c call 200fef4 <rtems_bdbuf_read>
20036c8: 90 10 00 11 mov %l1, %o0
if (sc == RTEMS_SUCCESSFUL) {
20036cc: 80 a2 20 00 cmp %o0, 0
20036d0: 02 80 00 09 be 20036f4 <rtems_blkdev_imfs_read+0x88> <== ALWAYS TAKEN
20036d4: 90 10 00 19 mov %i1, %o0
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
20036d8: 40 00 46 99 call 201513c <__errno> <== NOT EXECUTED
20036dc: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
20036e0: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
20036e4: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
20036e8: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20036ec: 81 c7 e0 08 ret <== NOT EXECUTED
20036f0: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
while (remaining > 0) {
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
if (sc == RTEMS_SUCCESSFUL) {
ssize_t copy = block_size - block_offset;
20036f4: b8 24 80 10 sub %l2, %l0, %i4
20036f8: 80 a7 00 1d cmp %i4, %i5
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
20036fc: 04 80 00 03 ble 2003708 <rtems_blkdev_imfs_read+0x9c>
2003700: c2 07 bf fc ld [ %fp + -4 ], %g1
2003704: b8 10 00 1d mov %i5, %i4
2003708: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
200370c: 94 10 00 1c mov %i4, %o2
2003710: 40 00 49 06 call 2015b28 <memcpy>
2003714: 92 02 40 10 add %o1, %l0, %o1
sc = rtems_bdbuf_release(bd);
2003718: d0 07 bf fc ld [ %fp + -4 ], %o0
200371c: 40 00 32 7b call 2010108 <rtems_bdbuf_release>
2003720: ba 27 40 1c sub %i5, %i4, %i5
if (sc == RTEMS_SUCCESSFUL) {
2003724: 80 a2 20 00 cmp %o0, 0
2003728: 12 bf ff ec bne 20036d8 <rtems_blkdev_imfs_read+0x6c> <== NEVER TAKEN
200372c: 80 a7 60 00 cmp %i5, 0
block_offset = 0;
remaining -= copy;
dst += copy;
2003730: b2 06 40 1c add %i1, %i4, %i1
++block;
2003734: b6 06 e0 01 inc %i3
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) {
2003738: 14 bf ff e1 bg 20036bc <rtems_blkdev_imfs_read+0x50>
200373c: a0 10 20 00 clr %l0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
2003740: 80 a7 60 00 cmp %i5, 0
2003744: 12 bf ff e5 bne 20036d8 <rtems_blkdev_imfs_read+0x6c> <== NEVER TAKEN
2003748: 82 10 00 1a mov %i2, %g1
iop->offset += count;
200374c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
2003750: 86 80 c0 1a addcc %g3, %i2, %g3
2003754: 84 40 a0 00 addx %g2, 0, %g2
2003758: c4 3e 20 08 std %g2, [ %i0 + 8 ]
errno = EIO;
rv = -1;
}
return rv;
}
200375c: 81 c7 e0 08 ret
2003760: 91 e8 00 01 restore %g0, %g1, %o0
02003538 <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
2003538: 9d e3 bf 98 save %sp, -104, %sp
200353c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
2003540: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
2003544: 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);
2003548: 92 10 00 1d mov %i5, %o1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
200354c: f6 04 60 24 ld [ %l1 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003550: 90 10 00 1c mov %i4, %o0
2003554: a1 3e e0 1f sra %i3, 0x1f, %l0
2003558: 96 10 00 1b mov %i3, %o3
200355c: 40 00 6c 26 call 201e5f4 <__divdi3>
2003560: 94 10 00 10 mov %l0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003564: 94 10 00 10 mov %l0, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003568: a4 10 00 09 mov %o1, %l2
ssize_t block_offset = (ssize_t) (offset % block_size);
200356c: 90 10 00 1c mov %i4, %o0
2003570: 92 10 00 1d mov %i5, %o1
2003574: 40 00 6d 0b call 201e9a0 <__moddi3>
2003578: 96 10 00 1b mov %i3, %o3
const char *src = buffer;
while (remaining > 0) {
200357c: ba 96 a0 00 orcc %i2, 0, %i5
2003580: 04 80 00 2e ble 2003638 <rtems_blkdev_imfs_write+0x100> <== NEVER TAKEN
2003584: a0 10 00 09 mov %o1, %l0
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
2003588: 80 a7 40 1b cmp %i5, %i3
200358c: 16 80 00 03 bge 2003598 <rtems_blkdev_imfs_write+0x60>
2003590: 82 10 20 01 mov 1, %g1
2003594: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
2003598: 90 10 00 11 mov %l1, %o0
200359c: 92 10 00 12 mov %l2, %o1
while (remaining > 0) {
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
20035a0: 80 88 60 ff btst 0xff, %g1
20035a4: 02 80 00 2e be 200365c <rtems_blkdev_imfs_write+0x124>
20035a8: 94 07 bf fc add %fp, -4, %o2
20035ac: 80 a4 20 00 cmp %l0, 0
20035b0: 12 80 00 2b bne 200365c <rtems_blkdev_imfs_write+0x124>
20035b4: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
20035b8: 40 00 32 0f call 200fdf4 <rtems_bdbuf_get>
20035bc: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
20035c0: 80 a2 20 00 cmp %o0, 0
20035c4: 02 80 00 09 be 20035e8 <rtems_blkdev_imfs_write+0xb0> <== ALWAYS TAKEN
20035c8: b8 26 c0 10 sub %i3, %l0, %i4
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
20035cc: 40 00 46 dc call 201513c <__errno> <== NOT EXECUTED
20035d0: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
20035d4: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
20035d8: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
20035dc: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20035e0: 81 c7 e0 08 ret <== NOT EXECUTED
20035e4: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
20035e8: 80 a7 00 1d cmp %i4, %i5
20035ec: 34 80 00 02 bg,a 20035f4 <rtems_blkdev_imfs_write+0xbc>
20035f0: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
20035f4: c2 07 bf fc ld [ %fp + -4 ], %g1
20035f8: 92 10 00 19 mov %i1, %o1
20035fc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003600: 94 10 00 1c mov %i4, %o2
2003604: 40 00 49 49 call 2015b28 <memcpy>
2003608: 90 02 00 10 add %o0, %l0, %o0
sc = rtems_bdbuf_release_modified(bd);
200360c: 40 00 32 f7 call 20101e8 <rtems_bdbuf_release_modified>
2003610: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
2003614: 80 a2 20 00 cmp %o0, 0
2003618: 12 bf ff ed bne 20035cc <rtems_blkdev_imfs_write+0x94> <== NEVER TAKEN
200361c: 01 00 00 00 nop
block_offset = 0;
remaining -= copy;
2003620: ba 27 40 1c sub %i5, %i4, %i5
src += copy;
2003624: b2 06 40 1c add %i1, %i4, %i1
++block;
2003628: a4 04 a0 01 inc %l2
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) {
200362c: 80 a7 60 00 cmp %i5, 0
2003630: 14 bf ff d6 bg 2003588 <rtems_blkdev_imfs_write+0x50>
2003634: a0 10 20 00 clr %l0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
2003638: 80 a7 60 00 cmp %i5, 0
200363c: 12 bf ff e4 bne 20035cc <rtems_blkdev_imfs_write+0x94> <== NEVER TAKEN
2003640: 82 10 00 1a mov %i2, %g1
iop->offset += count;
2003644: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
2003648: 86 80 c0 1a addcc %g3, %i2, %g3
200364c: 84 40 a0 00 addx %g2, 0, %g2
2003650: c4 3e 20 08 std %g2, [ %i0 + 8 ]
errno = EIO;
rv = -1;
}
return rv;
}
2003654: 81 c7 e0 08 ret
2003658: 91 e8 00 01 restore %g0, %g1, %o0
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);
200365c: 40 00 32 26 call 200fef4 <rtems_bdbuf_read>
2003660: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
2003664: 10 bf ff d8 b 20035c4 <rtems_blkdev_imfs_write+0x8c>
2003668: 80 a2 20 00 cmp %o0, 0
0200fb78 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200fb78: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
200fb7c: 05 10 01 10 sethi %hi(0x40044000), %g2
200fb80: 82 10 a2 03 or %g2, 0x203, %g1 ! 40044203 <RAM_END+0x3dc44203>
200fb84: 80 a6 40 01 cmp %i1, %g1
200fb88: 22 80 00 55 be,a 200fcdc <rtems_blkdev_ioctl+0x164>
200fb8c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200fb90: 08 80 00 1c bleu 200fc00 <rtems_blkdev_ioctl+0x88>
200fb94: 03 08 00 10 sethi %hi(0x20004000), %g1
200fb98: 82 10 a2 09 or %g2, 0x209, %g1
200fb9c: 80 a6 40 01 cmp %i1, %g1
200fba0: 22 80 00 3c be,a 200fc90 <rtems_blkdev_ioctl+0x118>
200fba4: f0 26 80 00 st %i0, [ %i2 ]
200fba8: 28 80 00 27 bleu,a 200fc44 <rtems_blkdev_ioctl+0xcc>
200fbac: 84 10 a2 05 or %g2, 0x205, %g2
200fbb0: 84 10 a2 0b or %g2, 0x20b, %g2
200fbb4: 80 a6 40 02 cmp %i1, %g2
200fbb8: 02 80 00 3f be 200fcb4 <rtems_blkdev_ioctl+0x13c>
200fbbc: 03 20 01 10 sethi %hi(0x80044000), %g1
200fbc0: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <RAM_END+0x7dc44204>
200fbc4: 80 a6 40 01 cmp %i1, %g1
200fbc8: 12 80 00 22 bne 200fc50 <rtems_blkdev_ioctl+0xd8> <== NEVER TAKEN
200fbcc: 90 10 00 18 mov %i0, %o0
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
200fbd0: d2 06 80 00 ld [ %i2 ], %o1
200fbd4: 7f ff ff 8f call 200fa10 <rtems_bdbuf_set_block_size>
200fbd8: 94 10 20 01 mov 1, %o2
if (sc != RTEMS_SUCCESSFUL) {
200fbdc: 80 a2 20 00 cmp %o0, 0
200fbe0: 02 80 00 2a be 200fc88 <rtems_blkdev_ioctl+0x110> <== ALWAYS TAKEN
200fbe4: 01 00 00 00 nop
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
errno = EIO;
200fbe8: 40 00 13 ba call 2014ad0 <__errno> <== NOT EXECUTED
200fbec: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
200fbf0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
200fbf4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200fbf8: 81 c7 e0 08 ret <== NOT EXECUTED
200fbfc: 81 e8 00 00 restore <== NOT EXECUTED
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
200fc00: 86 10 62 0a or %g1, 0x20a, %g3
200fc04: 80 a6 40 03 cmp %i1, %g3
200fc08: 02 80 00 31 be 200fccc <rtems_blkdev_ioctl+0x154>
200fc0c: 90 10 00 18 mov %i0, %o0
200fc10: 28 80 00 16 bleu,a 200fc68 <rtems_blkdev_ioctl+0xf0>
200fc14: 82 10 62 06 or %g1, 0x206, %g1
200fc18: 82 10 62 0c or %g1, 0x20c, %g1
200fc1c: 80 a6 40 01 cmp %i1, %g1
200fc20: 02 80 00 21 be 200fca4 <rtems_blkdev_ioctl+0x12c>
200fc24: 84 10 a2 02 or %g2, 0x202, %g2
200fc28: 80 a6 40 02 cmp %i1, %g2
200fc2c: 12 80 00 09 bne 200fc50 <rtems_blkdev_ioctl+0xd8> <== NEVER TAKEN
200fc30: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
200fc34: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
200fc38: c2 26 80 00 st %g1, [ %i2 ]
break;
200fc3c: 81 c7 e0 08 ret
200fc40: 91 e8 20 00 restore %g0, 0, %o0
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
200fc44: 80 a6 40 02 cmp %i1, %g2
200fc48: 22 80 00 14 be,a 200fc98 <rtems_blkdev_ioctl+0x120> <== ALWAYS TAKEN
200fc4c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
break;
default:
errno = EINVAL;
200fc50: 40 00 13 a0 call 2014ad0 <__errno>
200fc54: b0 10 3f ff mov -1, %i0
200fc58: 82 10 20 16 mov 0x16, %g1
200fc5c: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
break;
}
return rc;
}
200fc60: 81 c7 e0 08 ret
200fc64: 81 e8 00 00 restore
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
200fc68: 80 a6 40 01 cmp %i1, %g1
200fc6c: 12 bf ff f9 bne 200fc50 <rtems_blkdev_ioctl+0xd8>
200fc70: 01 00 00 00 nop
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
200fc74: 7f ff fe d2 call 200f7bc <rtems_bdbuf_syncdev>
200fc78: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL) {
200fc7c: 80 a2 20 00 cmp %o0, 0
200fc80: 12 bf ff da bne 200fbe8 <rtems_blkdev_ioctl+0x70> <== NEVER TAKEN
200fc84: 01 00 00 00 nop
}
break;
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
200fc88: 81 c7 e0 08 ret
200fc8c: 91 e8 20 00 restore %g0, 0, %o0
200fc90: 81 c7 e0 08 ret
200fc94: 91 e8 20 00 restore %g0, 0, %o0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200fc98: c2 26 80 00 st %g1, [ %i2 ]
break;
200fc9c: 81 c7 e0 08 ret
200fca0: 91 e8 20 00 restore %g0, 0, %o0
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
break;
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
200fca4: 7f ff ff ac call 200fb54 <rtems_bdbuf_reset_device_stats>
200fca8: b0 10 20 00 clr %i0
break;
200fcac: 81 c7 e0 08 ret
200fcb0: 81 e8 00 00 restore
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
200fcb4: 90 10 00 18 mov %i0, %o0
200fcb8: 92 10 00 1a mov %i2, %o1
200fcbc: 7f ff ff 9d call 200fb30 <rtems_bdbuf_get_device_stats>
200fcc0: b0 10 20 00 clr %i0
break;
200fcc4: 81 c7 e0 08 ret
200fcc8: 81 e8 00 00 restore
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
200fccc: 7f ff fe d3 call 200f818 <rtems_bdbuf_purge_dev>
200fcd0: b0 10 20 00 clr %i0
break;
200fcd4: 81 c7 e0 08 ret
200fcd8: 81 e8 00 00 restore
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
200fcdc: c2 26 80 00 st %g1, [ %i2 ]
break;
200fce0: 81 c7 e0 08 ret
200fce4: 91 e8 20 00 restore %g0, 0, %o0
02025b00 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
2025b00: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
2025b04: 92 10 20 00 clr %o1 <== NOT EXECUTED
2025b08: 7f ff 79 5f call 2004084 <open> <== NOT EXECUTED
2025b0c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
2025b10: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2025b14: 06 80 00 33 bl 2025be0 <rtems_blkstats+0xe0> <== NOT EXECUTED
2025b18: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
2025b1c: 40 00 07 02 call 2027724 <fstat> <== NOT EXECUTED
2025b20: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
2025b24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025b28: 12 80 00 39 bne 2025c0c <rtems_blkstats+0x10c> <== NOT EXECUTED
2025b2c: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
2025b30: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
2025b34: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
2025b38: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
2025b3c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2025b40: 02 80 00 19 be 2025ba4 <rtems_blkstats+0xa4> <== NOT EXECUTED
2025b44: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
}
}
} else {
fprintf(output, "error: not a block device\n");
2025b48: 11 00 81 76 sethi %hi(0x205d800), %o0 <== NOT EXECUTED
2025b4c: 90 12 21 10 or %o0, 0x110, %o0 ! 205d910 <RTEMS_BDPART_MBR_MASTER_TYPE+0x40><== NOT EXECUTED
2025b50: 94 10 20 1a mov 0x1a, %o2 <== NOT EXECUTED
2025b54: 40 00 60 44 call 203dc64 <fwrite> <== NOT EXECUTED
2025b58: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
}
rv = close(fd);
2025b5c: 40 00 06 6b call 2027508 <close> <== NOT EXECUTED
2025b60: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
2025b64: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025b68: 12 80 00 04 bne 2025b78 <rtems_blkstats+0x78> <== NOT EXECUTED
2025b6c: 01 00 00 00 nop <== NOT EXECUTED
2025b70: 81 c7 e0 08 ret <== NOT EXECUTED
2025b74: 81 e8 00 00 restore <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
2025b78: 40 00 58 bc call 203be68 <__errno> <== NOT EXECUTED
2025b7c: 01 00 00 00 nop <== NOT EXECUTED
2025b80: 40 00 74 61 call 2042d04 <strerror> <== NOT EXECUTED
2025b84: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2025b88: 13 00 81 76 sethi %hi(0x205d800), %o1 <== NOT EXECUTED
2025b8c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2025b90: 92 12 61 50 or %o1, 0x150, %o1 <== NOT EXECUTED
2025b94: 40 00 5b 78 call 203c974 <fprintf> <== NOT EXECUTED
2025b98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2025b9c: 81 c7 e0 08 ret <== NOT EXECUTED
2025ba0: 81 e8 00 00 restore <== NOT EXECUTED
int rv;
rv = fstat(fd, &st);
if (rv == 0) {
if (S_ISBLK(st.st_mode)) {
if (reset) {
2025ba4: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2025ba8: 12 80 00 23 bne 2025c34 <rtems_blkstats+0x134> <== NOT EXECUTED
2025bac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
2025bb0: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
2025bb4: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
2025bb8: 40 00 09 bf call 20282b4 <ioctl> <== NOT EXECUTED
2025bbc: 92 12 62 0b or %o1, 0x20b, %o1 ! 4004420b <RAM_END+0x3dc4420b><== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
2025bc0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025bc4: 12 80 00 2c bne 2025c74 <rtems_blkstats+0x174> <== NOT EXECUTED
2025bc8: 13 00 80 f2 sethi %hi(0x203c800), %o1 <== NOT EXECUTED
rtems_blkdev_print_stats(
2025bcc: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
2025bd0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2025bd4: 40 00 00 32 call 2025c9c <rtems_blkdev_print_stats> <== NOT EXECUTED
2025bd8: 92 12 61 74 or %o1, 0x174, %o1 <== NOT EXECUTED
2025bdc: 30 bf ff e0 b,a 2025b5c <rtems_blkstats+0x5c> <== NOT EXECUTED
rv = close(fd);
if (rv != 0) {
fprintf(output, "error: close device: %s\n", strerror(errno));
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
2025be0: 40 00 58 a2 call 203be68 <__errno> <== NOT EXECUTED
2025be4: 01 00 00 00 nop <== NOT EXECUTED
2025be8: 40 00 74 47 call 2042d04 <strerror> <== NOT EXECUTED
2025bec: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2025bf0: 13 00 81 76 sethi %hi(0x205d800), %o1 <== NOT EXECUTED
2025bf4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2025bf8: 92 12 61 70 or %o1, 0x170, %o1 <== NOT EXECUTED
2025bfc: 40 00 5b 5e call 203c974 <fprintf> <== NOT EXECUTED
2025c00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2025c04: 81 c7 e0 08 ret <== NOT EXECUTED
2025c08: 81 e8 00 00 restore <== NOT EXECUTED
}
} else {
fprintf(output, "error: not a block device\n");
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
2025c0c: 40 00 58 97 call 203be68 <__errno> <== NOT EXECUTED
2025c10: 01 00 00 00 nop <== NOT EXECUTED
2025c14: 40 00 74 3c call 2042d04 <strerror> <== NOT EXECUTED
2025c18: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2025c1c: 13 00 81 76 sethi %hi(0x205d800), %o1 <== NOT EXECUTED
2025c20: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2025c24: 92 12 61 30 or %o1, 0x130, %o1 <== NOT EXECUTED
2025c28: 40 00 5b 53 call 203c974 <fprintf> <== NOT EXECUTED
2025c2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2025c30: 30 bf ff cb b,a 2025b5c <rtems_blkstats+0x5c> <== NOT EXECUTED
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
2025c34: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
2025c38: 40 00 09 9f call 20282b4 <ioctl> <== NOT EXECUTED
2025c3c: 92 12 62 0c or %o1, 0x20c, %o1 ! 2000420c <RAM_END+0x1dc0420c><== NOT EXECUTED
rv = fstat(fd, &st);
if (rv == 0) {
if (S_ISBLK(st.st_mode)) {
if (reset) {
rv = rtems_disk_fd_reset_device_stats(fd);
if (rv != 0) {
2025c40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2025c44: 02 bf ff c6 be 2025b5c <rtems_blkstats+0x5c> <== NOT EXECUTED
2025c48: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
2025c4c: 40 00 58 87 call 203be68 <__errno> <== NOT EXECUTED
2025c50: 01 00 00 00 nop <== NOT EXECUTED
2025c54: 40 00 74 2c call 2042d04 <strerror> <== NOT EXECUTED
2025c58: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2025c5c: 13 00 81 76 sethi %hi(0x205d800), %o1 <== NOT EXECUTED
2025c60: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2025c64: 92 12 60 e0 or %o1, 0xe0, %o1 <== NOT EXECUTED
2025c68: 40 00 5b 43 call 203c974 <fprintf> <== NOT EXECUTED
2025c6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2025c70: 30 bf ff bb b,a 2025b5c <rtems_blkstats+0x5c> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
2025c74: 40 00 58 7d call 203be68 <__errno> <== NOT EXECUTED
2025c78: 01 00 00 00 nop <== NOT EXECUTED
2025c7c: 40 00 74 22 call 2042d04 <strerror> <== NOT EXECUTED
2025c80: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2025c84: 13 00 81 76 sethi %hi(0x205d800), %o1 <== NOT EXECUTED
2025c88: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2025c8c: 92 12 60 f8 or %o1, 0xf8, %o1 <== NOT EXECUTED
2025c90: 40 00 5b 39 call 203c974 <fprintf> <== NOT EXECUTED
2025c94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2025c98: 30 bf ff b1 b,a 2025b5c <rtems_blkstats+0x5c> <== NOT EXECUTED
02002e40 <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
2002e40: 9d e3 bf a0 save %sp, -96, %sp
const char *p;
if ( !name )
2002e44: 80 a6 20 00 cmp %i0, 0
2002e48: 02 80 00 36 be 2002f20 <rtems_bsp_cmdline_get_param+0xe0>
2002e4c: 80 a6 60 00 cmp %i1, 0
return NULL;
if ( !value )
2002e50: 02 80 00 34 be 2002f20 <rtems_bsp_cmdline_get_param+0xe0>
2002e54: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( !length )
2002e58: 22 80 00 33 be,a 2002f24 <rtems_bsp_cmdline_get_param+0xe4>
2002e5c: b2 10 20 00 clr %i1
return NULL;
value[0] = '\0';
2002e60: c0 2e 40 00 clrb [ %i1 ]
p = rtems_bsp_cmdline_get_param_raw( name );
2002e64: 40 00 00 32 call 2002f2c <rtems_bsp_cmdline_get_param_raw>
2002e68: 90 10 00 18 mov %i0, %o0
if ( !p )
2002e6c: 80 a2 20 00 cmp %o0, 0
2002e70: 22 80 00 2d be,a 2002f24 <rtems_bsp_cmdline_get_param+0xe4>
2002e74: b2 10 20 00 clr %i1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
2002e78: c6 0a 00 00 ldub [ %o0 ], %g3
2002e7c: 85 28 e0 18 sll %g3, 0x18, %g2
2002e80: 80 a0 a0 00 cmp %g2, 0
2002e84: 02 80 00 25 be 2002f18 <rtems_bsp_cmdline_get_param+0xd8> <== NEVER TAKEN
2002e88: 80 a6 a0 01 cmp %i2, 1
2002e8c: 02 80 00 23 be 2002f18 <rtems_bsp_cmdline_get_param+0xd8> <== NEVER TAKEN
2002e90: b4 06 bf ff add %i2, -1, %i2
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
2002e94: 82 10 20 00 clr %g1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
2002e98: 88 10 20 00 clr %g4
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
2002e9c: 10 80 00 12 b 2002ee4 <rtems_bsp_cmdline_get_param+0xa4>
2002ea0: ba 10 20 00 clr %i5
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
2002ea4: 32 80 00 06 bne,a 2002ebc <rtems_bsp_cmdline_get_param+0x7c>
2002ea8: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
2002eac: 80 a0 a0 20 cmp %g2, 0x20
2002eb0: 02 80 00 1a be 2002f18 <rtems_bsp_cmdline_get_param+0xd8>
2002eb4: 01 00 00 00 nop
break;
value[i++] = *p++;
2002eb8: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
2002ebc: 82 00 60 01 inc %g1
value[i] = '\0';
2002ec0: c0 2e 40 01 clrb [ %i1 + %g1 ]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
2002ec4: c6 0a 00 01 ldub [ %o0 + %g1 ], %g3
2002ec8: 85 28 e0 18 sll %g3, 0x18, %g2
2002ecc: 80 a0 a0 00 cmp %g2, 0
2002ed0: 02 80 00 12 be 2002f18 <rtems_bsp_cmdline_get_param+0xd8>
2002ed4: 88 10 00 01 mov %g1, %g4
2002ed8: 80 a0 40 1a cmp %g1, %i2
2002edc: 02 80 00 0f be 2002f18 <rtems_bsp_cmdline_get_param+0xd8>
2002ee0: 01 00 00 00 nop
if ( *p == '\"' ) {
2002ee4: 85 38 a0 18 sra %g2, 0x18, %g2
2002ee8: 80 a0 a0 22 cmp %g2, 0x22
2002eec: 12 bf ff ee bne 2002ea4 <rtems_bsp_cmdline_get_param+0x64>
2002ef0: 80 8f 60 01 btst 1, %i5
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
2002ef4: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
2002ef8: 82 00 60 01 inc %g1
value[i] = '\0';
2002efc: c0 2e 40 01 clrb [ %i1 + %g1 ]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
2002f00: c6 0a 00 01 ldub [ %o0 + %g1 ], %g3
if ( *p == '\"' ) {
quotes++;
2002f04: ba 07 60 01 inc %i5
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
2002f08: 85 28 e0 18 sll %g3, 0x18, %g2
2002f0c: 80 a0 a0 00 cmp %g2, 0
2002f10: 12 bf ff f2 bne 2002ed8 <rtems_bsp_cmdline_get_param+0x98><== ALWAYS TAKEN
2002f14: 88 10 00 01 mov %g1, %g4
return NULL;
copy_string( p, value, length );
return value;
}
2002f18: 81 c7 e0 08 ret
2002f1c: 91 e8 00 19 restore %g0, %i1, %o0
)
{
const char *p;
if ( !name )
return NULL;
2002f20: b2 10 20 00 clr %i1
return NULL;
copy_string( p, value, length );
return value;
}
2002f24: 81 c7 e0 08 ret
2002f28: 91 e8 00 19 restore %g0, %i1, %o0
020087d4 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
20087d4: 9d e3 bf 98 save %sp, -104, %sp
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
20087d8: 40 00 01 b3 call 2008ea4 <_Chain_Get>
20087dc: 90 10 00 18 mov %i0, %o0
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
20087e0: 92 10 20 00 clr %o1
20087e4: ba 10 00 08 mov %o0, %i5
20087e8: 94 10 00 1a mov %i2, %o2
20087ec: 90 10 00 19 mov %i1, %o0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
20087f0: 80 a7 60 00 cmp %i5, 0
20087f4: 12 80 00 0a bne 200881c <rtems_chain_get_with_wait+0x48>
20087f8: 96 07 bf fc add %fp, -4, %o3
) {
rtems_event_set out;
sc = rtems_event_receive(
20087fc: 7f ff fc df call 2007b78 <rtems_event_receive>
2008800: 01 00 00 00 nop
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
2008804: 80 a2 20 00 cmp %o0, 0
2008808: 02 bf ff f4 be 20087d8 <rtems_chain_get_with_wait+0x4> <== NEVER TAKEN
200880c: 01 00 00 00 nop
timeout,
&out
);
}
*node_ptr = node;
2008810: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
2008814: 81 c7 e0 08 ret
2008818: 91 e8 00 08 restore %g0, %o0, %o0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
200881c: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
2008820: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
2008824: 81 c7 e0 08 ret
2008828: 91 e8 00 08 restore %g0, %o0, %o0
02003998 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2003998: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
200399c: 80 a6 60 00 cmp %i1, 0
20039a0: 02 80 00 85 be 2003bb4 <rtems_cpu_usage_report_with_plugin+0x21c><== NEVER TAKEN
20039a4: 03 00 80 85 sethi %hi(0x2021400), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
20039a8: c0 27 bf e0 clr [ %fp + -32 ]
20039ac: c0 27 bf e4 clr [ %fp + -28 ]
}
}
}
#endif
(*print)(
20039b0: 90 10 00 18 mov %i0, %o0
* 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;
20039b4: f8 18 61 00 ldd [ %g1 + 0x100 ], %i4
}
}
}
#endif
(*print)(
20039b8: 13 00 80 77 sethi %hi(0x201dc00), %o1
20039bc: 2b 00 80 83 sethi %hi(0x2020c00), %l5
20039c0: 92 12 63 90 or %o1, 0x390, %o1
20039c4: aa 15 62 a8 or %l5, 0x2a8, %l5
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
20039c8: 25 00 80 78 sethi %hi(0x201e000), %l2
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
20039cc: 29 00 80 83 sethi %hi(0x2020c00), %l4
}
}
}
#endif
(*print)(
20039d0: 9f c6 40 00 call %i1
20039d4: 27 00 80 78 sethi %hi(0x201e000), %l3
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
20039d8: ac 05 60 0c add %l5, 0xc, %l6
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
20039dc: a4 14 a1 08 or %l2, 0x108, %l2
20039e0: a8 15 22 90 or %l4, 0x290, %l4
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
20039e4: a6 14 e1 20 or %l3, 0x120, %l3
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
20039e8: c2 05 40 00 ld [ %l5 ], %g1
20039ec: e2 00 60 04 ld [ %g1 + 4 ], %l1
if ( information ) {
20039f0: 80 a4 60 00 cmp %l1, 0
20039f4: 22 80 00 56 be,a 2003b4c <rtems_cpu_usage_report_with_plugin+0x1b4><== NEVER TAKEN
20039f8: aa 05 60 04 add %l5, 4, %l5 <== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
20039fc: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1
2003a00: 86 90 60 00 orcc %g1, 0, %g3
2003a04: 02 80 00 51 be 2003b48 <rtems_cpu_usage_report_with_plugin+0x1b0>
2003a08: a0 10 20 01 mov 1, %l0
the_thread = (Thread_Control *)information->local_table[ i ];
2003a0c: 10 80 00 2d b 2003ac0 <rtems_cpu_usage_report_with_plugin+0x128>
2003a10: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
2003a14: 90 07 bf d8 add %fp, -40, %o0
2003a18: 40 00 1a 1a call 200a280 <_TOD_Get_with_nanoseconds>
2003a1c: 92 10 00 14 mov %l4, %o1
2003a20: c4 1f bf d8 ldd [ %fp + -40 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003a24: 86 a0 c0 1d subcc %g3, %i5, %g3
2003a28: 84 60 80 1c subx %g2, %i4, %g2
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
2003a2c: 90 07 bf e8 add %fp, -24, %o0
2003a30: c4 3f bf e0 std %g2, [ %fp + -32 ]
2003a34: 92 07 bf e0 add %fp, -32, %o1
2003a38: 94 07 bf d0 add %fp, -48, %o2
2003a3c: 40 00 24 3f call 200cb38 <_Timestamp64_Divide>
2003a40: 96 07 bf d4 add %fp, -44, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
2003a44: f4 1f bf e8 ldd [ %fp + -24 ], %i2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003a48: 94 10 20 00 clr %o2
2003a4c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003a50: 90 10 00 1a mov %i2, %o0
2003a54: 96 12 e2 00 or %o3, 0x200, %o3
2003a58: 40 00 5f a0 call 201b8d8 <__divdi3>
2003a5c: 92 10 00 1b mov %i3, %o1
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003a60: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003a64: ae 10 00 09 mov %o1, %l7
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003a68: 90 10 00 1a mov %i2, %o0
2003a6c: 92 10 00 1b mov %i3, %o1
2003a70: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003a74: 40 00 60 84 call 201bc84 <__moddi3>
2003a78: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003a7c: 90 10 00 09 mov %o1, %o0
2003a80: 40 00 5e 3e call 201b378 <.udiv>
2003a84: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003a88: d8 1f bf d0 ldd [ %fp + -48 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003a8c: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003a90: 92 10 00 13 mov %l3, %o1
2003a94: 90 10 00 18 mov %i0, %o0
2003a98: 9f c6 40 00 call %i1
2003a9c: 94 10 00 17 mov %l7, %o2
2003aa0: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
2003aa4: a0 04 20 01 inc %l0
2003aa8: 83 28 e0 10 sll %g3, 0x10, %g1
2003aac: 83 30 60 10 srl %g1, 0x10, %g1
2003ab0: 80 a0 40 10 cmp %g1, %l0
2003ab4: 2a 80 00 26 bcs,a 2003b4c <rtems_cpu_usage_report_with_plugin+0x1b4>
2003ab8: aa 05 60 04 add %l5, 4, %l5
the_thread = (Thread_Control *)information->local_table[ i ];
2003abc: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
2003ac0: 83 2c 20 02 sll %l0, 2, %g1
2003ac4: f6 00 80 01 ld [ %g2 + %g1 ], %i3
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2003ac8: 94 07 bf f0 add %fp, -16, %o2
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
2003acc: 80 a6 e0 00 cmp %i3, 0
2003ad0: 02 bf ff f5 be 2003aa4 <rtems_cpu_usage_report_with_plugin+0x10c><== NEVER TAKEN
2003ad4: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2003ad8: 40 00 14 7d call 2008ccc <rtems_object_get_name>
2003adc: d0 06 e0 08 ld [ %i3 + 8 ], %o0
(*print)(
2003ae0: d4 06 e0 08 ld [ %i3 + 8 ], %o2
2003ae4: 90 10 00 18 mov %i0, %o0
2003ae8: 92 10 00 12 mov %l2, %o1
2003aec: 9f c6 40 00 call %i1
2003af0: 96 07 bf f0 add %fp, -16, %o3
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2003af4: 03 00 80 85 sethi %hi(0x2021400), %g1
2003af8: 82 10 60 a0 or %g1, 0xa0, %g1 ! 20214a0 <_Per_CPU_Information>
2003afc: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2003b00: c4 1e e0 80 ldd [ %i3 + 0x80 ], %g2
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2003b04: f4 01 20 08 ld [ %g4 + 8 ], %i2
2003b08: c8 06 e0 08 ld [ %i3 + 8 ], %g4
2003b0c: 80 a6 80 04 cmp %i2, %g4
2003b10: 12 bf ff c1 bne 2003a14 <rtems_cpu_usage_report_with_plugin+0x7c>
2003b14: c4 3f bf e8 std %g2, [ %fp + -24 ]
*time_of_context_switch = _Thread_Time_of_last_context_switch;
2003b18: f4 18 60 20 ldd [ %g1 + 0x20 ], %i2
2003b1c: 92 10 00 14 mov %l4, %o1
2003b20: 40 00 19 d8 call 200a280 <_TOD_Get_with_nanoseconds>
2003b24: 90 07 bf d8 add %fp, -40, %o0
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
2003b28: c4 1f bf d8 ldd [ %fp + -40 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003b2c: 96 a0 c0 1b subcc %g3, %i3, %o3
2003b30: 94 60 80 1a subx %g2, %i2, %o2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2003b34: f4 1f bf e8 ldd [ %fp + -24 ], %i2
2003b38: 9a 86 c0 0b addcc %i3, %o3, %o5
2003b3c: 98 46 80 0a addx %i2, %o2, %o4
2003b40: 10 bf ff b9 b 2003a24 <rtems_cpu_usage_report_with_plugin+0x8c>
2003b44: d8 3f bf e8 std %o4, [ %fp + -24 ]
2003b48: aa 05 60 04 add %l5, 4, %l5
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003b4c: 80 a5 40 16 cmp %l5, %l6
2003b50: 32 bf ff a7 bne,a 20039ec <rtems_cpu_usage_report_with_plugin+0x54>
2003b54: c2 05 40 00 ld [ %l5 ], %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
2003b58: f8 1f bf e0 ldd [ %fp + -32 ], %i4
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003b5c: 94 10 20 00 clr %o2
2003b60: 90 10 00 1c mov %i4, %o0
2003b64: 92 10 00 1d mov %i5, %o1
2003b68: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003b6c: 40 00 5f 5b call 201b8d8 <__divdi3>
2003b70: 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);
2003b74: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003b78: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003b7c: 90 10 00 1c mov %i4, %o0
2003b80: 92 10 00 1d mov %i5, %o1
2003b84: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003b88: 40 00 60 3f call 201bc84 <__moddi3>
2003b8c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003b90: 90 10 00 09 mov %o1, %o0
2003b94: 40 00 5d f9 call 201b378 <.udiv>
2003b98: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003b9c: 94 10 00 1b mov %i3, %o2
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003ba0: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003ba4: 13 00 80 78 sethi %hi(0x201e000), %o1
2003ba8: 90 10 00 18 mov %i0, %o0
2003bac: 9f c6 40 00 call %i1
2003bb0: 92 12 61 38 or %o1, 0x138, %o1
2003bb4: 81 c7 e0 08 ret
2003bb8: 81 e8 00 00 restore
020102ec <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
20102ec: 9d e3 bf a0 save %sp, -96, %sp
20102f0: 82 10 00 18 mov %i0, %g1
if (sc == RTEMS_SUCCESSFUL) {
20102f4: 80 a0 60 00 cmp %g1, 0
20102f8: 02 80 00 0c be 2010328 <rtems_deviceio_errno+0x3c>
20102fc: b0 10 20 00 clr %i0
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
2010300: 80 a0 60 1c cmp %g1, 0x1c
2010304: 18 80 00 06 bgu 201031c <rtems_deviceio_errno+0x30> <== NEVER TAKEN
2010308: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
201030c: 83 28 60 02 sll %g1, 2, %g1
2010310: 05 00 80 72 sethi %hi(0x201c800), %g2
2010314: 84 10 a0 fc or %g2, 0xfc, %g2 ! 201c8fc <status_code_to_errno>
2010318: fa 00 80 01 ld [ %g2 + %g1 ], %i5
}
errno = eno;
201031c: 40 00 00 2f call 20103d8 <__errno>
2010320: b0 10 3f ff mov -1, %i0
2010324: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
2010328: 81 c7 e0 08 ret
201032c: 81 e8 00 00 restore
02003924 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
2003924: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *phys_dd = NULL;
rtems_disk_device *dd = NULL;
2003928: c0 27 bf f8 clr [ %fp + -8 ]
char *alloc_name = NULL;
sc = disk_lock();
200392c: 7f ff fe f5 call 2003500 <disk_lock>
2003930: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
2003934: a0 92 20 00 orcc %o0, 0, %l0
2003938: 02 80 00 04 be 2003948 <rtems_disk_create_log+0x24> <== ALWAYS TAKEN
200393c: 92 10 00 1b mov %i3, %o1
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
2003940: 81 c7 e0 08 ret <== NOT EXECUTED
2003944: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
phys_dd = get_disk_entry(phys, true);
2003948: 90 10 00 1a mov %i2, %o0
200394c: 7f ff fe b0 call 200340c <get_disk_entry>
2003950: 94 10 20 01 mov 1, %o2
if (phys_dd == NULL) {
2003954: b6 92 20 00 orcc %o0, 0, %i3
2003958: 02 80 00 25 be 20039ec <rtems_disk_create_log+0xc8>
200395c: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
2003960: 90 10 00 18 mov %i0, %o0
2003964: 92 10 00 19 mov %i1, %o1
2003968: 96 07 bf f8 add %fp, -8, %o3
200396c: 7f ff ff 03 call 2003578 <create_disk>
2003970: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
2003974: a0 92 20 00 orcc %o0, 0, %l0
2003978: 12 80 00 19 bne 20039dc <rtems_disk_create_log+0xb8>
200397c: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
2003980: 92 10 00 1b mov %i3, %o1
2003984: 94 10 00 1c mov %i4, %o2
2003988: 40 00 31 e9 call 201012c <rtems_disk_init_log>
200398c: 96 10 00 1d mov %i5, %o3
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
2003990: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
++phys_dd->uses;
2003994: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
block_begin,
block_count
);
dd->dev = dev;
dd->name = alloc_name;
2003998: c6 07 bf fc ld [ %fp + -4 ], %g3
++phys_dd->uses;
200399c: 84 00 a0 01 inc %g2
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
20039a0: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
20039a4: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
++phys_dd->uses;
20039a8: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
if (sc != RTEMS_SUCCESSFUL) {
20039ac: 80 a2 20 00 cmp %o0, 0
20039b0: 02 80 00 0b be 20039dc <rtems_disk_create_log+0xb8>
20039b4: a0 10 00 08 mov %o0, %l0
dd->ioctl = null_handler;
20039b8: 05 00 80 0d sethi %hi(0x2003400), %g2
20039bc: 84 10 a0 a0 or %g2, 0xa0, %g2 ! 20034a0 <null_handler>
rtems_disk_delete(dev);
20039c0: 92 10 00 19 mov %i1, %o1
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
20039c4: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
20039c8: 7f ff ff 5c call 2003738 <rtems_disk_delete>
20039cc: 90 10 00 18 mov %i0, %o0
disk_unlock();
20039d0: 7f ff fe db call 200353c <disk_unlock>
20039d4: b0 10 00 10 mov %l0, %i0
20039d8: 30 80 00 03 b,a 20039e4 <rtems_disk_create_log+0xc0>
return sc;
}
disk_unlock();
20039dc: 7f ff fe d8 call 200353c <disk_unlock>
20039e0: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
20039e4: 81 c7 e0 08 ret
20039e8: 81 e8 00 00 restore
return sc;
}
phys_dd = get_disk_entry(phys, true);
if (phys_dd == NULL) {
disk_unlock();
20039ec: 7f ff fe d4 call 200353c <disk_unlock>
20039f0: a0 10 20 04 mov 4, %l0
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
20039f4: 81 c7 e0 08 ret
20039f8: 91 e8 00 10 restore %g0, %l0, %o0
020039fc <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
20039fc: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
2003a00: c0 27 bf f8 clr [ %fp + -8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
2003a04: c0 27 bf fc clr [ %fp + -4 ]
if (handler == NULL) {
2003a08: 80 a7 20 00 cmp %i4, 0
2003a0c: 02 80 00 07 be 2003a28 <rtems_disk_create_phys+0x2c>
2003a10: a0 10 20 09 mov 9, %l0
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
2003a14: 7f ff fe bb call 2003500 <disk_lock>
2003a18: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003a1c: a0 92 20 00 orcc %o0, 0, %l0
2003a20: 02 80 00 04 be 2003a30 <rtems_disk_create_phys+0x34> <== ALWAYS TAKEN
2003a24: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
2003a28: 81 c7 e0 08 ret
2003a2c: 91 e8 00 10 restore %g0, %l0, %o0
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
sc = create_disk(dev, name, &dd, &alloc_name);
2003a30: 90 10 00 18 mov %i0, %o0
2003a34: 92 10 00 19 mov %i1, %o1
2003a38: 96 07 bf f8 add %fp, -8, %o3
2003a3c: 7f ff fe cf call 2003578 <create_disk>
2003a40: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
2003a44: a0 92 20 00 orcc %o0, 0, %l0
2003a48: 12 80 00 0e bne 2003a80 <rtems_disk_create_phys+0x84>
2003a4c: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
2003a50: 92 10 00 1a mov %i2, %o1
2003a54: 94 10 00 1b mov %i3, %o2
2003a58: 96 10 00 1c mov %i4, %o3
2003a5c: 40 00 31 9a call 20100c4 <rtems_disk_init_phys>
2003a60: 98 10 00 1d mov %i5, %o4
block_count,
handler,
driver_data
);
dd->dev = dev;
2003a64: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
2003a68: c4 07 bf fc ld [ %fp + -4 ], %g2
block_count,
handler,
driver_data
);
dd->dev = dev;
2003a6c: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
2003a70: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if (sc != RTEMS_SUCCESSFUL) {
2003a74: 80 a2 20 00 cmp %o0, 0
2003a78: 12 80 00 06 bne 2003a90 <rtems_disk_create_phys+0x94>
2003a7c: a0 10 00 08 mov %o0, %l0
disk_unlock();
return sc;
}
disk_unlock();
2003a80: 7f ff fe af call 200353c <disk_unlock>
2003a84: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
2003a88: 81 c7 e0 08 ret
2003a8c: 81 e8 00 00 restore
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
2003a90: 05 00 80 0d sethi %hi(0x2003400), %g2
2003a94: 84 10 a0 a0 or %g2, 0xa0, %g2 ! 20034a0 <null_handler>
rtems_disk_delete(dev);
2003a98: 92 10 00 19 mov %i1, %o1
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
2003a9c: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
2003aa0: 7f ff ff 26 call 2003738 <rtems_disk_delete>
2003aa4: 90 10 00 18 mov %i0, %o0
disk_unlock();
2003aa8: 7f ff fe a5 call 200353c <disk_unlock>
2003aac: b0 10 00 10 mov %l0, %i0
2003ab0: 30 bf ff f6 b,a 2003a88 <rtems_disk_create_phys+0x8c>
02003738 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
2003738: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
200373c: 7f ff ff 71 call 2003500 <disk_lock>
2003740: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003744: a0 92 20 00 orcc %o0, 0, %l0
2003748: 02 80 00 04 be 2003758 <rtems_disk_delete+0x20> <== ALWAYS TAKEN
200374c: 90 10 00 18 mov %i0, %o0
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
2003750: 81 c7 e0 08 ret <== NOT EXECUTED
2003754: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
dd = get_disk_entry(dev, true);
2003758: 92 10 00 19 mov %i1, %o1
200375c: 7f ff ff 2c call 200340c <get_disk_entry>
2003760: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
2003764: 82 92 20 00 orcc %o0, 0, %g1
2003768: 02 80 00 5e be 20038e0 <rtems_disk_delete+0x1a8> <== NEVER TAKEN
200376c: 84 10 20 01 mov 1, %g2
}
static void
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
2003770: e2 00 60 08 ld [ %g1 + 8 ], %l1
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
2003774: c4 28 60 40 stb %g2, [ %g1 + 0x40 ]
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
2003778: c4 0c 60 40 ldub [ %l1 + 0x40 ], %g2
200377c: 80 a0 a0 00 cmp %g2, 0
2003780: 22 80 00 43 be,a 200388c <rtems_disk_delete+0x154>
2003784: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2003788: 2b 00 80 89 sethi %hi(0x2022400), %l5
200378c: c2 05 61 f0 ld [ %l5 + 0x1f0 ], %g1 ! 20225f0 <disktab_size>
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
2003790: f2 04 40 00 ld [ %l1 ], %i1
2003794: e4 04 60 04 ld [ %l1 + 4 ], %l2
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2003798: 80 a0 60 00 cmp %g1, 0
200379c: 02 80 00 33 be 2003868 <rtems_disk_delete+0x130> <== NEVER TAKEN
20037a0: a8 10 20 00 clr %l4
20037a4: 2d 00 80 89 sethi %hi(0x2022400), %l6
20037a8: b0 10 20 00 clr %i0
20037ac: ac 15 a1 f4 or %l6, 0x1f4, %l6
20037b0: aa 15 61 f0 or %l5, 0x1f0, %l5
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
20037b4: a6 10 20 01 mov 1, %l3
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;
20037b8: f6 05 80 00 ld [ %l6 ], %i3
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
20037bc: 83 2e 20 03 sll %i0, 3, %g1
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;
20037c0: b6 06 c0 01 add %i3, %g1, %i3
for (minor = 0; minor < dtab->size; ++minor) {
20037c4: f4 06 e0 04 ld [ %i3 + 4 ], %i2
20037c8: 80 a6 a0 00 cmp %i2, 0
20037cc: 22 80 00 23 be,a 2003858 <rtems_disk_delete+0x120>
20037d0: c2 05 40 00 ld [ %l5 ], %g1
20037d4: 10 80 00 06 b 20037ec <rtems_disk_delete+0xb4>
20037d8: ba 10 20 00 clr %i5
20037dc: ba 07 60 01 inc %i5
20037e0: 80 a7 40 1a cmp %i5, %i2
20037e4: 3a 80 00 1d bcc,a 2003858 <rtems_disk_delete+0x120>
20037e8: c2 05 40 00 ld [ %l5 ], %g1
rtems_disk_device *dd = dtab->minor [minor];
20037ec: c6 06 c0 00 ld [ %i3 ], %g3
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
20037f0: 85 2f 60 02 sll %i5, 2, %g2
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
20037f4: d0 00 c0 02 ld [ %g3 + %g2 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
20037f8: 80 a2 20 00 cmp %o0, 0
20037fc: 22 bf ff f9 be,a 20037e0 <rtems_disk_delete+0xa8>
2003800: ba 07 60 01 inc %i5
2003804: c8 02 20 08 ld [ %o0 + 8 ], %g4
2003808: f8 01 00 00 ld [ %g4 ], %i4
200380c: 80 a7 00 19 cmp %i4, %i1
2003810: 32 bf ff f4 bne,a 20037e0 <rtems_disk_delete+0xa8> <== NEVER TAKEN
2003814: ba 07 60 01 inc %i5 <== NOT EXECUTED
2003818: c8 01 20 04 ld [ %g4 + 4 ], %g4
200381c: 80 a1 00 12 cmp %g4, %l2
2003820: 32 bf ff f0 bne,a 20037e0 <rtems_disk_delete+0xa8> <== NEVER TAKEN
2003824: ba 07 60 01 inc %i5 <== NOT EXECUTED
2003828: 80 a4 40 08 cmp %l1, %o0
200382c: 22 bf ff ed be,a 20037e0 <rtems_disk_delete+0xa8>
2003830: ba 07 60 01 inc %i5
if (dd->uses == 0) {
2003834: c8 02 20 14 ld [ %o0 + 0x14 ], %g4
2003838: 80 a1 20 00 cmp %g4, 0
200383c: 22 80 00 25 be,a 20038d0 <rtems_disk_delete+0x198>
2003840: c0 20 c0 02 clr [ %g3 + %g2 ]
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
2003844: ba 07 60 01 inc %i5
2003848: 80 a7 40 1a cmp %i5, %i2
200384c: 0a bf ff e8 bcs 20037ec <rtems_disk_delete+0xb4> <== ALWAYS TAKEN
2003850: e6 2a 20 40 stb %l3, [ %o0 + 0x40 ]
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2003854: c2 05 40 00 ld [ %l5 ], %g1 <== NOT EXECUTED
2003858: b0 06 20 01 inc %i0
200385c: 80 a6 00 01 cmp %i0, %g1
2003860: 2a bf ff d7 bcs,a 20037bc <rtems_disk_delete+0x84>
2003864: f6 05 80 00 ld [ %l6 ], %i3
}
}
}
}
physical_disk->uses -= deleted_count;
2003868: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
200386c: a8 20 40 14 sub %g1, %l4, %l4
if (physical_disk->uses == 0) {
2003870: 80 a5 20 00 cmp %l4, 0
2003874: 02 80 00 1f be 20038f0 <rtems_disk_delete+0x1b8>
2003878: e8 24 60 14 st %l4, [ %l1 + 0x14 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
200387c: 7f ff ff 30 call 200353c <disk_unlock>
2003880: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
2003884: 81 c7 e0 08 ret
2003888: 81 e8 00 00 restore
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
200388c: 80 a0 a0 00 cmp %g2, 0
2003890: 12 bf ff fb bne 200387c <rtems_disk_delete+0x144> <== NEVER TAKEN
2003894: 07 00 80 89 sethi %hi(0x2022400), %g3
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2003898: c4 00 40 00 ld [ %g1 ], %g2
disktab [major].minor [minor] = NULL;
200389c: c8 00 e1 f4 ld [ %g3 + 0x1f4 ], %g4
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
20038a0: c2 00 60 04 ld [ %g1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
20038a4: c6 04 60 14 ld [ %l1 + 0x14 ], %g3
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
20038a8: 85 28 a0 03 sll %g2, 3, %g2
20038ac: c4 01 00 02 ld [ %g4 + %g2 ], %g2
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
20038b0: 86 00 ff ff add %g3, -1, %g3
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
20038b4: 83 28 60 02 sll %g1, 2, %g1
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
20038b8: c6 24 60 14 st %g3, [ %l1 + 0x14 ]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
free_disk_device(disk_to_remove);
20038bc: 7f ff fe fb call 20034a8 <free_disk_device>
20038c0: c0 20 80 01 clr [ %g2 + %g1 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
20038c4: 7f ff ff 1e call 200353c <disk_unlock>
20038c8: b0 10 00 10 mov %l0, %i0
20038cc: 30 bf ff ee b,a 2003884 <rtems_disk_delete+0x14c>
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
20038d0: 7f ff fe f6 call 20034a8 <free_disk_device>
20038d4: a8 05 20 01 inc %l4
20038d8: 10 bf ff c1 b 20037dc <rtems_disk_delete+0xa4>
20038dc: f4 06 e0 04 ld [ %i3 + 4 ], %i2
return sc;
}
dd = get_disk_entry(dev, true);
if (dd == NULL) {
disk_unlock();
20038e0: 7f ff ff 17 call 200353c <disk_unlock> <== NOT EXECUTED
20038e4: a0 10 20 04 mov 4, %l0 <== NOT EXECUTED
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
20038e8: 81 c7 e0 08 ret <== NOT EXECUTED
20038ec: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
20038f0: c4 04 40 00 ld [ %l1 ], %g2
disktab [major].minor [minor] = NULL;
20038f4: 03 00 80 89 sethi %hi(0x2022400), %g1
20038f8: c6 00 61 f4 ld [ %g1 + 0x1f4 ], %g3 ! 20225f4 <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
20038fc: c2 04 60 04 ld [ %l1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
2003900: 85 28 a0 03 sll %g2, 3, %g2
2003904: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2003908: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
200390c: 90 10 00 11 mov %l1, %o0
2003910: 7f ff fe e6 call 20034a8 <free_disk_device>
2003914: c0 20 80 01 clr [ %g2 + %g1 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2003918: 7f ff ff 09 call 200353c <disk_unlock>
200391c: b0 10 00 10 mov %l0, %i0
2003920: 30 bf ff d9 b,a 2003884 <rtems_disk_delete+0x14c>
02003d28 <rtems_disk_io_done>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
2003d28: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
2003d2c: 21 00 80 89 sethi %hi(0x2022400), %l0
2003d30: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 ! 20225f0 <disktab_size>
2003d34: 35 00 80 89 sethi %hi(0x2022400), %i2
2003d38: b6 10 20 00 clr %i3
2003d3c: fa 06 a1 f4 ld [ %i2 + 0x1f4 ], %i5
2003d40: 80 a0 60 00 cmp %g1, 0
2003d44: 02 80 00 1d be 2003db8 <rtems_disk_io_done+0x90> <== NEVER TAKEN
2003d48: b2 14 21 f0 or %l0, 0x1f0, %i1
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
2003d4c: 83 2e e0 03 sll %i3, 3, %g1
{
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
2003d50: b8 07 40 01 add %i5, %g1, %i4
for (minor = 0; minor < dtab->size; ++minor) {
2003d54: c4 07 20 04 ld [ %i4 + 4 ], %g2
2003d58: 80 a0 a0 00 cmp %g2, 0
2003d5c: 02 80 00 10 be 2003d9c <rtems_disk_io_done+0x74>
2003d60: c6 07 40 01 ld [ %i5 + %g1 ], %g3
2003d64: ba 10 20 00 clr %i5
rtems_disk_device *dd = dtab->minor [minor];
2003d68: 83 2f 60 02 sll %i5, 2, %g1
2003d6c: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
if (dd != NULL) {
2003d70: 90 90 60 00 orcc %g1, 0, %o0
2003d74: 02 80 00 06 be 2003d8c <rtems_disk_io_done+0x64>
2003d78: ba 07 60 01 inc %i5
free_disk_device(dd);
2003d7c: 7f ff fd cb call 20034a8 <free_disk_device>
2003d80: 01 00 00 00 nop
2003d84: c4 07 20 04 ld [ %i4 + 4 ], %g2
2003d88: c6 07 00 00 ld [ %i4 ], %g3
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
2003d8c: 80 a0 80 1d cmp %g2, %i5
2003d90: 18 bf ff f7 bgu 2003d6c <rtems_disk_io_done+0x44>
2003d94: 83 2f 60 02 sll %i5, 2, %g1
2003d98: fa 06 a1 f4 ld [ %i2 + 0x1f4 ], %i5
if (dd != NULL) {
free_disk_device(dd);
}
}
free(dtab->minor);
2003d9c: 40 00 02 b8 call 200487c <free>
2003da0: 90 10 00 03 mov %g3, %o0
rtems_disk_io_done(void)
{
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
2003da4: c2 06 40 00 ld [ %i1 ], %g1
2003da8: b6 06 e0 01 inc %i3
2003dac: 80 a0 40 1b cmp %g1, %i3
2003db0: 18 bf ff e8 bgu 2003d50 <rtems_disk_io_done+0x28>
2003db4: 83 2e e0 03 sll %i3, 3, %g1
free_disk_device(dd);
}
}
free(dtab->minor);
}
free(disktab);
2003db8: 40 00 02 b1 call 200487c <free>
2003dbc: 90 10 00 1d mov %i5, %o0
rtems_semaphore_delete(diskdevs_mutex);
2003dc0: 3b 00 80 89 sethi %hi(0x2022400), %i5
2003dc4: d0 07 61 ec ld [ %i5 + 0x1ec ], %o0 ! 20225ec <diskdevs_mutex>
2003dc8: 40 00 14 26 call 2008e60 <rtems_semaphore_delete>
2003dcc: b0 10 20 00 clr %i0
diskdevs_mutex = RTEMS_ID_NONE;
2003dd0: c0 27 61 ec clr [ %i5 + 0x1ec ]
disktab = NULL;
2003dd4: c0 26 a1 f4 clr [ %i2 + 0x1f4 ]
disktab_size = 0;
2003dd8: c0 24 21 f0 clr [ %l0 + 0x1f0 ]
return RTEMS_SUCCESSFUL;
}
2003ddc: 81 c7 e0 08 ret
2003de0: 81 e8 00 00 restore
02003c7c <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
2003c7c: 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) {
2003c80: 3b 00 80 89 sethi %hi(0x2022400), %i5
2003c84: c2 07 61 f0 ld [ %i5 + 0x1f0 ], %g1 ! 20225f0 <disktab_size>
2003c88: 80 a0 60 00 cmp %g1, 0
2003c8c: 12 80 00 19 bne 2003cf0 <rtems_disk_io_initialize+0x74>
2003c90: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
2003c94: 90 10 20 08 mov 8, %o0
2003c98: 92 10 20 08 mov 8, %o1
2003c9c: 40 00 02 27 call 2004538 <calloc>
2003ca0: 39 00 80 89 sethi %hi(0x2022400), %i4
2003ca4: d0 27 21 f4 st %o0, [ %i4 + 0x1f4 ] ! 20225f4 <disktab>
if (disktab == NULL) {
2003ca8: 80 a2 20 00 cmp %o0, 0
2003cac: 02 80 00 11 be 2003cf0 <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
2003cb0: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
2003cb4: 03 00 80 89 sethi %hi(0x2022400), %g1
sc = rtems_semaphore_create(
2003cb8: 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;
2003cbc: c0 28 61 e8 clrb [ %g1 + 0x1e8 ]
sc = rtems_semaphore_create(
2003cc0: 90 12 21 56 or %o0, 0x156, %o0
2003cc4: 92 10 20 01 mov 1, %o1
2003cc8: 94 10 20 10 mov 0x10, %o2
2003ccc: 96 10 20 00 clr %o3
2003cd0: 37 00 80 89 sethi %hi(0x2022400), %i3
2003cd4: 40 00 13 f2 call 2008c9c <rtems_semaphore_create>
2003cd8: 98 16 e1 ec or %i3, 0x1ec, %o4 ! 20225ec <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
2003cdc: 80 a2 20 00 cmp %o0, 0
2003ce0: 02 80 00 06 be 2003cf8 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
2003ce4: 01 00 00 00 nop
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
free(disktab);
2003ce8: 40 00 02 e5 call 200487c <free> <== NOT EXECUTED
2003cec: d0 07 21 f4 ld [ %i4 + 0x1f4 ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2003cf0: 81 c7 e0 08 ret
2003cf4: 81 e8 00 00 restore
free(disktab);
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
2003cf8: 40 00 2c 37 call 200edd4 <rtems_bdbuf_init>
2003cfc: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003d00: 80 a2 20 00 cmp %o0, 0
2003d04: 12 80 00 05 bne 2003d18 <rtems_disk_io_initialize+0x9c> <== NEVER TAKEN
2003d08: 82 10 20 08 mov 8, %g1
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
2003d0c: c2 27 61 f0 st %g1, [ %i5 + 0x1f0 ]
return RTEMS_SUCCESSFUL;
}
2003d10: 81 c7 e0 08 ret
2003d14: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
2003d18: d0 06 e1 ec ld [ %i3 + 0x1ec ], %o0 <== NOT EXECUTED
2003d1c: 40 00 14 51 call 2008e60 <rtems_semaphore_delete> <== NOT EXECUTED
2003d20: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
2003d24: 30 bf ff f1 b,a 2003ce8 <rtems_disk_io_initialize+0x6c> <== NOT EXECUTED
02003b84 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
2003b84: 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) {
2003b88: 80 a6 3f ff cmp %i0, -1
2003b8c: 02 80 00 37 be 2003c68 <rtems_disk_next+0xe4>
2003b90: 80 a6 7f ff cmp %i1, -1
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
2003b94: ba 06 60 01 add %i1, 1, %i5
2003b98: 80 a7 40 19 cmp %i5, %i1
2003b9c: 0a 80 00 2e bcs 2003c54 <rtems_disk_next+0xd0> <== NEVER TAKEN
2003ba0: b8 10 00 18 mov %i0, %i4
} else {
++minor;
}
}
sc = disk_lock();
2003ba4: 7f ff fe 57 call 2003500 <disk_lock>
2003ba8: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003bac: 80 a2 20 00 cmp %o0, 0
2003bb0: 12 80 00 27 bne 2003c4c <rtems_disk_next+0xc8> <== NEVER TAKEN
2003bb4: 03 00 80 89 sethi %hi(0x2022400), %g1
return NULL;
}
if (major >= disktab_size) {
2003bb8: c8 00 61 f0 ld [ %g1 + 0x1f0 ], %g4 ! 20225f0 <disktab_size>
2003bbc: 80 a7 00 04 cmp %i4, %g4
2003bc0: 1a 80 00 21 bcc 2003c44 <rtems_disk_next+0xc0> <== NEVER TAKEN
2003bc4: 03 00 80 89 sethi %hi(0x2022400), %g1
disk_unlock();
return NULL;
}
dtab = disktab + major;
2003bc8: c6 00 61 f4 ld [ %g1 + 0x1f4 ], %g3 ! 20225f4 <disktab>
2003bcc: b7 2f 20 03 sll %i4, 3, %i3
2003bd0: c2 00 c0 1b ld [ %g3 + %i3 ], %g1
2003bd4: b6 00 c0 1b add %g3, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2003bd8: 80 a0 60 00 cmp %g1, 0
2003bdc: 02 80 00 12 be 2003c24 <rtems_disk_next+0xa0>
2003be0: b5 2f 60 02 sll %i5, 2, %i2
2003be4: c4 06 e0 04 ld [ %i3 + 4 ], %g2
2003be8: 80 a7 40 02 cmp %i5, %g2
2003bec: 3a 80 00 0f bcc,a 2003c28 <rtems_disk_next+0xa4>
2003bf0: b8 07 20 01 inc %i4
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
2003bf4: c4 00 40 1a ld [ %g1 + %i2 ], %g2
2003bf8: 80 a0 a0 00 cmp %g2, 0
2003bfc: 02 bf ff f7 be 2003bd8 <rtems_disk_next+0x54>
2003c00: ba 07 60 01 inc %i5
++minor;
} else {
++dtab->minor [minor]->uses;
2003c04: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
2003c08: 82 00 60 01 inc %g1
disk_unlock();
2003c0c: 7f ff fe 4c call 200353c <disk_unlock>
2003c10: c2 20 a0 14 st %g1, [ %g2 + 0x14 ]
return dtab->minor [minor];
2003c14: c2 06 c0 00 ld [ %i3 ], %g1
2003c18: f0 00 40 1a ld [ %g1 + %i2 ], %i0
}
}
}
2003c1c: 81 c7 e0 08 ret
2003c20: 81 e8 00 00 restore
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
++major;
2003c24: b8 07 20 01 inc %i4
if (major >= disktab_size) {
2003c28: 80 a1 00 1c cmp %g4, %i4
2003c2c: 08 80 00 06 bleu 2003c44 <rtems_disk_next+0xc0>
2003c30: 83 2f 20 03 sll %i4, 3, %g1
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
2003c34: ba 10 20 00 clr %i5
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
2003c38: b6 00 c0 01 add %g3, %g1, %i3
2003c3c: 10 bf ff e7 b 2003bd8 <rtems_disk_next+0x54>
2003c40: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
disk_unlock();
2003c44: 7f ff fe 3e call 200353c <disk_unlock>
2003c48: 01 00 00 00 nop
return NULL;
2003c4c: 81 c7 e0 08 ret
2003c50: 91 e8 20 00 restore %g0, 0, %o0
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
2003c54: b8 06 20 01 add %i0, 1, %i4 <== NOT EXECUTED
2003c58: 80 a7 00 18 cmp %i4, %i0 <== NOT EXECUTED
2003c5c: 1a bf ff d2 bcc 2003ba4 <rtems_disk_next+0x20> <== NOT EXECUTED
2003c60: ba 10 20 00 clr %i5 <== NOT EXECUTED
2003c64: 30 bf ff fa b,a 2003c4c <rtems_disk_next+0xc8> <== NOT EXECUTED
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) {
2003c68: 32 bf ff cc bne,a 2003b98 <rtems_disk_next+0x14> <== NEVER TAKEN
2003c6c: ba 06 60 01 add %i1, 1, %i5 <== NOT EXECUTED
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
2003c70: ba 10 20 00 clr %i5
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;
2003c74: 10 bf ff cc b 2003ba4 <rtems_disk_next+0x20>
2003c78: b8 10 20 00 clr %i4
02003ab4 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
2003ab4: 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);
2003ab8: 7f ff fc 9e call 2002d30 <sparc_disable_interrupts>
2003abc: b8 10 00 18 mov %i0, %i4
2003ac0: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
2003ac4: 03 00 80 89 sethi %hi(0x2022400), %g1
2003ac8: c2 08 61 e8 ldub [ %g1 + 0x1e8 ], %g1 ! 20225e8 <diskdevs_protected>
2003acc: 80 a0 60 00 cmp %g1, 0
2003ad0: 22 80 00 10 be,a 2003b10 <rtems_disk_obtain+0x5c> <== ALWAYS TAKEN
2003ad4: 90 10 00 18 mov %i0, %o0
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
2003ad8: 7f ff fc 9a call 2002d40 <sparc_enable_interrupts> <== NOT EXECUTED
2003adc: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
2003ae0: 7f ff fe 88 call 2003500 <disk_lock> <== NOT EXECUTED
2003ae4: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
2003ae8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2003aec: 12 80 00 07 bne 2003b08 <rtems_disk_obtain+0x54> <== NOT EXECUTED
2003af0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
2003af4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2003af8: 7f ff fe 45 call 200340c <get_disk_entry> <== NOT EXECUTED
2003afc: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
2003b00: 7f ff fe 8f call 200353c <disk_unlock> <== NOT EXECUTED
2003b04: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
2003b08: 81 c7 e0 08 ret <== NOT EXECUTED
2003b0c: 81 e8 00 00 restore <== NOT EXECUTED
rtems_interrupt_level level;
rtems_interrupt_disable(level);
if (!diskdevs_protected) {
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
2003b10: 92 10 00 19 mov %i1, %o1
2003b14: 7f ff fe 3e call 200340c <get_disk_entry>
2003b18: 94 10 20 00 clr %o2
2003b1c: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
2003b20: 7f ff fc 88 call 2002d40 <sparc_enable_interrupts>
2003b24: 90 10 00 1b mov %i3, %o0
2003b28: 81 c7 e0 08 ret
2003b2c: 81 e8 00 00 restore
02011e4c <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
2011e4c: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
2011e50: 80 a6 e0 00 cmp %i3, 0
2011e54: 02 80 00 0a be 2011e7c <rtems_event_system_receive+0x30> <== NEVER TAKEN
2011e58: 82 10 20 09 mov 9, %g1
Thread_Control *executing = _Thread_Executing;
2011e5c: 03 00 80 8b sethi %hi(0x2022c00), %g1
2011e60: fa 00 63 e0 ld [ %g1 + 0x3e0 ], %i5 ! 2022fe0 <_Per_CPU_Information+0x10>
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
2011e64: 80 a6 20 00 cmp %i0, 0
2011e68: 12 80 00 07 bne 2011e84 <rtems_event_system_receive+0x38> <== ALWAYS TAKEN
2011e6c: da 07 61 58 ld [ %i5 + 0x158 ], %o5
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
2011e70: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
2011e74: 82 10 20 00 clr %g1 <== NOT EXECUTED
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
2011e78: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
2011e7c: 81 c7 e0 08 ret <== NOT EXECUTED
2011e80: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2011e84: 03 00 80 8a sethi %hi(0x2022800), %g1
2011e88: c4 00 62 b0 ld [ %g1 + 0x2b0 ], %g2 ! 2022ab0 <_Thread_Dispatch_disable_level>
++level;
2011e8c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2011e90: c4 20 62 b0 st %g2, [ %g1 + 0x2b0 ]
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
_Thread_Disable_dispatch();
_Event_Seize(
2011e94: 03 00 01 00 sethi %hi(0x40000), %g1
2011e98: 90 10 00 18 mov %i0, %o0
2011e9c: 92 10 00 19 mov %i1, %o1
2011ea0: 94 10 00 1a mov %i2, %o2
2011ea4: 96 10 00 1b mov %i3, %o3
2011ea8: 98 10 00 1d mov %i5, %o4
2011eac: 9a 03 60 04 add %o5, 4, %o5
2011eb0: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
2011eb4: 03 00 80 8c sethi %hi(0x2023000), %g1
2011eb8: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 20233d0 <_System_event_Sync_state>
2011ebc: 7f ff da a5 call 2008950 <_Event_Seize>
2011ec0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
2011ec4: 7f ff e6 cf call 200ba00 <_Thread_Enable_dispatch>
2011ec8: 01 00 00 00 nop
sc = executing->Wait.return_code;
2011ecc: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
2011ed0: 81 c7 e0 08 ret
2011ed4: 91 e8 00 01 restore %g0, %g1, %o0
02007d48 <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
2007d48: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
Thread_Control *thread;
Objects_Locations location;
RTEMS_API_Control *api;
thread = _Thread_Get( id, &location );
2007d4c: 90 10 00 18 mov %i0, %o0
2007d50: 40 00 0a 96 call 200a7a8 <_Thread_Get>
2007d54: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
2007d58: c2 07 bf fc ld [ %fp + -4 ], %g1
2007d5c: 80 a0 60 00 cmp %g1, 0
2007d60: 12 80 00 0d bne 2007d94 <rtems_event_system_send+0x4c> <== NEVER TAKEN
2007d64: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
api = thread->API_Extensions[ THREAD_API_RTEMS ];
_Event_Surrender(
2007d68: d4 02 21 58 ld [ %o0 + 0x158 ], %o2
2007d6c: 94 02 a0 04 add %o2, 4, %o2
2007d70: 19 00 01 00 sethi %hi(0x40000), %o4
2007d74: 17 00 80 7b sethi %hi(0x201ec00), %o3
2007d78: 96 12 e0 40 or %o3, 0x40, %o3 ! 201ec40 <_System_event_Sync_state>
2007d7c: 7f ff fe 54 call 20076cc <_Event_Surrender>
2007d80: b0 10 20 00 clr %i0
event_in,
&api->System_event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
2007d84: 40 00 0a 7d call 200a778 <_Thread_Enable_dispatch>
2007d88: 01 00 00 00 nop
sc = RTEMS_SUCCESSFUL;
break;
2007d8c: 81 c7 e0 08 ret
2007d90: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
break;
}
return sc;
}
2007d94: 81 c7 e0 08 ret <== NOT EXECUTED
2007d98: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
02007bf4 <rtems_fdisk_abort.constprop.1>:
*
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
2007bf4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:abort:");
2007bf8: 31 00 80 e1 sethi %hi(0x2038400), %i0 <== NOT EXECUTED
2007bfc: c2 06 23 30 ld [ %i0 + 0x330 ], %g1 ! 2038730 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
2007c00: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2007c04: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2007c08: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2007c0c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
2007c10: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007c14: d6 00 60 0c ld [ %g1 + 0xc ], %o3 <== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
2007c18: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007c1c: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
2007c20: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
2007c24: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007c28: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
2007c2c: 40 00 71 8b call 2024258 <fwrite> <== NOT EXECUTED
2007c30: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 20337e8 <__FUNCTION__.7127+0x850><== NOT EXECUTED
vfprintf (stderr, format, args);
2007c34: c2 06 23 30 ld [ %i0 + 0x330 ], %g1 <== NOT EXECUTED
2007c38: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
2007c3c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2007c40: 40 00 6f d9 call 2023ba4 <fputs> <== NOT EXECUTED
2007c44: 90 12 23 f8 or %o0, 0x3f8, %o0 <== NOT EXECUTED
fprintf (stderr, "\n");
2007c48: c2 06 23 30 ld [ %i0 + 0x330 ], %g1 <== NOT EXECUTED
2007c4c: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
2007c50: 40 00 6f a1 call 2023ad4 <fputc> <== NOT EXECUTED
2007c54: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
2007c58: c2 06 23 30 ld [ %i0 + 0x330 ], %g1 <== NOT EXECUTED
2007c5c: 40 00 6e 86 call 2023674 <fflush> <== NOT EXECUTED
2007c60: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
2007c64: 40 00 6d 84 call 2023274 <exit> <== NOT EXECUTED
2007c68: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
02005c30 <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)
{
2005c30: 9d e3 bf 98 save %sp, -104, %sp
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
2005c34: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
2005c38: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2005c3c: 80 a0 80 01 cmp %g2, %g1
2005c40: 1a 80 00 20 bcc 2005cc0 <rtems_fdisk_compact+0x90>
2005c44: a6 10 00 18 mov %i0, %l3
fd->starvations++;
2005c48: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " resolve starvation");
2005c4c: 90 10 00 18 mov %i0, %o0
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
2005c50: 82 00 60 01 inc %g1
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " resolve starvation");
2005c54: 13 00 80 cd sethi %hi(0x2033400), %o1
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
2005c58: c2 26 20 70 st %g1, [ %i0 + 0x70 ]
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " resolve starvation");
2005c5c: 7f ff fc a7 call 2004ef8 <rtems_fdisk_printf>
2005c60: 92 12 62 f0 or %o1, 0x2f0, %o1
* 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)
{
if (queue->head)
2005c64: fa 06 20 40 ld [ %i0 + 0x40 ], %i5
2005c68: 80 a7 60 00 cmp %i5, 0
2005c6c: 22 80 00 83 be,a 2005e78 <rtems_fdisk_compact+0x248> <== NEVER TAKEN
2005c70: fa 06 20 34 ld [ %i0 + 0x34 ], %i5 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
2005c74: c2 07 40 00 ld [ %i5 ], %g1
if (!queue->head)
2005c78: 80 a0 60 00 cmp %g1, 0
2005c7c: 02 80 00 9f be 2005ef8 <rtems_fdisk_compact+0x2c8> <== NEVER TAKEN
2005c80: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
queue->tail = 0;
queue->count--;
2005c84: c2 04 e0 48 ld [ %l3 + 0x48 ], %g1
2005c88: 82 00 7f ff add %g1, -1, %g1
2005c8c: c2 24 e0 48 st %g1, [ %l3 + 0x48 ]
sc->next = 0;
2005c90: c0 27 40 00 clr [ %i5 ]
if (!ssc)
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (ssc)
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005c94: 7f ff fc 59 call 2004df8 <rtems_fdisk_seg_most_available>
2005c98: 90 04 e0 34 add %l3, 0x34, %o0
if (dsc)
2005c9c: 94 92 20 00 orcc %o0, 0, %o2
2005ca0: 02 80 00 8b be 2005ecc <rtems_fdisk_compact+0x29c> <== NEVER TAKEN
2005ca4: 92 10 00 1d mov %i5, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005ca8: 90 10 00 13 mov %l3, %o0
2005cac: 7f ff fe d1 call 20057f0 <rtems_fdisk_recycle_segment>
2005cb0: 96 07 bf fc add %fp, -4, %o3
if (ret)
2005cb4: b0 92 20 00 orcc %o0, 0, %i0
2005cb8: 12 80 00 8e bne 2005ef0 <rtems_fdisk_compact+0x2c0> <== NEVER TAKEN
2005cbc: 01 00 00 00 nop
2005cc0: d2 04 e0 40 ld [ %l3 + 0x40 ], %o1
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005cc4: 21 00 80 cd sethi %hi(0x2033400), %l0
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005cc8: 23 00 80 cd sethi %hi(0x2033400), %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005ccc: 25 00 80 cd sethi %hi(0x2033400), %l2
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
2005cd0: b8 10 20 00 clr %i4
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005cd4: a0 14 23 20 or %l0, 0x320, %l0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005cd8: b2 04 e0 34 add %l3, 0x34, %i1
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005cdc: a2 14 63 68 or %l1, 0x368, %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005ce0: a4 14 a3 a0 or %l2, 0x3a0, %l2
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
2005ce4: 80 a2 60 00 cmp %o1, 0
2005ce8: 02 80 00 70 be 2005ea8 <rtems_fdisk_compact+0x278>
2005cec: 92 10 00 10 mov %l0, %o1
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005cf0: 7f ff fc 82 call 2004ef8 <rtems_fdisk_printf>
2005cf4: 90 10 00 13 mov %l3, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005cf8: 7f ff fc 40 call 2004df8 <rtems_fdisk_seg_most_available>
2005cfc: 90 10 00 19 mov %i1, %o0
if (dsc == 0)
2005d00: b4 92 20 00 orcc %o0, 0, %i2
2005d04: 02 80 00 6b be 2005eb0 <rtems_fdisk_compact+0x280> <== NEVER TAKEN
2005d08: 11 00 80 cd sethi %hi(0x2033400), %o0
* with the most available number of pages and see if we have
* 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)
2005d0c: f6 06 a0 24 ld [ %i2 + 0x24 ], %i3
2005d10: c6 06 a0 20 ld [ %i2 + 0x20 ], %g3
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
2005d14: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
2005d18: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
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",
2005d1c: d4 06 a0 08 ld [ %i2 + 8 ], %o2
2005d20: d6 06 a0 0c ld [ %i2 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
2005d24: fa 04 e0 40 ld [ %l3 + 0x40 ], %i5
* with the most available number of pages and see if we have
* 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)
2005d28: b6 06 c0 03 add %i3, %g3, %i3
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
2005d2c: c0 27 bf fc clr [ %fp + -4 ]
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
2005d30: b6 20 80 1b sub %g2, %i3, %i3
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",
2005d34: 90 10 00 13 mov %l3, %o0
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
2005d38: b6 26 c0 01 sub %i3, %g1, %i3
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",
2005d3c: 7f ff fc 6f call 2004ef8 <rtems_fdisk_printf>
2005d40: 92 10 00 11 mov %l1, %o1
* 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 &&
2005d44: 80 a7 60 00 cmp %i5, 0
2005d48: 02 80 00 1b be 2005db4 <rtems_fdisk_compact+0x184> <== NEVER TAKEN
2005d4c: c2 07 bf fc ld [ %fp + -4 ], %g1
((pages + ssc->pages_active) < dst_pages) &&
2005d50: d8 07 60 1c ld [ %i5 + 0x1c ], %o4
2005d54: 98 00 40 0c add %g1, %o4, %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 &&
2005d58: 80 a6 c0 0c cmp %i3, %o4
2005d5c: 28 80 00 45 bleu,a 2005e70 <rtems_fdisk_compact+0x240>
2005d60: 98 10 00 01 mov %g1, %o4
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
2005d64: c6 04 e0 0c ld [ %l3 + 0xc ], %g3
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
2005d68: 80 a7 00 03 cmp %i4, %g3
2005d6c: 3a 80 00 41 bcc,a 2005e70 <rtems_fdisk_compact+0x240> <== NEVER TAKEN
2005d70: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED
2005d74: 10 80 00 0b b 2005da0 <rtems_fdisk_compact+0x170>
2005d78: 9a 10 20 00 clr %o5
2005d7c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2005d80: 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 &&
2005d84: 80 a0 40 1b cmp %g1, %i3
2005d88: 1a 80 00 12 bcc 2005dd0 <rtems_fdisk_compact+0x1a0>
2005d8c: 84 07 00 0d add %i4, %o5, %g2
((pages + ssc->pages_active) < dst_pages) &&
2005d90: 80 a0 80 03 cmp %g2, %g3
2005d94: 3a 80 00 10 bcc,a 2005dd4 <rtems_fdisk_compact+0x1a4> <== NEVER TAKEN
2005d98: d8 27 bf fc st %o4, [ %fp + -4 ] <== NOT EXECUTED
2005d9c: 98 10 00 01 mov %g1, %o4
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
ssc = ssc->next;
2005da0: fa 07 40 00 ld [ %i5 ], %i5
* 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 &&
2005da4: 80 a7 60 00 cmp %i5, 0
2005da8: 12 bf ff f5 bne 2005d7c <rtems_fdisk_compact+0x14c>
2005dac: 9a 03 60 01 inc %o5
2005db0: d8 27 bf fc st %o4, [ %fp + -4 ]
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
2005db4: 90 10 00 13 mov %l3, %o0
2005db8: 13 00 80 cd sethi %hi(0x2033400), %o1
}
compacted_segs += segments;
}
return 0;
2005dbc: b0 10 20 00 clr %i0
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
2005dc0: 7f ff fc 4e call 2004ef8 <rtems_fdisk_printf>
2005dc4: 92 12 63 88 or %o1, 0x388, %o1
#endif
break;
2005dc8: 81 c7 e0 08 ret
2005dcc: 81 e8 00 00 restore
2005dd0: 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))
2005dd4: 80 a3 20 00 cmp %o4, 0
2005dd8: 02 bf ff f8 be 2005db8 <rtems_fdisk_compact+0x188>
2005ddc: 90 10 00 13 mov %l3, %o0
2005de0: b8 07 00 0d add %i4, %o5, %i4
2005de4: 80 a7 20 01 cmp %i4, 1
2005de8: 22 bf ff f5 be,a 2005dbc <rtems_fdisk_compact+0x18c>
2005dec: 13 00 80 cd sethi %hi(0x2033400), %o1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005df0: d4 07 60 08 ld [ %i5 + 8 ], %o2
2005df4: d6 07 60 0c ld [ %i5 + 0xc ], %o3
2005df8: 92 10 00 12 mov %l2, %o1
2005dfc: 7f ff fc 3f call 2004ef8 <rtems_fdisk_printf>
2005e00: 90 10 00 13 mov %l3, %o0
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
2005e04: 90 10 00 19 mov %i1, %o0
2005e08: 7f ff fb 9b call 2004c74 <rtems_fdisk_segment_queue_remove>
2005e0c: 92 10 00 1a mov %i2, %o1
2005e10: c2 07 bf fc ld [ %fp + -4 ], %g1
2005e14: d2 04 e0 40 ld [ %l3 + 0x40 ], %o1
/*
* We now copy the pages to the new segment.
*/
while (pages)
2005e18: 80 a0 60 00 cmp %g1, 0
2005e1c: 02 bf ff b3 be 2005ce8 <rtems_fdisk_compact+0xb8>
2005e20: 80 a2 60 00 cmp %o1, 0
* 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)
{
if (queue->head)
2005e24: 02 bf ff fe be 2005e1c <rtems_fdisk_compact+0x1ec> <== NEVER TAKEN
2005e28: 80 a0 60 00 cmp %g1, 0
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
2005e2c: c2 02 40 00 ld [ %o1 ], %g1
if (!queue->head)
2005e30: 80 a0 60 00 cmp %g1, 0
2005e34: 02 80 00 24 be 2005ec4 <rtems_fdisk_compact+0x294> <== NEVER TAKEN
2005e38: c2 24 e0 40 st %g1, [ %l3 + 0x40 ]
queue->tail = 0;
queue->count--;
2005e3c: c2 04 e0 48 ld [ %l3 + 0x48 ], %g1
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (ssc)
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005e40: 90 10 00 13 mov %l3, %o0
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
queue->count--;
2005e44: 82 00 7f ff add %g1, -1, %g1
2005e48: c2 24 e0 48 st %g1, [ %l3 + 0x48 ]
sc->next = 0;
2005e4c: c0 22 40 00 clr [ %o1 ]
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (ssc)
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005e50: 94 10 00 1a mov %i2, %o2
2005e54: 7f ff fe 67 call 20057f0 <rtems_fdisk_recycle_segment>
2005e58: 96 07 bf fc add %fp, -4, %o3
if (ret)
2005e5c: b0 92 20 00 orcc %o0, 0, %i0
2005e60: 02 bf ff ed be 2005e14 <rtems_fdisk_compact+0x1e4> <== ALWAYS TAKEN
2005e64: c2 07 bf fc ld [ %fp + -4 ], %g1
compacted_segs += segments;
}
return 0;
}
2005e68: 81 c7 e0 08 ret <== NOT EXECUTED
2005e6c: 81 e8 00 00 restore <== NOT EXECUTED
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
2005e70: 10 bf ff d9 b 2005dd4 <rtems_fdisk_compact+0x1a4>
2005e74: 9a 10 20 00 clr %o5
* 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)
{
if (queue->head)
2005e78: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2005e7c: 02 80 00 1a be 2005ee4 <rtems_fdisk_compact+0x2b4> <== NOT EXECUTED
2005e80: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
2005e84: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
if (!queue->head)
2005e88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005e8c: 02 80 00 1d be 2005f00 <rtems_fdisk_compact+0x2d0> <== NOT EXECUTED
2005e90: c2 24 e0 34 st %g1, [ %l3 + 0x34 ] <== NOT EXECUTED
queue->tail = 0;
queue->count--;
2005e94: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED
2005e98: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2005e9c: c2 24 e0 3c st %g1, [ %l3 + 0x3c ] <== NOT EXECUTED
sc->next = 0;
2005ea0: 10 bf ff 7d b 2005c94 <rtems_fdisk_compact+0x64> <== NOT EXECUTED
2005ea4: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
}
compacted_segs += segments;
}
return 0;
2005ea8: 81 c7 e0 08 ret
2005eac: 91 e8 20 00 restore %g0, 0, %o0
dsc = rtems_fdisk_seg_most_available (&fd->available);
if (dsc == 0)
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
2005eb0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
dsc = rtems_fdisk_seg_most_available (&fd->available);
if (dsc == 0)
{
rtems_fdisk_error ("compacting: no available segments to compact too");
2005eb4: 7f ff fc eb call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2005eb8: 90 12 23 30 or %o0, 0x330, %o0 <== NOT EXECUTED
2005ebc: 81 c7 e0 08 ret <== NOT EXECUTED
2005ec0: 81 e8 00 00 restore <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
2005ec4: 10 bf ff de b 2005e3c <rtems_fdisk_compact+0x20c> <== NOT EXECUTED
2005ec8: c0 24 e0 44 clr [ %l3 + 0x44 ] <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
2005ecc: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
return EIO;
2005ed0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
2005ed4: 7f ff fc e3 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2005ed8: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
2005edc: 81 c7 e0 08 ret <== NOT EXECUTED
2005ee0: 81 e8 00 00 restore <== NOT EXECUTED
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
2005ee4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
2005ee8: 7f ff fc de call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2005eec: 90 12 23 c8 or %o0, 0x3c8, %o0 <== NOT EXECUTED
2005ef0: 81 c7 e0 08 ret <== NOT EXECUTED
2005ef4: 81 e8 00 00 restore <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
2005ef8: 10 bf ff 63 b 2005c84 <rtems_fdisk_compact+0x54> <== NOT EXECUTED
2005efc: c0 26 20 44 clr [ %i0 + 0x44 ] <== NOT EXECUTED
2005f00: 10 bf ff e5 b 2005e94 <rtems_fdisk_compact+0x264> <== NOT EXECUTED
2005f04: c0 24 e0 38 clr [ %l3 + 0x38 ] <== NOT EXECUTED
020052dc <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
20052dc: 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;
20052e0: d2 06 60 08 ld [ %i1 + 8 ], %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;
20052e4: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
20052e8: 87 2a 60 04 sll %o1, 4, %g3
20052ec: 83 2a 60 02 sll %o1, 2, %g1
20052f0: 82 20 c0 01 sub %g3, %g1, %g1
20052f4: 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;
20052f8: c6 00 e0 08 ld [ %g3 + 8 ], %g3
uint32_t device;
uint32_t segment;
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
20052fc: d4 06 60 0c ld [ %i1 + 0xc ], %o2
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
2005300: f8 00 e0 08 ld [ %g3 + 8 ], %i4
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;
2005304: c6 00 80 01 ld [ %g2 + %g1 ], %g3
2005308: 89 2a a0 06 sll %o2, 6, %g4
200530c: 85 2a a0 04 sll %o2, 4, %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);
2005310: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
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: 84 21 00 02 sub %g4, %g2, %g2
2005318: 84 00 c0 02 add %g3, %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);
200531c: d0 00 a0 04 ld [ %g2 + 4 ], %o0
2005320: 9f c0 40 00 call %g1
2005324: ba 10 00 18 mov %i0, %i5
if (ret)
2005328: b0 92 20 00 orcc %o0, 0, %i0
200532c: 22 80 00 24 be,a 20053bc <rtems_fdisk_erase_segment+0xe0><== ALWAYS TAKEN
2005330: c6 07 60 28 ld [ %i5 + 0x28 ], %g3
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
2005334: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2005338: 40 00 81 a7 call 20259d4 <strerror> <== NOT EXECUTED
200533c: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
2005340: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2005344: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2005348: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
200534c: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
2005350: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
2005354: 7f ff ff c3 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2005358: 90 12 20 d8 or %o0, 0xd8, %o0 <== 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;
200535c: c2 07 60 58 ld [ %i5 + 0x58 ], %g1 <== NOT EXECUTED
if (ret)
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
2005360: 84 10 20 01 mov 1, %g2 <== 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)
2005364: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005368: 02 80 00 36 be 2005440 <rtems_fdisk_erase_segment+0x164> <== NOT EXECUTED
200536c: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED
{
if (it == sc)
2005370: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
2005374: 32 80 00 06 bne,a 200538c <rtems_fdisk_erase_segment+0xb0><== NOT EXECUTED
2005378: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
200537c: 30 80 00 35 b,a 2005450 <rtems_fdisk_erase_segment+0x174><== NOT EXECUTED
2005380: 02 80 00 34 be 2005450 <rtems_fdisk_erase_segment+0x174> <== NOT EXECUTED
2005384: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
2005388: 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)
200538c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005390: 12 bf ff fc bne 2005380 <rtems_fdisk_erase_segment+0xa4> <== NOT EXECUTED
2005394: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
2005398: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
200539c: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
20053a0: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
20053a4: f2 27 60 5c st %i1, [ %i5 + 0x5c ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
20053a8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
20053ac: 82 00 60 01 inc %g1 <== NOT EXECUTED
20053b0: c2 27 60 60 st %g1, [ %i5 + 0x60 ] <== NOT EXECUTED
20053b4: 81 c7 e0 08 ret <== NOT EXECUTED
20053b8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
20053bc: c2 06 60 2c ld [ %i1 + 0x2c ], %g1
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;
20053c0: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
20053c4: d2 06 60 18 ld [ %i1 + 0x18 ], %o1
20053c8: 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++;
20053cc: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
20053d0: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
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;
20053d4: 84 00 c0 02 add %g3, %g2, %g2
20053d8: c4 27 60 28 st %g2, [ %i5 + 0x28 ]
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
20053dc: 7f ff f4 74 call 20025ac <.umul>
20053e0: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
20053e4: 92 10 20 ff mov 0xff, %o1
20053e8: 94 10 00 08 mov %o0, %o2
20053ec: 40 00 7c b2 call 20246b4 <memset>
20053f0: 90 10 00 1c mov %i4, %o0
{
if (sc)
{
sc->next = 0;
if (queue->head)
20053f4: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
fd->erased_blocks += sc->pages;
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
sc->pages_active = 0;
20053f8: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
20053fc: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
2005400: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
2005404: c0 26 60 28 clr [ %i1 + 0x28 ]
{
if (sc)
{
sc->next = 0;
if (queue->head)
2005408: 80 a0 60 00 cmp %g1, 0
200540c: 02 80 00 0a be 2005434 <rtems_fdisk_erase_segment+0x158>
2005410: c0 26 40 00 clr [ %i1 ]
{
queue->tail->next = sc;
2005414: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
2005418: f2 20 40 00 st %i1, [ %g1 ]
queue->tail = sc;
200541c: f2 27 60 38 st %i1, [ %i5 + 0x38 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
2005420: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2005424: 82 00 60 01 inc %g1
2005428: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
200542c: 81 c7 e0 08 ret
2005430: 81 e8 00 00 restore
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
2005434: f2 27 60 38 st %i1, [ %i5 + 0x38 ]
2005438: 10 bf ff fa b 2005420 <rtems_fdisk_erase_segment+0x144>
200543c: f2 27 60 34 st %i1, [ %i5 + 0x34 ]
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
2005440: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
2005444: f2 27 60 5c st %i1, [ %i5 + 0x5c ] <== NOT EXECUTED
2005448: 10 bf ff d8 b 20053a8 <rtems_fdisk_erase_segment+0xcc> <== NOT EXECUTED
200544c: f2 27 60 58 st %i1, [ %i5 + 0x58 ] <== NOT EXECUTED
2005450: 81 c7 e0 08 ret <== NOT EXECUTED
2005454: 81 e8 00 00 restore <== NOT EXECUTED
02005260 <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, ...)
{
2005260: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
2005264: 21 00 80 e1 sethi %hi(0x2038400), %l0 <== NOT EXECUTED
2005268: c2 04 23 30 ld [ %l0 + 0x330 ], %g1 ! 2038730 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
200526c: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2005270: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2005274: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2005278: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
200527c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
2005280: d6 00 60 0c ld [ %g1 + 0xc ], %o3 <== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
2005284: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
2005288: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
200528c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
2005290: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
2005294: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
2005298: 40 00 7b f0 call 2024258 <fwrite> <== NOT EXECUTED
200529c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20334c8 <__FUNCTION__.7127+0x530><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
20052a0: c2 04 23 30 ld [ %l0 + 0x330 ], %g1 <== NOT EXECUTED
20052a4: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
20052a8: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
20052ac: 40 00 9c a2 call 202c534 <vfprintf> <== NOT EXECUTED
20052b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
20052b4: c2 04 23 30 ld [ %l0 + 0x330 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
20052b8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
20052bc: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
20052c0: 40 00 7a 05 call 2023ad4 <fputc> <== NOT EXECUTED
20052c4: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
20052c8: c2 04 23 30 ld [ %l0 + 0x330 ], %g1 <== NOT EXECUTED
20052cc: 40 00 78 ea call 2023674 <fflush> <== NOT EXECUTED
20052d0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
20052d4: 81 c7 e0 08 ret <== NOT EXECUTED
20052d8: 81 e8 00 00 restore <== NOT EXECUTED
02004e70 <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, ...)
{
2004e70: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004e74: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2004e78: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2004e7c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2004e80: 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)
2004e84: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
2004e88: 80 a0 60 01 cmp %g1, 1
2004e8c: 08 80 00 19 bleu 2004ef0 <rtems_fdisk_info+0x80> <== ALWAYS TAKEN
2004e90: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
2004e94: 3b 00 80 e1 sethi %hi(0x2038400), %i5 <== NOT EXECUTED
2004e98: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 ! 2038730 <_impure_ptr><== NOT EXECUTED
2004e9c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2004ea0: d6 00 60 08 ld [ %g1 + 8 ], %o3 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004ea4: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
2004ea8: 94 10 20 06 mov 6, %o2 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004eac: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
2004eb0: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
2004eb4: 40 00 7c e9 call 2024258 <fwrite> <== NOT EXECUTED
2004eb8: 90 12 20 38 or %o0, 0x38, %o0 ! 2033438 <__FUNCTION__.7127+0x4a0><== NOT EXECUTED
ret = vfprintf (stdout, format, args);
2004ebc: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
2004ec0: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2004ec4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2004ec8: 40 00 9d 9b call 202c534 <vfprintf> <== NOT EXECUTED
2004ecc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2004ed0: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
2004ed4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
2004ed8: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2004edc: 40 00 7a fe call 2023ad4 <fputc> <== NOT EXECUTED
2004ee0: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
2004ee4: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
2004ee8: 40 00 79 e3 call 2023674 <fflush> <== NOT EXECUTED
2004eec: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2004ef0: 81 c7 e0 08 ret
2004ef4: 81 e8 00 00 restore
020076c0 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
20076c0: 9d e3 bf 80 save %sp, -128, %sp
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
20076c4: 7f ff f5 12 call 2004b0c <rtems_disk_io_initialize>
20076c8: a4 10 00 18 mov %i0, %l2
if (sc != RTEMS_SUCCESSFUL)
20076cc: b0 92 20 00 orcc %o0, 0, %i0
20076d0: 02 80 00 04 be 20076e0 <rtems_fdisk_initialize+0x20> <== ALWAYS TAKEN
20076d4: 01 00 00 00 nop
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
20076d8: 81 c7 e0 08 ret <== NOT EXECUTED
20076dc: 81 e8 00 00 restore <== NOT EXECUTED
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
20076e0: 40 00 05 e6 call 2008e78 <malloc>
20076e4: 90 10 22 00 mov 0x200, %o0
20076e8: 03 00 81 23 sethi %hi(0x2048c00), %g1
20076ec: d0 20 60 b8 st %o0, [ %g1 + 0xb8 ] ! 2048cb8 <rtems_fdisk_crc16_factor>
if (!rtems_fdisk_crc16_factor)
20076f0: 80 a2 20 00 cmp %o0, 0
20076f4: 02 bf ff f9 be 20076d8 <rtems_fdisk_initialize+0x18> <== NEVER TAKEN
20076f8: 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;
20076fc: 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)
2007700: 86 10 20 00 clr %g3
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;
2007704: 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;
2007708: 82 10 00 03 mov %g3, %g1
200770c: 84 10 20 08 mov 8, %g2
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2007710: 80 88 60 01 btst 1, %g1
2007714: 83 28 60 10 sll %g1, 0x10, %g1
2007718: 02 80 00 03 be 2007724 <rtems_fdisk_initialize+0x64>
200771c: 83 30 60 11 srl %g1, 0x11, %g1
2007720: 82 18 40 04 xor %g1, %g4, %g1
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
2007724: 84 80 bf ff addcc %g2, -1, %g2
2007728: 12 bf ff fb bne 2007714 <rtems_fdisk_initialize+0x54>
200772c: 80 88 60 01 btst 1, %g1
* @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,
2007730: 85 28 e0 01 sll %g3, 1, %g2
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
2007734: 86 00 e0 01 inc %g3
2007738: 80 a0 e1 00 cmp %g3, 0x100
200773c: 12 bf ff f3 bne 2007708 <rtems_fdisk_initialize+0x48>
2007740: c2 32 00 02 sth %g1, [ %o0 + %g2 ]
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
2007744: 03 00 80 e1 sethi %hi(0x2038400), %g1
2007748: fa 00 60 cc ld [ %g1 + 0xcc ], %i5 ! 20384cc <rtems_flashdisk_configuration_size>
200774c: 92 10 20 74 mov 0x74, %o1
2007750: 90 10 00 1d mov %i5, %o0
2007754: 40 00 03 2f call 2008410 <calloc>
2007758: 35 00 81 23 sethi %hi(0x2048c00), %i2
200775c: d0 26 a0 b0 st %o0, [ %i2 + 0xb0 ] ! 2048cb0 <rtems_flashdisks>
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
2007760: 80 a2 20 00 cmp %o0, 0
2007764: 02 bf ff dd be 20076d8 <rtems_fdisk_initialize+0x18> <== NEVER TAKEN
2007768: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
200776c: 80 a7 60 00 cmp %i5, 0
2007770: 02 80 00 f6 be 2007b48 <rtems_fdisk_initialize+0x488> <== NEVER TAKEN
2007774: 21 00 80 ca sethi %hi(0x2032800), %l0
2007778: a6 10 20 00 clr %l3
200777c: a0 14 23 30 or %l0, 0x330, %l0
2007780: a2 10 20 00 clr %l1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
2007784: f8 04 20 0c ld [ %l0 + 0xc ], %i4
fd->compact_segs = c->compact_segs;
2007788: c8 04 20 14 ld [ %l0 + 0x14 ], %g4
fd->avail_compact_segs = c->avail_compact_segs;
200778c: c6 04 20 18 ld [ %l0 + 0x18 ], %g3
fd->block_size = c->block_size;
2007790: fa 04 00 00 ld [ %l0 ], %i5
fd->unavail_blocks = c->unavail_blocks;
2007794: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
fd->info_level = c->info_level;
2007798: c2 04 20 1c ld [ %l0 + 0x1c ], %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";
200779c: 35 00 00 18 sethi %hi(0x6000), %i2
20077a0: b4 16 a1 00 or %i2, 0x100, %i2 ! 6100 <PROM_START+0x6100>
20077a4: f4 37 bf f8 sth %i2, [ %fp + -8 ]
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++)
20077a8: e8 04 20 04 ld [ %l0 + 4 ], %l4
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
20077ac: e2 2f bf f9 stb %l1, [ %fp + -7 ]
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
20077b0: 35 0b d9 19 sethi %hi(0x2f646400), %i2
20077b4: 37 0b d9 99 sethi %hi(0x2f666400), %i3
20077b8: b4 16 a1 76 or %i2, 0x176, %i2
20077bc: b6 16 e0 64 or %i3, 0x64, %i3
20077c0: f4 3f bf f0 std %i2, [ %fp + -16 ]
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
20077c4: e4 22 00 13 st %l2, [ %o0 + %l3 ]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
20077c8: b6 02 00 13 add %o0, %l3, %i3
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
20077cc: e2 26 e0 04 st %l1, [ %i3 + 4 ]
fd->flags = c->flags;
20077d0: f8 26 e0 08 st %i4, [ %i3 + 8 ]
fd->compact_segs = c->compact_segs;
20077d4: c8 26 e0 0c st %g4, [ %i3 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
20077d8: c6 26 e0 10 st %g3, [ %i3 + 0x10 ]
fd->block_size = c->block_size;
20077dc: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
20077e0: c4 26 e0 20 st %g2, [ %i3 + 0x20 ]
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
20077e4: 80 a5 20 00 cmp %l4, 0
20077e8: 02 80 00 a3 be 2007a74 <rtems_fdisk_initialize+0x3b4> <== NEVER TAKEN
20077ec: c2 26 e0 6c st %g1, [ %i3 + 0x6c ]
20077f0: f4 04 20 08 ld [ %l0 + 8 ], %i2
* @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,
20077f4: 83 2d 20 02 sll %l4, 2, %g1
20077f8: b1 2d 20 04 sll %l4, 4, %i0
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;
20077fc: b2 10 20 00 clr %i1
* @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,
2007800: b0 26 00 01 sub %i0, %g1, %i0
2007804: b0 06 80 18 add %i2, %i0, %i0
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
2007808: c4 06 80 00 ld [ %i2 ], %g2
200780c: 80 a0 a0 00 cmp %g2, 0
2007810: 02 80 00 93 be 2007a5c <rtems_fdisk_initialize+0x39c> <== NEVER TAKEN
2007814: 87 28 a0 02 sll %g2, 2, %g3
2007818: ea 06 a0 04 ld [ %i2 + 4 ], %l5
* @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,
200781c: b9 28 a0 04 sll %g2, 4, %i4
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
2007820: ae 10 20 00 clr %l7
* @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,
2007824: b8 27 00 03 sub %i4, %g3, %i4
2007828: b8 05 40 1c add %l5, %i4, %i4
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
200782c: d0 05 60 08 ld [ %l5 + 8 ], %o0
2007830: 7f ff eb 99 call 2002694 <.udiv>
2007834: 92 10 00 1d mov %i5, %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;
2007838: 92 10 00 1d mov %i5, %o1
200783c: 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);
2007840: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
2007844: 7f ff eb 94 call 2002694 <.udiv>
2007848: 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;
200784c: d2 15 40 00 lduh [ %l5 ], %o1
2007850: 7f ff eb 57 call 20025ac <.umul>
2007854: 90 25 80 08 sub %l6, %o0, %o0
2007858: aa 05 60 0c add %l5, 0xc, %l5
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++)
200785c: 80 a5 40 1c cmp %l5, %i4
2007860: 12 bf ff f3 bne 200782c <rtems_fdisk_initialize+0x16c> <== NEVER TAKEN
2007864: ae 05 c0 08 add %l7, %o0, %l7
2007868: b4 06 a0 0c add %i2, 0xc, %i2
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++)
200786c: 80 a6 80 18 cmp %i2, %i0
2007870: 12 bf ff e6 bne 2007808 <rtems_fdisk_initialize+0x148> <== NEVER TAKEN
2007874: b2 06 40 17 add %i1, %l7, %i1
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
2007878: 40 00 05 80 call 2008e78 <malloc>
200787c: 90 10 00 1d mov %i5, %o0
if (!fd->copy_buffer)
2007880: 80 a2 20 00 cmp %o0, 0
2007884: 02 80 00 af be 2007b40 <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
2007888: d0 26 e0 68 st %o0, [ %i3 + 0x68 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
200788c: 90 10 00 19 mov %i1, %o0
2007890: 40 00 02 e0 call 2008410 <calloc>
2007894: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
2007898: 80 a2 20 00 cmp %o0, 0
200789c: 02 80 00 a9 be 2007b40 <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
20078a0: d0 26 e0 18 st %o0, [ %i3 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
20078a4: f2 26 e0 1c st %i1, [ %i3 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
20078a8: 90 10 00 14 mov %l4, %o0
20078ac: 40 00 02 d9 call 2008410 <calloc>
20078b0: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
20078b4: 80 a2 20 00 cmp %o0, 0
20078b8: 02 80 00 a2 be 2007b40 <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
20078bc: d0 26 e0 2c st %o0, [ %i3 + 0x2c ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
20078c0: 03 00 80 cf sethi %hi(0x2033c00), %g1
20078c4: d0 00 63 e0 ld [ %g1 + 0x3e0 ], %o0 ! 2033fe0 <__FUNCTION__.7127+0x1048>
20078c8: 92 10 20 01 mov 1, %o1
20078cc: 94 10 20 54 mov 0x54, %o2
20078d0: 96 10 20 00 clr %o3
20078d4: 40 00 16 be call 200d3cc <rtems_semaphore_create>
20078d8: 98 06 e0 64 add %i3, 0x64, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
20078dc: b0 92 20 00 orcc %o0, 0, %i0
20078e0: 12 80 00 8d bne 2007b14 <rtems_fdisk_initialize+0x454> <== NEVER TAKEN
20078e4: b4 07 bf f0 add %fp, -16, %i2
free (fd->blocks);
free (fd->devices);
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
20078e8: d6 06 e0 20 ld [ %i3 + 0x20 ], %o3
20078ec: d4 04 00 00 ld [ %l0 ], %o2
20078f0: 90 10 00 12 mov %l2, %o0
20078f4: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
20078f8: 92 10 00 11 mov %l1, %o1
20078fc: 96 26 40 0b sub %i1, %o3, %o3
2007900: 19 00 80 18 sethi %hi(0x2006000), %o4
2007904: 9a 10 20 00 clr %o5
2007908: 7f ff f3 e1 call 200488c <rtems_disk_create_phys>
200790c: 98 13 22 dc or %o4, 0x2dc, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
2007910: b0 92 20 00 orcc %o0, 0, %i0
2007914: 12 80 00 70 bne 2007ad4 <rtems_fdisk_initialize+0x414> <== NEVER TAKEN
2007918: 01 00 00 00 nop
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
200791c: f0 04 20 04 ld [ %l0 + 4 ], %i0
2007920: 80 a6 20 00 cmp %i0, 0
2007924: 22 80 00 3b be,a 2007a10 <rtems_fdisk_initialize+0x350> <== NEVER TAKEN
2007928: f0 26 e0 30 st %i0, [ %i3 + 0x30 ] <== NOT EXECUTED
200792c: f4 04 20 08 ld [ %l0 + 8 ], %i2
2007930: f2 06 e0 2c ld [ %i3 + 0x2c ], %i1
2007934: ba 10 20 00 clr %i5
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++)
2007938: c4 06 80 00 ld [ %i2 ], %g2
200793c: 80 a0 a0 00 cmp %g2, 0
2007940: 02 80 00 5d be 2007ab4 <rtems_fdisk_initialize+0x3f4> <== NEVER TAKEN
2007944: a9 28 a0 02 sll %g2, 2, %l4
2007948: c2 06 a0 04 ld [ %i2 + 4 ], %g1
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
200794c: b8 10 20 00 clr %i4
* @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,
2007950: 85 28 a0 04 sll %g2, 4, %g2
2007954: 88 20 80 14 sub %g2, %l4, %g4
2007958: 88 00 40 04 add %g1, %g4, %g4
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++)
count += dd->segments[segment].count;
200795c: c6 10 40 00 lduh [ %g1 ], %g3
2007960: 82 00 60 0c add %g1, 0xc, %g1
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++)
2007964: 80 a0 40 04 cmp %g1, %g4
2007968: 12 bf ff fd bne 200795c <rtems_fdisk_initialize+0x29c> <== NEVER TAKEN
200796c: b8 07 00 03 add %i4, %g3, %i4
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
2007970: c4 27 bf ec st %g2, [ %fp + -20 ]
2007974: 90 10 00 1c mov %i4, %o0
2007978: 40 00 02 a6 call 2008410 <calloc>
200797c: 92 10 20 30 mov 0x30, %o1
2007980: d0 26 40 00 st %o0, [ %i1 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
2007984: 80 a2 20 00 cmp %o0, 0
2007988: 02 80 00 3d be 2007a7c <rtems_fdisk_initialize+0x3bc> <== NEVER TAKEN
200798c: c4 07 bf ec ld [ %fp + -20 ], %g2
2007990: c6 06 a0 04 ld [ %i2 + 4 ], %g3
* @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,
2007994: 84 20 80 14 sub %g2, %l4, %g2
2007998: 9e 00 c0 02 add %g3, %g2, %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++)
200799c: c8 10 c0 00 lduh [ %g3 ], %g4
20079a0: 80 a1 20 00 cmp %g4, 0
20079a4: 02 80 00 0f be 20079e0 <rtems_fdisk_initialize+0x320> <== NEVER TAKEN
20079a8: 82 10 00 08 mov %o0, %g1
20079ac: 84 10 20 00 clr %g2
{
sc->descriptor = sd;
sc->device = device;
sc->segment = seg_segment;
20079b0: c4 20 60 0c st %g2, [ %g1 + 0xc ]
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
{
sc->descriptor = sd;
20079b4: c6 20 60 04 st %g3, [ %g1 + 4 ]
sc->device = device;
20079b8: fa 20 60 08 st %i5, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
20079bc: 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++)
20079c0: 84 00 a0 01 inc %g2
20079c4: 80 a0 80 04 cmp %g2, %g4
20079c8: 0a bf ff fa bcs 20079b0 <rtems_fdisk_initialize+0x2f0>
20079cc: 82 00 60 30 add %g1, 0x30, %g1
* @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,
20079d0: 83 29 20 04 sll %g4, 4, %g1
20079d4: 89 29 20 06 sll %g4, 6, %g4
20079d8: 88 21 00 01 sub %g4, %g1, %g4
20079dc: 90 02 00 04 add %o0, %g4, %o0
20079e0: 86 00 e0 0c add %g3, 0xc, %g3
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
20079e4: 80 a0 c0 0f cmp %g3, %o7
20079e8: 32 bf ff ee bne,a 20079a0 <rtems_fdisk_initialize+0x2e0> <== NEVER TAKEN
20079ec: c8 10 c0 00 lduh [ %g3 ], %g4 <== NOT EXECUTED
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
20079f0: f4 26 60 08 st %i2, [ %i1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
20079f4: f8 26 60 04 st %i4, [ %i1 + 4 ]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
20079f8: ba 07 60 01 inc %i5
20079fc: b4 06 a0 0c add %i2, 0xc, %i2
2007a00: 80 a7 40 18 cmp %i5, %i0
2007a04: 12 bf ff cd bne 2007938 <rtems_fdisk_initialize+0x278> <== NEVER TAKEN
2007a08: b2 06 60 0c add %i1, 0xc, %i1
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
}
fd->device_count = c->device_count;
2007a0c: f0 26 e0 30 st %i0, [ %i3 + 0x30 ]
ret = rtems_fdisk_recover_block_mappings (fd);
2007a10: 7f ff f9 3e call 2005f08 <rtems_fdisk_recover_block_mappings>
2007a14: 90 10 00 1b mov %i3, %o0
if (ret)
2007a18: b0 92 20 00 orcc %o0, 0, %i0
2007a1c: 12 80 00 63 bne 2007ba8 <rtems_fdisk_initialize+0x4e8> <== NEVER TAKEN
2007a20: 92 10 00 11 mov %l1, %o1
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
2007a24: 7f ff f8 83 call 2005c30 <rtems_fdisk_compact>
2007a28: 90 10 00 1b mov %i3, %o0
if (ret)
2007a2c: b0 92 20 00 orcc %o0, 0, %i0
2007a30: 12 80 00 4a bne 2007b58 <rtems_fdisk_initialize+0x498> <== NEVER TAKEN
2007a34: a0 04 20 20 add %l0, 0x20, %l0
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
2007a38: 37 00 80 e1 sethi %hi(0x2038400), %i3
2007a3c: fa 06 e0 cc ld [ %i3 + 0xcc ], %i5 ! 20384cc <rtems_flashdisk_configuration_size>
2007a40: a2 04 60 01 inc %l1
2007a44: 80 a7 40 11 cmp %i5, %l1
2007a48: 08 80 00 40 bleu 2007b48 <rtems_fdisk_initialize+0x488> <== ALWAYS TAKEN
2007a4c: a6 04 e0 74 add %l3, 0x74, %l3
2007a50: 03 00 81 23 sethi %hi(0x2048c00), %g1 <== NOT EXECUTED
2007a54: 10 bf ff 4c b 2007784 <rtems_fdisk_initialize+0xc4> <== NOT EXECUTED
2007a58: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 2048cb0 <rtems_flashdisks><== NOT EXECUTED
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
2007a5c: ae 10 20 00 clr %l7 <== NOT EXECUTED
2007a60: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
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++)
2007a64: 80 a6 80 18 cmp %i2, %i0 <== NOT EXECUTED
2007a68: 12 bf ff 68 bne 2007808 <rtems_fdisk_initialize+0x148> <== NOT EXECUTED
2007a6c: b2 06 40 17 add %i1, %l7, %i1 <== NOT EXECUTED
2007a70: 30 bf ff 82 b,a 2007878 <rtems_fdisk_initialize+0x1b8> <== NOT EXECUTED
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;
2007a74: 10 bf ff 81 b 2007878 <rtems_fdisk_initialize+0x1b8> <== NOT EXECUTED
2007a78: b2 10 20 00 clr %i1 <== NOT EXECUTED
fd->devices[device].segments = calloc (segment_count,
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
{
rtems_disk_delete (dev);
2007a7c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2007a80: 7f ff f2 d2 call 20045c8 <rtems_disk_delete> <== NOT EXECUTED
2007a84: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007a88: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
2007a8c: 40 00 16 c1 call 200d590 <rtems_semaphore_delete> <== NOT EXECUTED
2007a90: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
free (fd->copy_buffer);
2007a94: 40 00 03 5c call 2008804 <free> <== NOT EXECUTED
2007a98: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007a9c: 40 00 03 5a call 2008804 <free> <== NOT EXECUTED
2007aa0: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007aa4: 40 00 03 58 call 2008804 <free> <== NOT EXECUTED
2007aa8: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
2007aac: 81 c7 e0 08 ret <== NOT EXECUTED
2007ab0: 81 e8 00 00 restore <== NOT EXECUTED
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
2007ab4: 90 10 20 00 clr %o0 <== NOT EXECUTED
2007ab8: 40 00 02 56 call 2008410 <calloc> <== NOT EXECUTED
2007abc: 92 10 20 30 mov 0x30, %o1 <== NOT EXECUTED
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
2007ac0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2007ac4: 02 bf ff ee be 2007a7c <rtems_fdisk_initialize+0x3bc> <== NOT EXECUTED
2007ac8: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
2007acc: 10 bf ff c9 b 20079f0 <rtems_fdisk_initialize+0x330> <== NOT EXECUTED
2007ad0: b8 10 20 00 clr %i4 <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_semaphore_delete (fd->lock);
2007ad4: 40 00 16 af call 200d590 <rtems_semaphore_delete> <== NOT EXECUTED
2007ad8: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
2007adc: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2007ae0: 7f ff f2 ba call 20045c8 <rtems_disk_delete> <== NOT EXECUTED
2007ae4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007ae8: 40 00 03 47 call 2008804 <free> <== NOT EXECUTED
2007aec: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007af0: 40 00 03 45 call 2008804 <free> <== NOT EXECUTED
2007af4: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007af8: 40 00 03 43 call 2008804 <free> <== NOT EXECUTED
2007afc: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
2007b00: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
2007b04: 7f ff f5 d7 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007b08: 90 12 23 78 or %o0, 0x378, %o0 ! 2033f78 <__FUNCTION__.7127+0xfe0><== NOT EXECUTED
2007b0c: 81 c7 e0 08 ret <== NOT EXECUTED
2007b10: 81 e8 00 00 restore <== NOT EXECUTED
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_fdisk_error ("disk lock create failed");
2007b14: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
2007b18: 7f ff f5 d2 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007b1c: 90 12 23 60 or %o0, 0x360, %o0 ! 2033f60 <__FUNCTION__.7127+0xfc8><== NOT EXECUTED
free (fd->copy_buffer);
2007b20: 40 00 03 39 call 2008804 <free> <== NOT EXECUTED
2007b24: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007b28: 40 00 03 37 call 2008804 <free> <== NOT EXECUTED
2007b2c: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007b30: 40 00 03 35 call 2008804 <free> <== NOT EXECUTED
2007b34: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
2007b38: 81 c7 e0 08 ret <== NOT EXECUTED
2007b3c: 81 e8 00 00 restore <== NOT EXECUTED
fd->block_count = blocks;
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
2007b40: 81 c7 e0 08 ret <== NOT EXECUTED
2007b44: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
2007b48: 03 00 81 23 sethi %hi(0x2048c00), %g1
2007b4c: fa 20 60 b4 st %i5, [ %g1 + 0xb4 ] ! 2048cb4 <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
2007b50: 81 c7 e0 08 ret
2007b54: 91 e8 20 00 restore %g0, 0, %o0
}
ret = rtems_fdisk_compact (fd);
if (ret)
{
rtems_disk_delete (dev);
2007b58: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2007b5c: 7f ff f2 9b call 20045c8 <rtems_disk_delete> <== NOT EXECUTED
2007b60: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007b64: 40 00 16 8b call 200d590 <rtems_semaphore_delete> <== NOT EXECUTED
2007b68: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007b6c: 40 00 03 26 call 2008804 <free> <== NOT EXECUTED
2007b70: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007b74: 40 00 03 24 call 2008804 <free> <== NOT EXECUTED
2007b78: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007b7c: 40 00 03 22 call 2008804 <free> <== NOT EXECUTED
2007b80: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
2007b84: 40 00 77 94 call 20259d4 <strerror> <== NOT EXECUTED
2007b88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2007b8c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2007b90: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2007b94: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
2007b98: 7f ff f5 b2 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007b9c: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 2033fb8 <__FUNCTION__.7127+0x1020><== NOT EXECUTED
2007ba0: 81 c7 e0 08 ret <== NOT EXECUTED
2007ba4: 81 e8 00 00 restore <== NOT EXECUTED
fd->device_count = c->device_count;
ret = rtems_fdisk_recover_block_mappings (fd);
if (ret)
{
rtems_disk_delete (dev);
2007ba8: 7f ff f2 88 call 20045c8 <rtems_disk_delete> <== NOT EXECUTED
2007bac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007bb0: 40 00 16 78 call 200d590 <rtems_semaphore_delete> <== NOT EXECUTED
2007bb4: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007bb8: 40 00 03 13 call 2008804 <free> <== NOT EXECUTED
2007bbc: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007bc0: 40 00 03 11 call 2008804 <free> <== NOT EXECUTED
2007bc4: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007bc8: 40 00 03 0f call 2008804 <free> <== NOT EXECUTED
2007bcc: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
2007bd0: 40 00 77 81 call 20259d4 <strerror> <== NOT EXECUTED
2007bd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2007bd8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2007bdc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2007be0: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
2007be4: 7f ff f5 9f call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007be8: 90 12 23 90 or %o0, 0x390, %o0 ! 2033f90 <__FUNCTION__.7127+0xff8><== NOT EXECUTED
2007bec: 81 c7 e0 08 ret <== NOT EXECUTED
2007bf0: 81 e8 00 00 restore <== NOT EXECUTED
020062dc <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)
{
20062dc: 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;
20062e0: 40 00 73 e2 call 2023268 <__errno>
20062e4: fa 06 20 04 ld [ %i0 + 4 ], %i5
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
20062e8: 21 00 81 23 sethi %hi(0x2048c00), %l0
20062ec: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 ! 2048cb0 <rtems_flashdisks>
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;
20062f0: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
20062f4: 85 2f 60 02 sll %i5, 2, %g2
20062f8: b9 2f 60 05 sll %i5, 5, %i4
20062fc: b8 27 00 02 sub %i4, %g2, %i4
2006300: b8 07 00 1d add %i4, %i5, %i4
2006304: b9 2f 20 02 sll %i4, 2, %i4
2006308: 82 00 40 1c add %g1, %i4, %g1
200630c: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
2006310: 92 10 20 00 clr %o1
2006314: 40 00 1c d6 call 200d66c <rtems_semaphore_obtain>
2006318: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
200631c: 80 a2 20 00 cmp %o0, 0
2006320: 12 80 00 36 bne 20063f8 <rtems_fdisk_ioctl+0x11c> <== NEVER TAKEN
2006324: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
2006328: 40 00 73 d0 call 2023268 <__errno>
200632c: 01 00 00 00 nop
switch (req)
2006330: 03 08 00 10 sethi %hi(0x20004000), %g1
2006334: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_END+0x1dc04283>
2006338: 80 a6 40 02 cmp %i1, %g2
200633c: 02 80 00 5b be 20064a8 <rtems_fdisk_ioctl+0x1cc> <== NEVER TAKEN
2006340: c0 22 00 00 clr [ %o0 ]
2006344: 80 a6 40 02 cmp %i1, %g2
2006348: 38 80 00 37 bgu,a 2006424 <rtems_fdisk_ioctl+0x148>
200634c: 82 10 62 85 or %g1, 0x285, %g1
2006350: 84 10 62 81 or %g1, 0x281, %g2
2006354: 80 a6 40 02 cmp %i1, %g2
2006358: 02 80 00 de be 20066d0 <rtems_fdisk_ioctl+0x3f4> <== NEVER TAKEN
200635c: 01 00 00 00 nop
2006360: 08 80 00 d0 bleu 20066a0 <rtems_fdisk_ioctl+0x3c4> <== ALWAYS TAKEN
2006364: 82 10 62 80 or %g1, 0x280, %g1
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
2006368: 40 00 73 c0 call 2023268 <__errno> <== NOT EXECUTED
200636c: b6 10 20 00 clr %i3 <== NOT EXECUTED
2006370: fa 04 20 b0 ld [ %l0 + 0xb0 ], %i5 <== NOT EXECUTED
2006374: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
2006378: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
* 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)
{
if (queue->head)
200637c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
2006380: 92 90 60 00 orcc %g1, 0, %o1 <== NOT EXECUTED
2006384: 02 80 00 15 be 20063d8 <rtems_fdisk_ioctl+0xfc> <== NOT EXECUTED
2006388: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
200638c: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
if (!queue->head)
2006390: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2006394: 02 80 01 09 be 20067b8 <rtems_fdisk_ioctl+0x4dc> <== NOT EXECUTED
2006398: c4 27 60 4c st %g2, [ %i5 + 0x4c ] <== NOT EXECUTED
queue->tail = 0;
queue->count--;
200639c: c4 07 60 54 ld [ %i5 + 0x54 ], %g2 <== NOT EXECUTED
20063a0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
20063a4: c4 27 60 54 st %g2, [ %i5 + 0x54 ] <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
20063a8: 7f ff fb cd call 20052dc <rtems_fdisk_erase_segment> <== NOT EXECUTED
20063ac: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
if (ret && !latched_ret)
20063b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20063b4: 02 bf ff f3 be 2006380 <rtems_fdisk_ioctl+0xa4> <== NOT EXECUTED
20063b8: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
20063bc: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
20063c0: 12 bf ff f0 bne 2006380 <rtems_fdisk_ioctl+0xa4> <== NOT EXECUTED
20063c4: 01 00 00 00 nop <== NOT EXECUTED
20063c8: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
* 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)
{
if (queue->head)
20063cc: 92 90 60 00 orcc %g1, 0, %o1 <== NOT EXECUTED
20063d0: 12 bf ff ef bne 200638c <rtems_fdisk_ioctl+0xb0> <== NOT EXECUTED
20063d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20063d8: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
20063dc: f6 26 80 00 st %i3, [ %i2 ] <== NOT EXECUTED
20063e0: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
20063e4: 40 00 1c f1 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
20063e8: d0 07 20 64 ld [ %i4 + 0x64 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20063ec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20063f0: 02 80 00 06 be 2006408 <rtems_fdisk_ioctl+0x12c> <== NOT EXECUTED
20063f4: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
20063f8: 40 00 73 9c call 2023268 <__errno> <== NOT EXECUTED
20063fc: 01 00 00 00 nop <== NOT EXECUTED
2006400: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2006404: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
2006408: 40 00 73 98 call 2023268 <__errno> <== NOT EXECUTED
200640c: 01 00 00 00 nop <== NOT EXECUTED
2006410: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2006414: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2006418: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
200641c: 81 c7 e0 08 ret <== NOT EXECUTED
2006420: 81 e8 00 00 restore <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
2006424: 80 a6 40 01 cmp %i1, %g1
2006428: 02 80 00 e6 be 20067c0 <rtems_fdisk_ioctl+0x4e4>
200642c: 01 00 00 00 nop
2006430: 0a 80 00 a5 bcs 20066c4 <rtems_fdisk_ioctl+0x3e8> <== NEVER TAKEN
2006434: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1
2006438: 03 30 06 10 sethi %hi(0xc0184000), %g1
200643c: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
2006440: 80 a6 40 01 cmp %i1, %g1
2006444: 12 80 00 9a bne 20066ac <rtems_fdisk_ioctl+0x3d0>
2006448: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
200644c: 03 00 81 23 sethi %hi(0x2048c00), %g1
2006450: c2 00 60 b4 ld [ %g1 + 0xb4 ], %g1 ! 2048cb4 <rtems_flashdisk_count>
2006454: 80 a0 40 1d cmp %g1, %i5
2006458: 08 80 02 0c bleu 2006c88 <rtems_fdisk_ioctl+0x9ac> <== NEVER TAKEN
200645c: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1
(rtems_flashdisks[minor].device_count == 0))
2006460: 82 00 40 1c add %g1, %i4, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
2006464: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
2006468: 80 a0 60 00 cmp %g1, 0
200646c: 02 80 02 07 be 2006c88 <rtems_fdisk_ioctl+0x9ac> <== NEVER TAKEN
2006470: 01 00 00 00 nop
{
errno = ENODEV;
}
else
{
switch (r->req)
2006474: c2 06 80 00 ld [ %i2 ], %g1
2006478: 80 a0 60 00 cmp %g1, 0
200647c: 02 80 03 a3 be 2007308 <rtems_fdisk_ioctl+0x102c>
2006480: 80 a0 60 01 cmp %g1, 1
2006484: 02 80 02 0a be 2006cac <rtems_fdisk_ioctl+0x9d0> <== ALWAYS TAKEN
2006488: 01 00 00 00 nop
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
break;
default:
errno = EINVAL;
200648c: 40 00 73 77 call 2023268 <__errno> <== NOT EXECUTED
2006490: 01 00 00 00 nop <== NOT EXECUTED
2006494: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
2006498: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
200649c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
break;
20064a0: 10 80 00 74 b 2006670 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
20064a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
20064a8: 40 00 73 70 call 2023268 <__errno> <== NOT EXECUTED
20064ac: 01 00 00 00 nop <== NOT EXECUTED
20064b0: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
20064b4: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
20064b8: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
20064bc: c8 07 20 14 ld [ %i4 + 0x14 ], %g4 <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
20064c0: c6 07 20 20 ld [ %i4 + 0x20 ], %g3 <== NOT EXECUTED
data->device_count = fd->device_count;
20064c4: c2 07 20 30 ld [ %i4 + 0x30 ], %g1 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
20064c8: c8 26 80 00 st %g4, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
20064cc: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
20064d0: c6 26 a0 08 st %g3, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
20064d4: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
20064d8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20064dc: 02 80 00 0f be 2006518 <rtems_fdisk_ioctl+0x23c> <== NOT EXECUTED
20064e0: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
20064e4: c8 07 20 18 ld [ %i4 + 0x18 ], %g4 <== NOT EXECUTED
* @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)
20064e8: 87 28 a0 03 sll %g2, 3, %g3 <== NOT EXECUTED
20064ec: 84 10 20 00 clr %g2 <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
20064f0: fa 01 00 02 ld [ %g4 + %g2 ], %i5 <== NOT EXECUTED
20064f4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
20064f8: 02 80 00 05 be 200650c <rtems_fdisk_ioctl+0x230> <== NOT EXECUTED
20064fc: 84 00 a0 08 add %g2, 8, %g2 <== NOT EXECUTED
data->blocks_used++;
2006500: fa 06 a0 18 ld [ %i2 + 0x18 ], %i5 <== NOT EXECUTED
2006504: ba 07 60 01 inc %i5 <== NOT EXECUTED
2006508: fa 26 a0 18 st %i5, [ %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++)
200650c: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
2006510: 32 bf ff f9 bne,a 20064f4 <rtems_fdisk_ioctl+0x218> <== NOT EXECUTED
2006514: fa 01 00 02 ld [ %g4 + %g2 ], %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;
2006518: c6 07 20 34 ld [ %i4 + 0x34 ], %g3 <== NOT EXECUTED
uint32_t count = 0;
while (sc)
200651c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006520: 02 80 00 06 be 2006538 <rtems_fdisk_ioctl+0x25c> <== NOT EXECUTED
2006524: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
count++;
sc = sc->next;
2006528: c6 00 c0 00 ld [ %g3 ], %g3 <== 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)
200652c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006530: 12 bf ff fe bne 2006528 <rtems_fdisk_ioctl+0x24c> <== NOT EXECUTED
2006534: 84 00 a0 01 inc %g2 <== 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;
2006538: c6 07 20 40 ld [ %i4 + 0x40 ], %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);
200653c: c4 26 a0 1c st %g2, [ %i2 + 0x1c ] <== 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)
2006540: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006544: 02 80 00 06 be 200655c <rtems_fdisk_ioctl+0x280> <== NOT EXECUTED
2006548: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
count++;
sc = sc->next;
200654c: c6 00 c0 00 ld [ %g3 ], %g3 <== 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)
2006550: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006554: 12 bf ff fe bne 200654c <rtems_fdisk_ioctl+0x270> <== NOT EXECUTED
2006558: 84 00 a0 01 inc %g2 <== 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;
200655c: c6 07 20 58 ld [ %i4 + 0x58 ], %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);
2006560: c4 26 a0 20 st %g2, [ %i2 + 0x20 ] <== 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)
2006564: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006568: 02 80 00 06 be 2006580 <rtems_fdisk_ioctl+0x2a4> <== NOT EXECUTED
200656c: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
count++;
sc = sc->next;
2006570: c6 00 c0 00 ld [ %g3 ], %g3 <== 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)
2006574: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006578: 12 bf ff fe bne 2006570 <rtems_fdisk_ioctl+0x294> <== NOT EXECUTED
200657c: 84 00 a0 01 inc %g2 <== 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);
2006580: c4 26 a0 24 st %g2, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
2006584: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
2006588: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
200658c: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
2006590: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
2006594: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
2006598: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
200659c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20065a0: 02 80 00 31 be 2006664 <rtems_fdisk_ioctl+0x388> <== NOT EXECUTED
20065a4: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
20065a8: e0 07 20 2c ld [ %i4 + 0x2c ], %l0 <== NOT EXECUTED
* @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)
20065ac: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED
20065b0: a2 10 20 00 clr %l1 <== NOT EXECUTED
20065b4: 83 28 60 04 sll %g1, 4, %g1 <== NOT EXECUTED
20065b8: a4 20 40 02 sub %g1, %g2, %l2 <== NOT EXECUTED
20065bc: a4 04 00 12 add %l0, %l2, %l2 <== 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;
20065c0: f0 04 20 04 ld [ %l0 + 4 ], %i0 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
20065c4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
20065c8: 02 80 00 22 be 2006650 <rtems_fdisk_ioctl+0x374> <== NOT EXECUTED
20065cc: a2 04 40 18 add %l1, %i0, %l1 <== NOT EXECUTED
20065d0: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED
20065d4: f2 06 a0 14 ld [ %i2 + 0x14 ], %i1 <== NOT EXECUTED
20065d8: f6 06 a0 2c ld [ %i2 + 0x2c ], %i3 <== NOT EXECUTED
20065dc: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5 <== NOT EXECUTED
20065e0: c8 06 a0 34 ld [ %i2 + 0x34 ], %g4 <== NOT EXECUTED
20065e4: c6 06 a0 38 ld [ %i2 + 0x38 ], %g3 <== NOT EXECUTED
20065e8: c4 06 a0 28 ld [ %i2 + 0x28 ], %g2 <== NOT EXECUTED
* @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)
20065ec: 9f 2e 20 04 sll %i0, 4, %o7 <== NOT EXECUTED
20065f0: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
20065f4: 92 26 00 0f sub %i0, %o7, %o1 <== NOT EXECUTED
20065f8: 92 00 40 09 add %g1, %o1, %o1 <== 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;
20065fc: d4 00 60 14 ld [ %g1 + 0x14 ], %o2 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
2006600: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006604: d8 00 60 1c ld [ %g1 + 0x1c ], %o4 <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006608: da 00 60 20 ld [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
200660c: de 00 60 24 ld [ %g1 + 0x24 ], %o7 <== NOT EXECUTED
data->seg_erases += sc->erased;
2006610: f0 00 60 2c ld [ %g1 + 0x2c ], %i0 <== 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;
2006614: b2 06 40 0a add %i1, %o2, %i1 <== NOT EXECUTED
2006618: 82 00 60 30 add %g1, 0x30, %g1 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
200661c: b6 06 c0 0b add %i3, %o3, %i3 <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006620: ba 07 40 0c add %i5, %o4, %i5 <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006624: 88 01 00 0d add %g4, %o5, %g4 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
2006628: 86 00 c0 0f add %g3, %o7, %g3 <== 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++)
200662c: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED
2006630: 12 bf ff f3 bne 20065fc <rtems_fdisk_ioctl+0x320> <== NOT EXECUTED
2006634: 84 00 80 18 add %g2, %i0, %g2 <== NOT EXECUTED
2006638: f2 26 a0 14 st %i1, [ %i2 + 0x14 ] <== NOT EXECUTED
200663c: f6 26 a0 2c st %i3, [ %i2 + 0x2c ] <== NOT EXECUTED
2006640: fa 26 a0 30 st %i5, [ %i2 + 0x30 ] <== NOT EXECUTED
2006644: c8 26 a0 34 st %g4, [ %i2 + 0x34 ] <== NOT EXECUTED
2006648: c6 26 a0 38 st %g3, [ %i2 + 0x38 ] <== NOT EXECUTED
200664c: c4 26 a0 28 st %g2, [ %i2 + 0x28 ] <== NOT EXECUTED
2006650: a0 04 20 0c add %l0, 0xc, %l0 <== 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++)
2006654: 80 a4 00 12 cmp %l0, %l2 <== NOT EXECUTED
2006658: 32 bf ff db bne,a 20065c4 <rtems_fdisk_ioctl+0x2e8> <== NOT EXECUTED
200665c: f0 04 20 04 ld [ %l0 + 4 ], %i0 <== NOT EXECUTED
2006660: e2 26 a0 10 st %l1, [ %i2 + 0x10 ] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
2006664: c2 07 20 6c ld [ %i4 + 0x6c ], %g1 <== NOT EXECUTED
2006668: c2 26 a0 3c st %g1, [ %i2 + 0x3c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
200666c: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
2006670: 40 00 1c 4e call 200d7a8 <rtems_semaphore_release>
2006674: d0 07 20 64 ld [ %i4 + 0x64 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2006678: 80 a2 20 00 cmp %o0, 0
200667c: 12 bf ff 5f bne 20063f8 <rtems_fdisk_ioctl+0x11c> <== NEVER TAKEN
2006680: 01 00 00 00 nop
errno = EIO;
}
return errno == 0 ? 0 : -1;
2006684: 40 00 72 f9 call 2023268 <__errno>
2006688: 01 00 00 00 nop
200668c: c2 02 00 00 ld [ %o0 ], %g1
2006690: 80 a0 00 01 cmp %g0, %g1
2006694: b0 60 20 00 subx %g0, 0, %i0
2006698: 81 c7 e0 08 ret
200669c: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
20066a0: 80 a6 40 01 cmp %i1, %g1
20066a4: 02 80 00 15 be 20066f8 <rtems_fdisk_ioctl+0x41c> <== NEVER TAKEN
20066a8: 90 10 00 18 mov %i0, %o0
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
break;
default:
rtems_blkdev_ioctl (dd, req, argp);
20066ac: 92 10 00 19 mov %i1, %o1
20066b0: 40 00 44 02 call 20176b8 <rtems_blkdev_ioctl>
20066b4: 94 10 00 1a mov %i2, %o2
20066b8: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1
break;
20066bc: 10 bf ff ed b 2006670 <rtems_fdisk_ioctl+0x394>
20066c0: b8 00 40 1c add %g1, %i4, %i4
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
(rtems_fdisk_monitor_data*) argp);
break;
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
20066c4: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
break;
20066c8: 10 bf ff ea b 2006670 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
20066cc: f4 27 20 6c st %i2, [ %i4 + 0x6c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
20066d0: 40 00 72 e6 call 2023268 <__errno> <== NOT EXECUTED
20066d4: 01 00 00 00 nop <== NOT EXECUTED
20066d8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
20066dc: d0 04 20 b0 ld [ %l0 + 0xb0 ], %o0 <== NOT EXECUTED
20066e0: 7f ff fd 54 call 2005c30 <rtems_fdisk_compact> <== NOT EXECUTED
20066e4: 90 02 00 1c add %o0, %i4, %o0 <== NOT EXECUTED
20066e8: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
20066ec: d0 27 40 00 st %o0, [ %i5 ] <== NOT EXECUTED
break;
20066f0: 10 bf ff e0 b 2006670 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
20066f4: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
20066f8: 40 00 72 dc call 2023268 <__errno> <== NOT EXECUTED
20066fc: 01 00 00 00 nop <== NOT EXECUTED
2006700: fa 04 20 b0 ld [ %l0 + 0xb0 ], %i5 <== NOT EXECUTED
2006704: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
2006708: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
{
uint32_t device;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "erase-disk");
200670c: 13 00 80 cf sethi %hi(0x2033c00), %o1 <== NOT EXECUTED
2006710: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006714: 7f ff f9 d7 call 2004e70 <rtems_fdisk_info> <== NOT EXECUTED
2006718: 92 12 61 30 or %o1, 0x130, %o1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
200671c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2006720: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006724: 02 80 03 cd be 2007658 <rtems_fdisk_ioctl+0x137c> <== NOT EXECUTED
2006728: 31 00 80 cf sethi %hi(0x2033c00), %i0 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
200672c: 23 00 80 cf sethi %hi(0x2033c00), %l1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
2006730: b4 10 20 00 clr %i2 <== NOT EXECUTED
2006734: b6 10 20 00 clr %i3 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
2006738: a2 14 61 40 or %l1, 0x140, %l1 <== 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);
200673c: 10 80 00 06 b 2006754 <rtems_fdisk_ioctl+0x478> <== NOT EXECUTED
2006740: b0 16 21 58 or %i0, 0x158, %i0 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
2006744: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2006748: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
200674c: 1a 80 03 a8 bcc 20075ec <rtems_fdisk_ioctl+0x1310> <== NOT EXECUTED
2006750: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
2006754: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2006758: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
200675c: 7f ff f9 c5 call 2004e70 <rtems_fdisk_info> <== NOT EXECUTED
2006760: 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;
2006764: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006768: 94 10 00 1b mov %i3, %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;
200676c: 82 00 40 1a add %g1, %i2, %g1 <== NOT EXECUTED
2006770: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006774: 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;
2006778: e4 00 60 08 ld [ %g1 + 8 ], %l2 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
200677c: 7f ff f9 df call 2004ef8 <rtems_fdisk_printf> <== NOT EXECUTED
2006780: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
2006784: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
2006788: c2 04 a0 14 ld [ %l2 + 0x14 ], %g1 <== NOT EXECUTED
200678c: 84 00 80 1a add %g2, %i2, %g2 <== NOT EXECUTED
2006790: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
2006794: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006798: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
200679c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20067a0: 22 bf ff e9 be,a 2006744 <rtems_fdisk_ioctl+0x468> <== NOT EXECUTED
20067a4: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
20067a8: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
20067ac: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
break;
20067b0: 10 bf ff b0 b 2006670 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
20067b4: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
20067b8: 10 bf fe f9 b 200639c <rtems_fdisk_ioctl+0xc0> <== NOT EXECUTED
20067bc: c0 27 60 50 clr [ %i5 + 0x50 ] <== NOT EXECUTED
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]);
20067c0: 40 00 72 aa call 2023268 <__errno>
20067c4: ba 10 20 00 clr %i5
20067c8: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1
20067cc: d0 27 bf e8 st %o0, [ %fp + -24 ]
20067d0: b4 00 40 1c add %g1, %i4, %i2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
20067d4: d4 00 40 1c ld [ %g1 + %i4 ], %o2
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
20067d8: c6 06 a0 6c ld [ %i2 + 0x6c ], %g3
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
20067dc: d6 06 a0 04 ld [ %i2 + 4 ], %o3
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
20067e0: 82 10 20 03 mov 3, %g1
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
20067e4: c6 27 bf e4 st %g3, [ %fp + -28 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
20067e8: c2 26 a0 6c st %g1, [ %i2 + 0x6c ]
rtems_fdisk_printf (fd,
20067ec: 90 10 00 1a mov %i2, %o0
20067f0: 13 00 80 cf sethi %hi(0x2033c00), %o1
20067f4: 7f ff f9 c1 call 2004ef8 <rtems_fdisk_printf>
20067f8: 92 12 61 70 or %o1, 0x170, %o1 ! 2033d70 <__FUNCTION__.7127+0xdd8>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
20067fc: d4 06 a0 1c ld [ %i2 + 0x1c ], %o2
2006800: 90 10 00 1a mov %i2, %o0
2006804: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006808: 7f ff f9 bc call 2004ef8 <rtems_fdisk_printf>
200680c: 92 12 61 98 or %o1, 0x198, %o1 ! 2033d98 <__FUNCTION__.7127+0xe00>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
2006810: d4 06 a0 20 ld [ %i2 + 0x20 ], %o2
2006814: 90 10 00 1a mov %i2, %o0
2006818: 13 00 80 cf sethi %hi(0x2033c00), %o1
200681c: 7f ff f9 b7 call 2004ef8 <rtems_fdisk_printf>
2006820: 92 12 61 a8 or %o1, 0x1a8, %o1 ! 2033da8 <__FUNCTION__.7127+0xe10>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
2006824: d4 06 a0 24 ld [ %i2 + 0x24 ], %o2
2006828: 90 10 00 1a mov %i2, %o0
200682c: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006830: 7f ff f9 b2 call 2004ef8 <rtems_fdisk_printf>
2006834: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 2033dc0 <__FUNCTION__.7127+0xe28>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
2006838: d4 06 a0 70 ld [ %i2 + 0x70 ], %o2
200683c: 90 10 00 1a mov %i2, %o0
2006840: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006844: 7f ff f9 ad call 2004ef8 <rtems_fdisk_printf>
2006848: 92 12 61 d8 or %o1, 0x1d8, %o1 ! 2033dd8 <__FUNCTION__.7127+0xe40>
* 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;
200684c: c2 06 a0 34 ld [ %i2 + 0x34 ], %g1
uint32_t count = 0;
while (sc)
2006850: 80 a0 60 00 cmp %g1, 0
2006854: 22 80 00 07 be,a 2006870 <rtems_fdisk_ioctl+0x594> <== NEVER TAKEN
2006858: d6 06 a0 3c ld [ %i2 + 0x3c ], %o3 <== NOT EXECUTED
{
count++;
sc = sc->next;
200685c: c2 00 40 00 ld [ %g1 ], %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)
2006860: 80 a0 60 00 cmp %g1, 0
2006864: 12 bf ff fe bne 200685c <rtems_fdisk_ioctl+0x580> <== NEVER TAKEN
2006868: ba 07 60 01 inc %i5
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
200686c: d6 06 a0 3c ld [ %i2 + 0x3c ], %o3
2006870: 94 10 00 1d mov %i5, %o2
2006874: 90 10 00 1a mov %i2, %o0
2006878: 13 00 80 cf sethi %hi(0x2033c00), %o1
200687c: 7f ff f9 9f call 2004ef8 <rtems_fdisk_printf>
2006880: 92 12 61 e8 or %o1, 0x1e8, %o1 ! 2033de8 <__FUNCTION__.7127+0xe50>
* 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;
2006884: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
uint32_t count = 0;
while (sc)
2006888: 80 a0 60 00 cmp %g1, 0
200688c: 02 80 00 06 be 20068a4 <rtems_fdisk_ioctl+0x5c8> <== NEVER TAKEN
2006890: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
2006894: c2 00 40 00 ld [ %g1 ], %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)
2006898: 80 a0 60 00 cmp %g1, 0
200689c: 12 bf ff fe bne 2006894 <rtems_fdisk_ioctl+0x5b8>
20068a0: 94 02 a0 01 inc %o2
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)",
20068a4: d6 06 a0 48 ld [ %i2 + 0x48 ], %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;
20068a8: ba 02 80 1d add %o2, %i5, %i5
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
20068ac: 90 10 00 1a mov %i2, %o0
20068b0: 13 00 80 cf sethi %hi(0x2033c00), %o1
20068b4: 7f ff f9 91 call 2004ef8 <rtems_fdisk_printf>
20068b8: 92 12 62 08 or %o1, 0x208, %o1 ! 2033e08 <__FUNCTION__.7127+0xe70>
* 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;
20068bc: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
uint32_t count = 0;
while (sc)
20068c0: 80 a0 60 00 cmp %g1, 0
20068c4: 02 80 00 06 be 20068dc <rtems_fdisk_ioctl+0x600> <== ALWAYS TAKEN
20068c8: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
20068cc: c2 00 40 00 ld [ %g1 ], %g1 <== 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)
20068d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20068d4: 12 bf ff fe bne 20068cc <rtems_fdisk_ioctl+0x5f0> <== NOT EXECUTED
20068d8: 94 02 a0 01 inc %o2 <== 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)",
20068dc: d6 06 a0 54 ld [ %i2 + 0x54 ], %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;
20068e0: ba 07 40 0a add %i5, %o2, %i5
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
20068e4: 90 10 00 1a mov %i2, %o0
20068e8: 13 00 80 cf sethi %hi(0x2033c00), %o1
20068ec: 7f ff f9 83 call 2004ef8 <rtems_fdisk_printf>
20068f0: 92 12 62 20 or %o1, 0x220, %o1 ! 2033e20 <__FUNCTION__.7127+0xe88>
* 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;
20068f4: c4 06 a0 58 ld [ %i2 + 0x58 ], %g2
uint32_t count = 0;
while (sc)
20068f8: 80 a0 a0 00 cmp %g2, 0
20068fc: 02 80 00 06 be 2006914 <rtems_fdisk_ioctl+0x638> <== ALWAYS TAKEN
2006900: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
2006904: c4 00 80 00 ld [ %g2 ], %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)
2006908: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
200690c: 12 bf ff fe bne 2006904 <rtems_fdisk_ioctl+0x628> <== NOT EXECUTED
2006910: 94 02 a0 01 inc %o2 <== 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)",
2006914: d6 06 a0 60 ld [ %i2 + 0x60 ], %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;
2006918: ba 07 40 0a add %i5, %o2, %i5
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
200691c: 90 10 00 1a mov %i2, %o0
2006920: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006924: 7f ff f9 75 call 2004ef8 <rtems_fdisk_printf>
2006928: 92 12 62 38 or %o1, 0x238, %o1 ! 2033e38 <__FUNCTION__.7127+0xea0>
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
200692c: c4 06 a0 30 ld [ %i2 + 0x30 ], %g2
2006930: 80 a0 a0 00 cmp %g2, 0
2006934: 02 80 00 dc be 2006ca4 <rtems_fdisk_ioctl+0x9c8> <== NEVER TAKEN
2006938: 87 28 a0 02 sll %g2, 2, %g3
200693c: c2 06 a0 2c ld [ %i2 + 0x2c ], %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;
2006940: 96 10 20 00 clr %o3
* @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)
2006944: 85 28 a0 04 sll %g2, 4, %g2
2006948: 84 20 80 03 sub %g2, %g3, %g2
200694c: 84 00 80 01 add %g2, %g1, %g2
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++)
count += fd->devices[device].segment_count;
2006950: c6 00 60 04 ld [ %g1 + 4 ], %g3
2006954: 82 00 60 0c add %g1, 0xc, %g1
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++)
2006958: 80 a0 40 02 cmp %g1, %g2
200695c: 12 bf ff fd bne 2006950 <rtems_fdisk_ioctl+0x674> <== NEVER TAKEN
2006960: 96 02 c0 03 add %o3, %g3, %o3
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
2006964: 19 00 80 ce sethi %hi(0x2033800), %o4
2006968: 80 a7 40 0b cmp %i5, %o3
200696c: 02 80 02 64 be 20072fc <rtems_fdisk_ioctl+0x1020> <== ALWAYS TAKEN
2006970: 98 13 21 38 or %o4, 0x138, %o4
2006974: 94 10 00 1d mov %i5, %o2
2006978: 90 10 00 1a mov %i2, %o0
200697c: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006980: 7f ff f9 5e call 2004ef8 <rtems_fdisk_printf>
2006984: 92 12 62 50 or %o1, 0x250, %o1 ! 2033e50 <__FUNCTION__.7127+0xeb8>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
2006988: d4 06 a0 30 ld [ %i2 + 0x30 ], %o2
200698c: 90 10 00 1a mov %i2, %o0
2006990: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006994: 7f ff f9 59 call 2004ef8 <rtems_fdisk_printf>
2006998: 92 12 62 70 or %o1, 0x270, %o1 ! 2033e70 <__FUNCTION__.7127+0xed8>
for (device = 0; device < fd->device_count; device++)
200699c: c2 06 a0 30 ld [ %i2 + 0x30 ], %g1
20069a0: 80 a0 60 00 cmp %g1, 0
20069a4: 22 80 00 8f be,a 2006be0 <rtems_fdisk_ioctl+0x904> <== NEVER TAKEN
20069a8: fa 06 a0 40 ld [ %i2 + 0x40 ], %i5 <== NOT EXECUTED
20069ac: a2 10 20 00 clr %l1
20069b0: c0 27 bf ec clr [ %fp + -20 ]
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
20069b4: d4 07 bf ec ld [ %fp + -20 ], %o2
20069b8: 13 00 80 cf sethi %hi(0x2033c00), %o1
20069bc: 90 10 00 1a mov %i2, %o0
20069c0: 7f ff f9 4e call 2004ef8 <rtems_fdisk_printf>
20069c4: 92 12 62 80 or %o1, 0x280, %o1
rtems_fdisk_printf (fd, " Segment count\t%ld",
20069c8: c2 06 a0 2c ld [ %i2 + 0x2c ], %g1
20069cc: 90 10 00 1a mov %i2, %o0
20069d0: 82 00 40 11 add %g1, %l1, %g1
20069d4: d4 00 60 04 ld [ %g1 + 4 ], %o2
20069d8: 13 00 80 cf sethi %hi(0x2033c00), %o1
20069dc: 7f ff f9 47 call 2004ef8 <rtems_fdisk_printf>
20069e0: 92 12 62 90 or %o1, 0x290, %o1 ! 2033e90 <__FUNCTION__.7127+0xef8>
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
20069e4: c2 06 a0 2c ld [ %i2 + 0x2c ], %g1
20069e8: 82 00 40 11 add %g1, %l1, %g1
20069ec: c4 00 60 04 ld [ %g1 + 4 ], %g2
20069f0: 80 a0 a0 00 cmp %g2, 0
20069f4: 02 80 00 74 be 2006bc4 <rtems_fdisk_ioctl+0x8e8> <== NEVER TAKEN
20069f8: c4 07 bf ec ld [ %fp + -20 ], %g2
20069fc: b0 10 20 00 clr %i0
2006a00: b2 10 20 00 clr %i1
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
2006a04: f6 00 40 00 ld [ %g1 ], %i3
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006a08: 90 10 00 1a mov %i2, %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];
2006a0c: b6 06 c0 18 add %i3, %i0, %i3
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006a10: 94 07 bf f8 add %fp, -8, %o2
2006a14: 7f ff f8 b9 call 2004cf8 <rtems_fdisk_queue_status>
2006a18: 92 10 00 1b mov %i3, %o1
for (page = 0; page < sc->pages; page++)
2006a1c: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
2006a20: 80 a0 a0 00 cmp %g2, 0
2006a24: 22 80 00 95 be,a 2006c78 <rtems_fdisk_ioctl+0x99c> <== NEVER TAKEN
2006a28: de 06 a0 1c ld [ %i2 + 0x1c ], %o7 <== NOT EXECUTED
2006a2c: d4 06 a0 1c ld [ %i2 + 0x1c ], %o2
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;
bool is_active = false;
2006a30: a6 10 20 00 clr %l3
2006a34: 9e 10 00 0a mov %o2, %o7
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;
2006a38: ae 10 20 00 clr %l7
uint32_t used = 0;
2006a3c: 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;
2006a40: aa 10 20 00 clr %l5
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006a44: a8 10 20 00 clr %l4
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
2006a48: d6 06 e0 10 ld [ %i3 + 0x10 ], %o3
* @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)
2006a4c: bb 2d 20 03 sll %l4, 3, %i5
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
2006a50: d2 02 c0 1d ld [ %o3 + %i5 ], %o1
2006a54: 80 a2 7f ff cmp %o1, -1
2006a58: 02 80 00 7e be 2006c50 <rtems_fdisk_ioctl+0x974>
2006a5c: ba 02 c0 1d add %o3, %i5, %i5
* 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;
2006a60: fa 17 60 02 lduh [ %i5 + 2 ], %i5
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
erased++;
else if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006a64: 80 8f 60 01 btst 1, %i5
2006a68: 12 80 00 07 bne 2006a84 <rtems_fdisk_ioctl+0x7a8> <== NEVER TAKEN
2006a6c: 80 a2 a0 00 cmp %o2, 0
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006a70: 80 8f 60 02 btst 2, %i5
2006a74: 32 80 00 7d bne,a 2006c68 <rtems_fdisk_ioctl+0x98c>
2006a78: ae 05 e0 01 inc %l7
RTEMS_FDISK_PAGE_USED))
used++;
2006a7c: ac 05 a0 01 inc %l6
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
2006a80: 80 a2 a0 00 cmp %o2, 0
2006a84: 22 80 00 23 be,a 2006b10 <rtems_fdisk_ioctl+0x834> <== NEVER TAKEN
2006a88: a8 05 20 01 inc %l4 <== NOT EXECUTED
2006a8c: ba 10 20 00 clr %i5
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
2006a90: 10 80 00 06 b 2006aa8 <rtems_fdisk_ioctl+0x7cc>
2006a94: a4 0c e0 ff and %l3, 0xff, %l2
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
2006a98: ba 07 60 01 inc %i5
2006a9c: 80 a7 40 0a cmp %i5, %o2
2006aa0: 1a 80 00 1a bcc 2006b08 <rtems_fdisk_ioctl+0x82c>
2006aa4: 9e 10 00 0a mov %o2, %o7
{
if ((fd->blocks[block].segment == sc) &&
2006aa8: d6 06 a0 18 ld [ %i2 + 0x18 ], %o3
* @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)
2006aac: 9f 2f 60 03 sll %i5, 3, %o7
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
2006ab0: d2 02 c0 0f ld [ %o3 + %o7 ], %o1
2006ab4: 80 a6 c0 09 cmp %i3, %o1
2006ab8: 12 bf ff f8 bne 2006a98 <rtems_fdisk_ioctl+0x7bc>
2006abc: 9e 02 c0 0f add %o3, %o7, %o7
2006ac0: de 03 e0 04 ld [ %o7 + 4 ], %o7
2006ac4: 80 a5 00 0f cmp %l4, %o7
2006ac8: 32 bf ff f5 bne,a 2006a9c <rtems_fdisk_ioctl+0x7c0>
2006acc: ba 07 60 01 inc %i5
(fd->blocks[block].page == page) && !is_active)
2006ad0: 80 a4 a0 00 cmp %l2, 0
2006ad4: 32 bf ff f2 bne,a 2006a9c <rtems_fdisk_ioctl+0x7c0> <== ALWAYS TAKEN
2006ad8: ba 07 60 01 inc %i5
rtems_fdisk_printf (fd,
2006adc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
2006ae0: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
2006ae4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2006ae8: 13 00 80 cf sethi %hi(0x2033c00), %o1 <== NOT EXECUTED
2006aec: 7f ff f9 03 call 2004ef8 <rtems_fdisk_printf> <== NOT EXECUTED
2006af0: 92 12 62 a8 or %o1, 0x2a8, %o1 ! 2033ea8 <__FUNCTION__.7127+0xf10><== NOT EXECUTED
2006af4: d4 06 a0 1c ld [ %i2 + 0x1c ], %o2 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
2006af8: ba 07 60 01 inc %i5 <== NOT EXECUTED
2006afc: 80 a7 40 0a cmp %i5, %o2 <== NOT EXECUTED
2006b00: 0a bf ff ea bcs 2006aa8 <rtems_fdisk_ioctl+0x7cc> <== NOT EXECUTED
2006b04: 9e 10 00 0a mov %o2, %o7 <== NOT EXECUTED
2006b08: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006b0c: a8 05 20 01 inc %l4
2006b10: 80 a5 00 02 cmp %l4, %g2
2006b14: 2a bf ff ce bcs,a 2006a4c <rtems_fdisk_ioctl+0x770>
2006b18: d6 06 e0 10 ld [ %i3 + 0x10 ], %o3
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006b1c: 80 a3 e0 00 cmp %o7, 0
2006b20: 02 80 00 54 be 2006c70 <rtems_fdisk_ioctl+0x994> <== NEVER TAKEN
2006b24: 9f 2b e0 03 sll %o7, 3, %o7
2006b28: d6 06 a0 18 ld [ %i2 + 0x18 ], %o3
* @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)
2006b2c: 82 10 20 00 clr %g1
2006b30: 86 10 20 00 clr %g3
}
count = 0;
for (block = 0; block < fd->block_count; block++)
{
if (fd->blocks[block].segment == sc)
2006b34: fa 02 c0 01 ld [ %o3 + %g1 ], %i5
2006b38: 82 00 60 08 add %g1, 8, %g1
count++;
2006b3c: ba 1e c0 1d xor %i3, %i5, %i5
2006b40: 80 a0 00 1d cmp %g0, %i5
2006b44: 86 60 ff ff subx %g3, -1, %g3
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006b48: 80 a0 40 0f cmp %g1, %o7
2006b4c: 32 bf ff fb bne,a 2006b38 <rtems_fdisk_ioctl+0x85c>
2006b50: fa 02 c0 01 ld [ %o3 + %g1 ], %i5
" 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),
2006b54: fa 06 e0 20 ld [ %i3 + 0x20 ], %i5
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 +
2006b58: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006b5c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2006b60: ee 23 a0 5c st %l7, [ %sp + 0x5c ]
2006b64: ec 23 a0 64 st %l6, [ %sp + 0x64 ]
2006b68: ea 23 a0 68 st %l5, [ %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)
2006b6c: c8 06 e0 24 ld [ %i3 + 0x24 ], %g4
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006b70: c6 23 a0 70 st %g3, [ %sp + 0x70 ]
* @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)
2006b74: ba 07 40 04 add %i5, %g4, %i5
2006b78: 86 07 40 01 add %i5, %g1, %g3
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006b7c: 86 20 80 03 sub %g2, %g3, %g3
2006b80: 94 10 00 19 mov %i1, %o2
2006b84: 98 10 00 02 mov %g2, %o4
2006b88: 9a 10 00 01 mov %g1, %o5
2006b8c: 90 10 00 1a mov %i2, %o0
2006b90: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006b94: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
2006b98: 92 12 62 d8 or %o1, 0x2d8, %o1
2006b9c: 7f ff f8 d7 call 2004ef8 <rtems_fdisk_printf>
2006ba0: 96 07 bf f8 add %fp, -8, %o3
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++)
2006ba4: c2 06 a0 2c ld [ %i2 + 0x2c ], %g1
2006ba8: b2 06 60 01 inc %i1
2006bac: 82 00 40 11 add %g1, %l1, %g1
2006bb0: c4 00 60 04 ld [ %g1 + 4 ], %g2
2006bb4: 80 a6 40 02 cmp %i1, %g2
2006bb8: 0a bf ff 93 bcs 2006a04 <rtems_fdisk_ioctl+0x728>
2006bbc: b0 06 20 30 add %i0, 0x30, %i0
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++)
2006bc0: c4 07 bf ec ld [ %fp + -20 ], %g2
2006bc4: c2 06 a0 30 ld [ %i2 + 0x30 ], %g1
2006bc8: 84 00 a0 01 inc %g2
2006bcc: c4 27 bf ec st %g2, [ %fp + -20 ]
2006bd0: 80 a0 80 01 cmp %g2, %g1
2006bd4: 0a bf ff 78 bcs 20069b4 <rtems_fdisk_ioctl+0x6d8> <== NEVER TAKEN
2006bd8: a2 04 60 0c add %l1, 0xc, %l1
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
2006bdc: fa 06 a0 40 ld [ %i2 + 0x40 ], %i5
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
2006be0: 90 10 00 1a mov %i2, %o0
2006be4: 13 00 80 cf sethi %hi(0x2033c00), %o1
2006be8: 7f ff f8 c4 call 2004ef8 <rtems_fdisk_printf>
2006bec: 92 12 63 18 or %o1, 0x318, %o1 ! 2033f18 <__FUNCTION__.7127+0xf80>
while (sc)
2006bf0: 80 a7 60 00 cmp %i5, 0
2006bf4: 02 80 00 11 be 2006c38 <rtems_fdisk_ioctl+0x95c> <== NEVER TAKEN
2006bf8: c6 07 bf e4 ld [ %fp + -28 ], %g3
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
2006bfc: 33 00 80 cf sethi %hi(0x2033c00), %i1
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
2006c00: b6 10 20 00 clr %i3
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
2006c04: b2 16 63 28 or %i1, 0x328, %i1
2006c08: d6 07 60 08 ld [ %i5 + 8 ], %o3
2006c0c: d8 07 60 0c ld [ %i5 + 0xc ], %o4
2006c10: da 07 60 20 ld [ %i5 + 0x20 ], %o5
2006c14: 94 10 00 1b mov %i3, %o2
2006c18: 90 10 00 1a mov %i2, %o0
2006c1c: 7f ff f8 b7 call 2004ef8 <rtems_fdisk_printf>
2006c20: 92 10 00 19 mov %i1, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
2006c24: fa 07 40 00 ld [ %i5 ], %i5
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
2006c28: 80 a7 60 00 cmp %i5, 0
2006c2c: 12 bf ff f7 bne 2006c08 <rtems_fdisk_ioctl+0x92c>
2006c30: b6 06 e0 01 inc %i3
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
2006c34: c6 07 bf e4 ld [ %fp + -28 ], %g3
2006c38: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
2006c3c: c4 07 bf e8 ld [ %fp + -24 ], %g2
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
2006c40: c6 26 a0 6c st %g3, [ %i2 + 0x6c ]
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]);
2006c44: c0 20 80 00 clr [ %g2 ]
break;
2006c48: 10 bf fe 8a b 2006670 <rtems_fdisk_ioctl+0x394>
2006c4c: b8 00 40 1c add %g1, %i4, %i4
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
2006c50: d6 07 60 04 ld [ %i5 + 4 ], %o3
2006c54: 80 a2 ff ff cmp %o3, -1
2006c58: 32 bf ff 83 bne,a 2006a64 <rtems_fdisk_ioctl+0x788> <== NEVER TAKEN
2006c5c: fa 17 60 02 lduh [ %i5 + 2 ], %i5 <== NOT EXECUTED
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
erased++;
2006c60: 10 bf ff 88 b 2006a80 <rtems_fdisk_ioctl+0x7a4>
2006c64: aa 05 60 01 inc %l5
RTEMS_FDISK_PAGE_USED))
used++;
else
{
active++;
is_active = true;
2006c68: 10 bf ff 86 b 2006a80 <rtems_fdisk_ioctl+0x7a4>
2006c6c: a6 10 20 01 mov 1, %l3
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006c70: 10 bf ff b9 b 2006b54 <rtems_fdisk_ioctl+0x878> <== NOT EXECUTED
2006c74: 86 10 20 00 clr %g3 <== NOT EXECUTED
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;
2006c78: ae 10 20 00 clr %l7 <== NOT EXECUTED
uint32_t used = 0;
2006c7c: ac 10 20 00 clr %l6 <== NOT EXECUTED
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;
2006c80: 10 bf ff a7 b 2006b1c <rtems_fdisk_ioctl+0x840> <== NOT EXECUTED
2006c84: aa 10 20 00 clr %l5 <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
2006c88: 40 00 71 78 call 2023268 <__errno> <== NOT EXECUTED
2006c8c: 01 00 00 00 nop <== NOT EXECUTED
2006c90: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
2006c94: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
2006c98: 82 10 20 13 mov 0x13, %g1 <== NOT EXECUTED
2006c9c: 10 bf fe 75 b 2006670 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
2006ca0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
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;
2006ca4: 10 bf ff 30 b 2006964 <rtems_fdisk_ioctl+0x688> <== NOT EXECUTED
2006ca8: 96 10 20 00 clr %o3 <== NOT EXECUTED
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);
2006cac: 40 00 71 6f call 2023268 <__errno>
2006cb0: a4 06 a0 28 add %i2, 0x28, %l2
2006cb4: fa 04 20 b0 ld [ %l0 + 0xb0 ], %i5
2006cb8: f6 06 a0 10 ld [ %i2 + 0x10 ], %i3
* @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)
2006cbc: 86 10 20 01 mov 1, %g3
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);
2006cc0: d0 27 bf e4 st %o0, [ %fp + -28 ]
2006cc4: ba 07 40 1c add %i5, %i4, %i5
* @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)
2006cc8: c6 27 bf ec st %g3, [ %fp + -20 ]
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2006ccc: c6 07 bf ec ld [ %fp + -20 ], %g3
2006cd0: 82 00 ff ff add %g3, -1, %g1
2006cd4: 80 a0 40 1b cmp %g1, %i3
2006cd8: 1a 80 01 29 bcc 200717c <rtems_fdisk_ioctl+0xea0>
2006cdc: 92 10 20 00 clr %o1
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
2006ce0: d0 04 bf f4 ld [ %l2 + -12 ], %o0
2006ce4: 7f ff ee 6c call 2002694 <.udiv>
2006ce8: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
2006cec: d0 27 bf e8 st %o0, [ %fp + -24 ]
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006cf0: 80 a2 20 00 cmp %o0, 0
2006cf4: 02 80 01 10 be 2007134 <rtems_fdisk_ioctl+0xe58> <== NEVER TAKEN
2006cf8: e2 04 bf f8 ld [ %l2 + -8 ], %l1
2006cfc: a6 10 20 00 clr %l3
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
2006d00: f2 04 bf f0 ld [ %l2 + -16 ], %i1
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
2006d04: 1f 00 80 ce sethi %hi(0x2033800), %o7
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);
2006d08: b2 04 c0 19 add %l3, %i1, %i1
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
2006d0c: 90 10 00 1d mov %i5, %o0
2006d10: 92 13 e2 c0 or %o7, 0x2c0, %o1
2006d14: 7f ff f8 57 call 2004e70 <rtems_fdisk_info>
2006d18: 94 10 00 19 mov %i1, %o2
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
2006d1c: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
2006d20: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
2006d24: 82 20 80 01 sub %g2, %g1, %g1
2006d28: 80 a6 40 01 cmp %i1, %g1
2006d2c: 1a 80 01 1c bcc 200719c <rtems_fdisk_ioctl+0xec0> <== NEVER TAKEN
2006d30: 92 10 00 19 mov %i1, %o1
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
2006d34: ee 07 60 18 ld [ %i5 + 0x18 ], %l7
2006d38: ad 2e 60 03 sll %i1, 3, %l6
/*
* Does the page exist in flash ?
*/
if (bc->segment)
2006d3c: f6 05 c0 16 ld [ %l7 + %l6 ], %i3
2006d40: 80 a6 e0 00 cmp %i3, 0
2006d44: 02 80 00 73 be 2006f10 <rtems_fdisk_ioctl+0xc34>
2006d48: b0 05 c0 16 add %l7, %l6, %i0
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006d4c: c2 06 20 04 ld [ %i0 + 4 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006d50: d4 06 e0 08 ld [ %i3 + 8 ], %o2
2006d54: d6 06 e0 0c ld [ %i3 + 0xc ], %o3
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006d58: e8 06 e0 10 ld [ %i3 + 0x10 ], %l4
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006d5c: 98 10 00 01 mov %g1, %o4
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006d60: 83 28 60 03 sll %g1, 3, %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006d64: 90 10 00 1d mov %i5, %o0
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006d68: a8 05 00 01 add %l4, %g1, %l4
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006d6c: 13 00 80 ce sethi %hi(0x2033800), %o1
2006d70: 7f ff f8 40 call 2004e70 <rtems_fdisk_info>
2006d74: 92 12 62 f8 or %o1, 0x2f8, %o1 ! 2033af8 <__FUNCTION__.7127+0xb60>
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);
2006d78: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006d7c: c6 06 20 04 ld [ %i0 + 4 ], %g3
2006d80: c2 06 e0 08 ld [ %i3 + 8 ], %g1
2006d84: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
2006d88: 92 10 00 02 mov %g2, %o1
2006d8c: 90 02 00 03 add %o0, %g3, %o0
2006d90: c2 27 bf d8 st %g1, [ %fp + -40 ]
2006d94: 7f ff ee 06 call 20025ac <.umul>
2006d98: c4 27 bf d0 st %g2, [ %fp + -48 ]
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;
2006d9c: c2 07 bf d8 ld [ %fp + -40 ], %g1
2006da0: de 07 60 2c ld [ %i5 + 0x2c ], %o7
2006da4: 9b 28 60 04 sll %g1, 4, %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,
2006da8: ea 06 e0 0c ld [ %i3 + 0xc ], %l5
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;
2006dac: 89 28 60 02 sll %g1, 2, %g4
2006db0: 88 23 40 04 sub %o5, %g4, %g4
2006db4: d2 03 c0 04 ld [ %o7 + %g4 ], %o1
2006db8: 9a 03 c0 04 add %o7, %g4, %o5
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
2006dbc: da 03 60 08 ld [ %o5 + 8 ], %o5
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
2006dc0: c4 07 bf d0 ld [ %fp + -48 ], %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;
2006dc4: da 03 60 08 ld [ %o5 + 8 ], %o5
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;
2006dc8: 9f 2d 60 06 sll %l5, 6, %o7
2006dcc: 89 2d 60 04 sll %l5, 4, %g4
2006dd0: 88 23 c0 04 sub %o7, %g4, %g4
2006dd4: 88 02 40 04 add %o1, %g4, %g4
2006dd8: c8 01 20 04 ld [ %g4 + 4 ], %g4
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
2006ddc: 86 10 00 08 mov %o0, %g3
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
2006de0: 94 10 00 01 mov %g1, %o2
2006de4: 98 10 00 08 mov %o0, %o4
2006de8: c4 3f bf d0 std %g2, [ %fp + -48 ]
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;
2006dec: da 27 bf dc st %o5, [ %fp + -36 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
2006df0: 96 10 00 15 mov %l5, %o3
2006df4: 9a 10 00 02 mov %g2, %o5
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;
2006df8: c8 27 bf e0 st %g4, [ %fp + -32 ]
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
2006dfc: 90 10 00 1d mov %i5, %o0
2006e00: 13 00 80 ce sethi %hi(0x2033800), %o1
2006e04: 7f ff f8 3d call 2004ef8 <rtems_fdisk_printf>
2006e08: 92 12 63 20 or %o1, 0x320, %o1 ! 2033b20 <__FUNCTION__.7127+0xb88>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
2006e0c: de 07 bf dc ld [ %fp + -36 ], %o7
2006e10: c2 07 bf d8 ld [ %fp + -40 ], %g1
2006e14: c6 07 bf d4 ld [ %fp + -44 ], %g3
2006e18: c4 07 bf d0 ld [ %fp + -48 ], %g2
2006e1c: c8 03 e0 0c ld [ %o7 + 0xc ], %g4
2006e20: d0 07 bf e0 ld [ %fp + -32 ], %o0
2006e24: 92 10 00 01 mov %g1, %o1
2006e28: 94 10 00 15 mov %l5, %o2
2006e2c: 96 10 00 03 mov %g3, %o3
2006e30: 98 10 00 11 mov %l1, %o4
2006e34: 9f c1 00 00 call %g4
2006e38: 9a 10 00 02 mov %g2, %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,
2006e3c: 80 a2 20 00 cmp %o0, 0
2006e40: 22 80 01 04 be,a 2007250 <rtems_fdisk_ioctl+0xf74>
2006e44: d6 06 e0 08 ld [ %i3 + 8 ], %o3
* 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;
2006e48: c6 15 20 02 lduh [ %l4 + 2 ], %g3
* matches the flash device.
*/
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
2006e4c: c2 06 20 04 ld [ %i0 + 4 ], %g1
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))
2006e50: c4 07 60 08 ld [ %i5 + 8 ], %g2
* 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;
2006e54: 86 08 ff fd and %g3, -3, %g3
2006e58: c6 35 20 02 sth %g3, [ %l4 + 2 ]
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)) +
2006e5c: ab 28 60 03 sll %g1, 3, %l5
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
2006e60: 80 88 a0 08 btst 8, %g2
2006e64: 02 80 00 df be 20071e0 <rtems_fdisk_ioctl+0xf04> <== NEVER TAKEN
2006e68: aa 05 60 02 add %l5, 2, %l5
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
2006e6c: c2 27 bf d8 st %g1, [ %fp + -40 ]
2006e70: 90 10 00 1d mov %i5, %o0
2006e74: 92 10 00 1b mov %i3, %o1
2006e78: 94 10 00 15 mov %l5, %o2
2006e7c: 96 07 bf f6 add %fp, -10, %o3
2006e80: 7f ff f8 40 call 2004f80 <rtems_fdisk_seg_read>
2006e84: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
2006e88: 84 92 20 00 orcc %o0, 0, %g2
2006e8c: 12 80 00 de bne 2007204 <rtems_fdisk_ioctl+0xf28> <== NEVER TAKEN
2006e90: c2 07 bf d8 ld [ %fp + -40 ], %g1
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
2006e94: c8 15 20 02 lduh [ %l4 + 2 ], %g4
2006e98: c4 17 bf f6 lduh [ %fp + -10 ], %g2
2006e9c: 87 29 20 10 sll %g4, 0x10, %g3
2006ea0: 88 08 80 04 and %g2, %g4, %g4
2006ea4: 89 29 20 10 sll %g4, 0x10, %g4
2006ea8: 80 a1 00 03 cmp %g4, %g3
2006eac: 02 80 00 cd be 20071e0 <rtems_fdisk_ioctl+0xf04> <== ALWAYS TAKEN
2006eb0: 9b 30 e0 10 srl %g3, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
2006eb4: d2 06 e0 08 ld [ %i3 + 8 ], %o1 <== NOT EXECUTED
2006eb8: d4 06 e0 0c ld [ %i3 + 0xc ], %o2 <== NOT EXECUTED
2006ebc: 99 28 a0 10 sll %g2, 0x10, %o4 <== NOT EXECUTED
2006ec0: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
2006ec4: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED
2006ec8: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED
2006ecc: 7f ff f8 e5 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2006ed0: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
2006ed4: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2 <== NOT EXECUTED
sc->pages_used++;
2006ed8: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
2006edc: 84 00 bf ff add %g2, -1, %g2
sc->pages_used++;
2006ee0: 82 00 60 01 inc %g1
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
2006ee4: c4 26 e0 1c st %g2, [ %i3 + 0x1c ]
sc->pages_used++;
2006ee8: c2 26 e0 20 st %g1, [ %i3 + 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);
2006eec: 90 10 00 1d mov %i5, %o0
2006ef0: 7f ff f9 84 call 2005500 <rtems_fdisk_queue_segment>
2006ef4: 92 10 00 1b mov %i3, %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)
2006ef8: c2 07 60 08 ld [ %i5 + 8 ], %g1
2006efc: 80 88 60 02 btst 2, %g1
2006f00: 32 80 00 05 bne,a 2006f14 <rtems_fdisk_ioctl+0xc38> <== NEVER TAKEN
2006f04: f6 07 60 34 ld [ %i5 + 0x34 ], %i3 <== NOT EXECUTED
rtems_fdisk_compact (fd);
2006f08: 7f ff fb 4a call 2005c30 <rtems_fdisk_compact>
2006f0c: 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;
2006f10: f6 07 60 34 ld [ %i5 + 0x34 ], %i3
uint32_t count = 0;
while (sc)
2006f14: 80 a6 e0 00 cmp %i3, 0
2006f18: 02 80 00 8c be 2007148 <rtems_fdisk_ioctl+0xe6c> <== NEVER TAKEN
2006f1c: 82 10 00 1b mov %i3, %g1
2006f20: 84 10 20 00 clr %g2
{
count++;
sc = sc->next;
2006f24: c2 00 40 00 ld [ %g1 ], %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)
2006f28: 80 a0 60 00 cmp %g1, 0
2006f2c: 12 bf ff fe bne 2006f24 <rtems_fdisk_ioctl+0xc48>
2006f30: 84 00 a0 01 inc %g2
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
2006f34: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2006f38: 80 a0 40 02 cmp %g1, %g2
2006f3c: 1a 80 00 83 bcc 2007148 <rtems_fdisk_ioctl+0xe6c>
2006f40: 01 00 00 00 nop
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
2006f44: c2 06 c0 00 ld [ %i3 ], %g1
if (!queue->head)
2006f48: 80 a0 60 00 cmp %g1, 0
2006f4c: 02 80 00 d8 be 20072ac <rtems_fdisk_ioctl+0xfd0>
2006f50: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
queue->tail = 0;
queue->count--;
2006f54: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2006f58: 82 00 7f ff add %g1, -1, %g1
2006f5c: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
2006f60: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
2006f64: 80 a0 60 02 cmp %g1, 2
2006f68: 18 80 00 c3 bgu 2007274 <rtems_fdisk_ioctl+0xf98> <== NEVER TAKEN
2006f6c: c0 26 c0 00 clr [ %i3 ]
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
2006f70: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
2006f74: 80 a0 60 00 cmp %g1, 0
2006f78: 02 80 00 8e be 20071b0 <rtems_fdisk_ioctl+0xed4> <== NEVER TAKEN
2006f7c: e8 06 e0 10 ld [ %i3 + 0x10 ], %l4
2006f80: 10 80 00 05 b 2006f94 <rtems_fdisk_ioctl+0xcb8>
2006f84: aa 10 20 00 clr %l5
2006f88: 80 a5 40 01 cmp %l5, %g1
2006f8c: 02 80 00 89 be 20071b0 <rtems_fdisk_ioctl+0xed4> <== NEVER TAKEN
2006f90: a8 05 20 08 add %l4, 8, %l4
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
2006f94: c4 05 00 00 ld [ %l4 ], %g2
2006f98: 80 a0 bf ff cmp %g2, -1
2006f9c: 32 bf ff fb bne,a 2006f88 <rtems_fdisk_ioctl+0xcac>
2006fa0: aa 05 60 01 inc %l5
2006fa4: c4 05 20 04 ld [ %l4 + 4 ], %g2
2006fa8: 80 a0 bf ff cmp %g2, -1
2006fac: 32 bf ff f7 bne,a 2006f88 <rtems_fdisk_ioctl+0xcac> <== NEVER TAKEN
2006fb0: aa 05 60 01 inc %l5 <== NOT EXECUTED
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);
2006fb4: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2006fb8: 80 a1 20 00 cmp %g4, 0
2006fbc: 02 80 00 cc be 20072ec <rtems_fdisk_ioctl+0x1010> <== NEVER TAKEN
2006fc0: 88 04 40 04 add %l1, %g4, %g4
2006fc4: 05 00 81 23 sethi %hi(0x2048c00), %g2
2006fc8: de 00 a0 b8 ld [ %g2 + 0xb8 ], %o7 ! 2048cb8 <rtems_fdisk_crc16_factor>
* 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;
2006fcc: 86 10 3f ff mov -1, %g3
* @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)
2006fd0: 84 10 00 11 mov %l1, %g2
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006fd4: da 08 80 00 ldub [ %g2 ], %o5
2006fd8: 86 08 e0 ff and %g3, 0xff, %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++)
2006fdc: 84 00 a0 01 inc %g2
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006fe0: 86 18 c0 0d xor %g3, %o5, %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++)
2006fe4: 80 a0 80 04 cmp %g2, %g4
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006fe8: 87 28 e0 01 sll %g3, 1, %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++)
2006fec: 12 bf ff fa bne 2006fd4 <rtems_fdisk_ioctl+0xcf8>
2006ff0: c6 13 c0 03 lduh [ %o7 + %g3 ], %g3
2006ff4: 85 28 e0 10 sll %g3, 0x10, %g2
2006ff8: 85 30 a0 10 srl %g2, 0x10, %g2
* 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;
2006ffc: c8 15 20 02 lduh [ %l4 + 2 ], %g4
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);
2007000: c6 35 00 00 sth %g3, [ %l4 ]
pd->block = block;
2007004: f2 25 20 04 st %i1, [ %l4 + 4 ]
bc->segment = sc;
2007008: f6 25 c0 16 st %i3, [ %l7 + %l6 ]
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: " \
200700c: c6 06 c0 00 ld [ %i3 ], %g3
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
bc->page = page;
2007010: ea 26 20 04 st %l5, [ %i0 + 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;
2007014: 88 09 3f fe and %g4, -2, %g4
2007018: c8 35 20 02 sth %g4, [ %l4 + 2 ]
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
200701c: d6 06 e0 08 ld [ %i3 + 8 ], %o3
2007020: d8 06 e0 0c ld [ %i3 + 0xc ], %o4
2007024: de 06 e0 1c ld [ %i3 + 0x1c ], %o7
2007028: d0 06 e0 20 ld [ %i3 + 0x20 ], %o0
200702c: 80 a0 e0 00 cmp %g3, 0
2007030: 02 80 00 ac be 20072e0 <rtems_fdisk_ioctl+0x1004> <== ALWAYS TAKEN
2007034: ec 06 e0 24 ld [ %i3 + 0x24 ], %l6
2007038: 07 00 80 cd sethi %hi(0x2033400), %g3 <== NOT EXECUTED
200703c: 86 10 e1 20 or %g3, 0x120, %g3 ! 2033520 <__FUNCTION__.7127+0x588><== NOT EXECUTED
2007040: 89 29 20 10 sll %g4, 0x10, %g4
2007044: 89 31 20 10 srl %g4, 0x10, %g4
2007048: 94 10 00 19 mov %i1, %o2
200704c: 9a 10 00 15 mov %l5, %o5
2007050: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2007054: de 23 a0 60 st %o7, [ %sp + 0x60 ]
2007058: d0 23 a0 64 st %o0, [ %sp + 0x64 ]
200705c: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
2007060: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
2007064: c4 23 a0 74 st %g2, [ %sp + 0x74 ]
2007068: f2 23 a0 78 st %i1, [ %sp + 0x78 ]
200706c: 13 00 80 cf sethi %hi(0x2033c00), %o1
2007070: ec 23 a0 68 st %l6, [ %sp + 0x68 ]
2007074: 92 12 60 30 or %o1, 0x30, %o1
2007078: 7f ff f7 7e call 2004e70 <rtems_fdisk_info>
200707c: 90 10 00 1d mov %i5, %o0
/*
* 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);
2007080: d4 06 e0 18 ld [ %i3 + 0x18 ], %o2
2007084: 90 10 00 1d mov %i5, %o0
2007088: 92 10 00 1b mov %i3, %o1
200708c: 94 05 40 0a add %l5, %o2, %o2
2007090: 7f ff f8 36 call 2005168 <rtems_fdisk_seg_write_page>
2007094: 96 10 00 11 mov %l1, %o3
if (ret)
2007098: b2 92 20 00 orcc %o0, 0, %i1
200709c: 22 80 00 86 be,a 20072b4 <rtems_fdisk_ioctl+0xfd8> <== ALWAYS TAKEN
20070a0: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
20070a4: e8 06 e0 08 ld [ %i3 + 8 ], %l4 <== NOT EXECUTED
20070a8: 40 00 7a 4b call 20259d4 <strerror> <== NOT EXECUTED
20070ac: f0 06 e0 0c ld [ %i3 + 0xc ], %i0 <== NOT EXECUTED
20070b0: 13 00 80 cf sethi %hi(0x2033c00), %o1 <== NOT EXECUTED
20070b4: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
20070b8: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
20070bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20070c0: 92 12 60 80 or %o1, 0x80, %o1 <== NOT EXECUTED
20070c4: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
20070c8: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
20070cc: 7f ff f7 69 call 2004e70 <rtems_fdisk_info> <== NOT EXECUTED
20070d0: 98 10 00 15 mov %l5, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
20070d4: 90 10 00 1d mov %i5, %o0
20070d8: 7f ff f9 0a call 2005500 <rtems_fdisk_queue_segment>
20070dc: 92 10 00 1b mov %i3, %o1
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
20070e0: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
20070e4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20070e8: 80 a0 80 01 cmp %g2, %g1
20070ec: 1a 80 00 08 bcc 200710c <rtems_fdisk_ioctl+0xe30>
20070f0: 80 a6 60 00 cmp %i1, 0
fd->starvations++;
20070f4: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
20070f8: 90 10 00 1d mov %i5, %o0
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
20070fc: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
2007100: 7f ff fa cc call 2005c30 <rtems_fdisk_compact>
2007104: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
if (ret)
2007108: 80 a6 60 00 cmp %i1, 0
200710c: 12 80 00 1c bne 200717c <rtems_fdisk_ioctl+0xea0> <== NEVER TAKEN
2007110: 92 10 20 1b mov 0x1b, %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)
2007114: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2007118: a6 04 e0 01 inc %l3
200711c: a2 04 40 01 add %l1, %g1, %l1
2007120: c2 07 bf e8 ld [ %fp + -24 ], %g1
2007124: 80 a4 c0 01 cmp %l3, %g1
2007128: 32 bf fe f7 bne,a 2006d04 <rtems_fdisk_ioctl+0xa28> <== NEVER TAKEN
200712c: f2 04 bf f0 ld [ %l2 + -16 ], %i1 <== NOT EXECUTED
2007130: f6 06 a0 10 ld [ %i2 + 0x10 ], %i3
2007134: c4 07 bf ec ld [ %fp + -20 ], %g2
2007138: a4 04 a0 10 add %l2, 0x10, %l2
200713c: 84 00 a0 01 inc %g2
2007140: 10 bf fe e3 b 2006ccc <rtems_fdisk_ioctl+0x9f0>
2007144: c4 27 bf ec st %g2, [ %fp + -20 ]
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
2007148: 7f ff fa ba call 2005c30 <rtems_fdisk_compact>
200714c: 90 10 00 1d mov %i5, %o0
2007150: f6 07 60 34 ld [ %i5 + 0x34 ], %i3
* 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)
{
if (queue->head)
2007154: 80 a6 e0 00 cmp %i3, 0
2007158: 32 bf ff 7c bne,a 2006f48 <rtems_fdisk_ioctl+0xc6c> <== ALWAYS TAKEN
200715c: c2 06 c0 00 ld [ %i3 ], %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))
2007160: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
2007164: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2007168: 12 80 01 40 bne 2007668 <rtems_fdisk_ioctl+0x138c> <== NOT EXECUTED
200716c: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
2007170: 7f ff f8 3c call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007174: 90 12 23 40 or %o0, 0x340, %o0 ! 2033f40 <__FUNCTION__.7127+0xfa8><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
2007178: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
200717c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
2007180: 9f c0 40 00 call %g1
2007184: 90 10 00 1a mov %i2, %o0
2007188: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1
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);
200718c: c4 07 bf e4 ld [ %fp + -28 ], %g2
2007190: b8 00 40 1c add %g1, %i4, %i4
break;
2007194: 10 bf fd 37 b 2006670 <rtems_fdisk_ioctl+0x394>
2007198: c0 20 80 00 clr [ %g2 ]
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
200719c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
20071a0: 7f ff f8 30 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
20071a4: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 2033ad0 <__FUNCTION__.7127+0xb38><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
20071a8: 10 bf ff f5 b 200717c <rtems_fdisk_ioctl+0xea0> <== NOT EXECUTED
20071ac: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
20071b0: d2 06 e0 08 ld [ %i3 + 8 ], %o1 <== NOT EXECUTED
20071b4: d4 06 e0 0c ld [ %i3 + 0xc ], %o2 <== NOT EXECUTED
20071b8: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
20071bc: 7f ff f8 29 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
20071c0: 90 12 20 f8 or %o0, 0xf8, %o0 ! 2033cf8 <__FUNCTION__.7127+0xd60><== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
20071c4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
20071c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20071cc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20071d0: 7f ff f8 cc call 2005500 <rtems_fdisk_queue_segment> <== NOT EXECUTED
20071d4: c2 26 e0 28 st %g1, [ %i3 + 0x28 ] <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
20071d8: 10 bf ff e9 b 200717c <rtems_fdisk_ioctl+0xea0> <== NOT EXECUTED
20071dc: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
sc->device, sc->segment, page,
flash_flags, page_desc->flags);
return ret;
}
}
return rtems_fdisk_seg_write (fd, sc, offset,
20071e0: 90 10 00 1d mov %i5, %o0
20071e4: 92 10 00 1b mov %i3, %o1
20071e8: 94 10 00 15 mov %l5, %o2
20071ec: 96 05 20 02 add %l4, 2, %o3
20071f0: 7f ff f7 a7 call 200508c <rtems_fdisk_seg_write>
20071f4: 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)
20071f8: 84 92 20 00 orcc %o0, 0, %g2
20071fc: 22 bf ff 37 be,a 2006ed8 <rtems_fdisk_ioctl+0xbfc> <== ALWAYS TAKEN
2007200: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
2007204: d4 06 e0 08 ld [ %i3 + 8 ], %o2 <== NOT EXECUTED
2007208: ea 06 e0 0c ld [ %i3 + 0xc ], %l5 <== NOT EXECUTED
200720c: e8 06 20 04 ld [ %i0 + 4 ], %l4 <== NOT EXECUTED
2007210: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2007214: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
2007218: 40 00 79 ef call 20259d4 <strerror> <== NOT EXECUTED
200721c: d4 27 bf cc st %o2, [ %fp + -52 ] <== NOT EXECUTED
2007220: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
2007224: d4 07 bf cc ld [ %fp + -52 ], %o2 <== NOT EXECUTED
2007228: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
200722c: c4 23 a0 5c st %g2, [ %sp + 0x5c ] <== NOT EXECUTED
2007230: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2007234: 13 00 80 ce sethi %hi(0x2033800), %o1 <== NOT EXECUTED
2007238: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
200723c: 92 12 63 c8 or %o1, 0x3c8, %o1 <== NOT EXECUTED
2007240: 7f ff f7 0c call 2004e70 <rtems_fdisk_info> <== NOT EXECUTED
2007244: 98 10 00 14 mov %l4, %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);
2007248: 10 bf ff 2a b 2006ef0 <rtems_fdisk_ioctl+0xc14> <== NOT EXECUTED
200724c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
2007250: d8 06 e0 0c ld [ %i3 + 0xc ], %o4
2007254: da 06 20 04 ld [ %i0 + 4 ], %o5
2007258: 90 10 00 1d mov %i5, %o0
200725c: 13 00 80 ce sethi %hi(0x2033800), %o1
2007260: 94 10 00 19 mov %i1, %o2
2007264: 7f ff f7 03 call 2004e70 <rtems_fdisk_info>
2007268: 92 12 63 48 or %o1, 0x348, %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)
200726c: 10 bf ff ab b 2007118 <rtems_fdisk_ioctl+0xe3c>
2007270: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2007274: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2007278: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
200727c: 7f ff f6 9f call 2004cf8 <rtems_fdisk_queue_status> <== NOT EXECUTED
2007280: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
2007284: d6 06 e0 08 ld [ %i3 + 8 ], %o3 <== NOT EXECUTED
2007288: d8 06 e0 0c ld [ %i3 + 0xc ], %o4 <== NOT EXECUTED
200728c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2007290: 13 00 80 cf sethi %hi(0x2033c00), %o1 <== NOT EXECUTED
2007294: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2007298: 92 12 60 08 or %o1, 8, %o1 <== NOT EXECUTED
200729c: 7f ff f6 f5 call 2004e70 <rtems_fdisk_info> <== NOT EXECUTED
20072a0: 9a 07 bf f8 add %fp, -8, %o5 <== NOT EXECUTED
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
20072a4: 10 bf ff 34 b 2006f74 <rtems_fdisk_ioctl+0xc98> <== NOT EXECUTED
20072a8: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
20072ac: 10 bf ff 2a b 2006f54 <rtems_fdisk_ioctl+0xc78>
20072b0: c0 27 60 38 clr [ %i5 + 0x38 ]
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
20072b4: 92 10 00 1b mov %i3, %o1
20072b8: 94 10 00 15 mov %l5, %o2
20072bc: 7f ff f7 9a call 2005124 <rtems_fdisk_seg_write_page_desc>
20072c0: 96 10 00 14 mov %l4, %o3
if (ret)
20072c4: b2 92 20 00 orcc %o0, 0, %i1
20072c8: 32 80 00 f0 bne,a 2007688 <rtems_fdisk_ioctl+0x13ac> <== NEVER TAKEN
20072cc: ea 06 e0 08 ld [ %i3 + 8 ], %l5 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
20072d0: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
20072d4: 82 00 60 01 inc %g1
20072d8: 10 bf ff 7f b 20070d4 <rtems_fdisk_ioctl+0xdf8>
20072dc: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
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: " \
20072e0: 07 00 80 cd sethi %hi(0x2033400), %g3
20072e4: 10 bf ff 57 b 2007040 <rtems_fdisk_ioctl+0xd64>
20072e8: 86 10 e1 28 or %g3, 0x128, %g3 ! 2033528 <__FUNCTION__.7127+0x590>
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++)
20072ec: 07 00 80 cf sethi %hi(0x2033c00), %g3 <== NOT EXECUTED
20072f0: c4 00 e3 dc ld [ %g3 + 0x3dc ], %g2 ! 2033fdc <__FUNCTION__.7127+0x1044><== NOT EXECUTED
* 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;
20072f4: 10 bf ff 42 b 2006ffc <rtems_fdisk_ioctl+0xd20> <== NOT EXECUTED
20072f8: 86 10 3f ff mov -1, %g3 <== NOT EXECUTED
count = 0;
for (device = 0; device < fd->device_count; device++)
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
20072fc: 19 00 80 ce sethi %hi(0x2033800), %o4
2007300: 10 bf fd 9d b 2006974 <rtems_fdisk_ioctl+0x698>
2007304: 98 13 21 30 or %o4, 0x130, %o4 ! 2033930 <__FUNCTION__.7127+0x998>
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
2007308: 40 00 6f d8 call 2023268 <__errno>
200730c: a2 06 a0 18 add %i2, 0x18, %l1
2007310: f6 04 20 b0 ld [ %l0 + 0xb0 ], %i3
2007314: fa 06 a0 10 ld [ %i2 + 0x10 ], %i5
2007318: d0 27 bf ec st %o0, [ %fp + -20 ]
200731c: b6 06 c0 1c add %i3, %i4, %i3
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2007320: a8 10 20 00 clr %l4
2007324: 80 a5 00 1d cmp %l4, %i5
2007328: 1a 80 00 4a bcc 2007450 <rtems_fdisk_ioctl+0x1174>
200732c: 92 10 20 00 clr %o1
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
2007330: d0 04 60 04 ld [ %l1 + 4 ], %o0
2007334: 7f ff ec d8 call 2002694 <.udiv>
2007338: d2 06 e0 14 ld [ %i3 + 0x14 ], %o1
data = sg->buffer;
200733c: f0 04 60 08 ld [ %l1 + 8 ], %i0
for (b = 0; b < fb; b++, data += fd->block_size)
2007340: 80 a2 20 00 cmp %o0, 0
2007344: 02 80 00 97 be 20075a0 <rtems_fdisk_ioctl+0x12c4> <== NEVER TAKEN
2007348: aa 10 00 08 mov %o0, %l5
200734c: a6 10 20 00 clr %l3
{
ret = rtems_fdisk_read_block (fd, sg->block + b, data);
2007350: f2 04 40 00 ld [ %l1 ], %i1
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
2007354: 90 10 00 1b mov %i3, %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);
2007358: b2 04 c0 19 add %l3, %i1, %i1
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
200735c: 13 00 80 ce sethi %hi(0x2033800), %o1
2007360: 94 10 00 19 mov %i1, %o2
2007364: 7f ff f6 c3 call 2004e70 <rtems_fdisk_info>
2007368: 92 12 61 40 or %o1, 0x140, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
200736c: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
2007370: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1
2007374: 82 20 80 01 sub %g2, %g1, %g1
2007378: 80 a6 40 01 cmp %i1, %g1
200737c: 1a 80 00 71 bcc 2007540 <rtems_fdisk_ioctl+0x1264> <== NEVER TAKEN
2007380: 83 2e 60 03 sll %i1, 3, %g1
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
2007384: e4 06 e0 18 ld [ %i3 + 0x18 ], %l2
if (!bc->segment)
2007388: fa 04 80 01 ld [ %l2 + %g1 ], %i5
200738c: 80 a7 60 00 cmp %i5, 0
2007390: 02 80 00 75 be 2007564 <rtems_fdisk_ioctl+0x1288>
2007394: a4 04 80 01 add %l2, %g1, %l2
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
2007398: da 04 a0 04 ld [ %l2 + 4 ], %o5
200739c: ee 07 60 10 ld [ %i5 + 0x10 ], %l7
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
20073a0: c8 07 40 00 ld [ %i5 ], %g4
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
20073a4: ad 2b 60 03 sll %o5, 3, %l6
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
20073a8: d6 07 60 08 ld [ %i5 + 8 ], %o3
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
20073ac: 86 05 c0 16 add %l7, %l6, %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
20073b0: d8 07 60 0c ld [ %i5 + 0xc ], %o4
20073b4: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
20073b8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
20073bc: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
20073c0: 80 a1 20 00 cmp %g4, 0
20073c4: 02 80 00 65 be 2007558 <rtems_fdisk_ioctl+0x127c>
20073c8: de 07 60 24 ld [ %i5 + 0x24 ], %o7
20073cc: 03 00 80 cd sethi %hi(0x2033400), %g1
20073d0: 88 10 61 20 or %g1, 0x120, %g4 ! 2033520 <__FUNCTION__.7127+0x588>
20073d4: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
20073d8: d2 23 a0 60 st %o1, [ %sp + 0x60 ]
20073dc: d4 23 a0 64 st %o2, [ %sp + 0x64 ]
20073e0: de 23 a0 68 st %o7, [ %sp + 0x68 ]
20073e4: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
20073e8: c8 10 e0 02 lduh [ %g3 + 2 ], %g4
20073ec: 90 10 00 1b mov %i3, %o0
20073f0: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
20073f4: c8 15 c0 16 lduh [ %l7 + %l6 ], %g4
20073f8: 13 00 80 ce sethi %hi(0x2033800), %o1
20073fc: c8 23 a0 74 st %g4, [ %sp + 0x74 ]
2007400: c8 00 e0 04 ld [ %g3 + 4 ], %g4
2007404: 92 12 61 a0 or %o1, 0x1a0, %o1
2007408: c6 27 bf d4 st %g3, [ %fp + -44 ]
200740c: 94 10 00 19 mov %i1, %o2
2007410: 7f ff f6 98 call 2004e70 <rtems_fdisk_info>
2007414: c8 23 a0 78 st %g4, [ %sp + 0x78 ]
* 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;
2007418: c6 07 bf d4 ld [ %fp + -44 ], %g3
200741c: c6 10 e0 02 lduh [ %g3 + 2 ], %g3
sc->pages, sc->pages_active, sc->pages_used, sc->pages_bad,
sc->next ? "set" : "null",
pd->flags, pd->crc, pd->block);
#endif
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
2007420: 80 88 e0 01 btst 1, %g3
2007424: 12 80 00 13 bne 2007470 <rtems_fdisk_ioctl+0x1194> <== NEVER TAKEN
2007428: 80 88 e0 02 btst 2, %g3
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
200742c: 12 80 00 1a bne 2007494 <rtems_fdisk_ioctl+0x11b8> <== ALWAYS TAKEN
2007430: 11 00 80 ce sethi %hi(0x2033800), %o0
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",
2007434: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
2007438: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
200743c: d8 04 a0 04 ld [ %l2 + 4 ], %o4 <== NOT EXECUTED
2007440: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2007444: 7f ff f7 87 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007448: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
200744c: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
2007450: c2 06 a0 04 ld [ %i2 + 4 ], %g1
2007454: 9f c0 40 00 call %g1
2007458: 90 10 00 1a mov %i2, %o0
200745c: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
2007460: c4 07 bf ec ld [ %fp + -20 ], %g2
2007464: b8 00 40 1c add %g1, %i4, %i4
break;
2007468: 10 bf fc 82 b 2006670 <rtems_fdisk_ioctl+0x394>
200746c: c0 20 80 00 clr [ %g2 ]
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
2007470: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
2007474: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
2007478: d8 04 a0 04 ld [ %l2 + 4 ], %o4 <== NOT EXECUTED
200747c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2007480: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
2007484: 7f ff f7 77 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007488: 90 12 22 90 or %o0, 0x290, %o0 ! 2033a90 <__FUNCTION__.7127+0xaf8><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
200748c: 10 bf ff f1 b 2007450 <rtems_fdisk_ioctl+0x1174> <== NOT EXECUTED
2007490: 92 10 20 1b mov 0x1b, %o1 <== 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);
2007494: d8 06 e0 14 ld [ %i3 + 0x14 ], %o4
/*
* 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,
2007498: c6 04 a0 04 ld [ %l2 + 4 ], %g3
200749c: 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,
20074a0: 92 10 00 0c mov %o4, %o1
20074a4: 90 02 00 03 add %o0, %g3, %o0
20074a8: 7f ff ec 41 call 20025ac <.umul>
20074ac: d8 27 bf c8 st %o4, [ %fp + -56 ]
20074b0: d8 07 bf c8 ld [ %fp + -56 ], %o4
20074b4: 94 10 00 08 mov %o0, %o2
20074b8: 92 10 00 1d mov %i5, %o1
20074bc: 90 10 00 1b mov %i3, %o0
20074c0: 7f ff f6 b0 call 2004f80 <rtems_fdisk_seg_read>
20074c4: 96 10 00 18 mov %i0, %o3
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
bc->page + sc->pages_desc, buffer);
if (ret)
20074c8: 86 92 20 00 orcc %o0, 0, %g3
20074cc: 32 80 00 38 bne,a 20075ac <rtems_fdisk_ioctl+0x12d0> <== NEVER TAKEN
20074d0: f0 07 60 08 ld [ %i5 + 8 ], %i0 <== NOT EXECUTED
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
20074d4: c6 06 e0 14 ld [ %i3 + 0x14 ], %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++)
20074d8: 80 a0 e0 00 cmp %g3, 0
20074dc: 02 80 00 0e be 2007514 <rtems_fdisk_ioctl+0x1238> <== NEVER TAKEN
20074e0: 88 10 3f ff mov -1, %g4
20074e4: 1f 00 81 23 sethi %hi(0x2048c00), %o7
* @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)
20074e8: ba 10 00 18 mov %i0, %i5
20074ec: da 03 e0 b8 ld [ %o7 + 0xb8 ], %o5
20074f0: 9e 06 00 03 add %i0, %g3, %o7
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
20074f4: d8 0f 40 00 ldub [ %i5 ], %o4
20074f8: 88 09 20 ff and %g4, 0xff, %g4
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20074fc: ba 07 60 01 inc %i5
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2007500: 88 19 00 0c xor %g4, %o4, %g4
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2007504: 80 a7 40 0f cmp %i5, %o7
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2007508: 89 29 20 01 sll %g4, 1, %g4
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
200750c: 12 bf ff fa bne 20074f4 <rtems_fdisk_ioctl+0x1218>
2007510: c8 13 40 04 lduh [ %o5 + %g4 ], %g4
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
2007514: d6 15 c0 16 lduh [ %l7 + %l6 ], %o3
2007518: 89 29 20 10 sll %g4, 0x10, %g4
200751c: 95 31 20 10 srl %g4, 0x10, %o2
2007520: 80 a2 80 0b cmp %o2, %o3
2007524: 02 80 00 1a be 200758c <rtems_fdisk_ioctl+0x12b0> <== ALWAYS TAKEN
2007528: 11 00 80 ce sethi %hi(0x2033800), %o0
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
200752c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2007530: 7f ff f7 4c call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2007534: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
2007538: 10 bf ff c6 b 2007450 <rtems_fdisk_ioctl+0x1174> <== NOT EXECUTED
200753c: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
2007540: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2007544: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
2007548: 7f ff f7 46 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
200754c: 90 12 21 50 or %o0, 0x150, %o0 ! 2033950 <__FUNCTION__.7127+0x9b8><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
2007550: 10 bf ff c0 b 2007450 <rtems_fdisk_ioctl+0x1174> <== NOT EXECUTED
2007554: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2007558: 05 00 80 cd sethi %hi(0x2033400), %g2
200755c: 10 bf ff 9e b 20073d4 <rtems_fdisk_ioctl+0x10f8>
2007560: 88 10 a1 28 or %g2, 0x128, %g4 ! 2033528 <__FUNCTION__.7127+0x590>
bc = &fd->blocks[block];
if (!bc->segment)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
2007564: 94 10 00 19 mov %i1, %o2
2007568: 13 00 80 ce sethi %hi(0x2033800), %o1
200756c: 90 10 00 1b mov %i3, %o0
2007570: 7f ff f6 40 call 2004e70 <rtems_fdisk_info>
2007574: 92 12 61 78 or %o1, 0x178, %o1
#endif
memset (buffer, 0xff, fd->block_size);
2007578: d4 06 e0 14 ld [ %i3 + 0x14 ], %o2
200757c: 90 10 00 18 mov %i0, %o0
2007580: 40 00 74 4d call 20246b4 <memset>
2007584: 92 10 20 ff mov 0xff, %o1
2007588: c6 06 e0 14 ld [ %i3 + 0x14 ], %g3
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)
200758c: a6 04 e0 01 inc %l3
2007590: 80 a4 c0 15 cmp %l3, %l5
2007594: 12 bf ff 6f bne 2007350 <rtems_fdisk_ioctl+0x1074> <== NEVER TAKEN
2007598: b0 06 00 03 add %i0, %g3, %i0
200759c: fa 06 a0 10 ld [ %i2 + 0x10 ], %i5
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
20075a0: a8 05 20 01 inc %l4
20075a4: 10 bf ff 60 b 2007324 <rtems_fdisk_ioctl+0x1048>
20075a8: a2 04 60 10 add %l1, 0x10, %l1
bc->page + sc->pages_desc, buffer);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
20075ac: f2 07 60 0c ld [ %i5 + 0xc ], %i1 <== NOT EXECUTED
20075b0: fa 04 a0 04 ld [ %l2 + 4 ], %i5 <== NOT EXECUTED
20075b4: 40 00 79 08 call 20259d4 <strerror> <== NOT EXECUTED
20075b8: c6 27 bf d4 st %g3, [ %fp + -44 ] <== NOT EXECUTED
20075bc: c6 07 bf d4 ld [ %fp + -44 ], %g3 <== NOT EXECUTED
20075c0: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
20075c4: c6 23 a0 5c st %g3, [ %sp + 0x5c ] <== NOT EXECUTED
20075c8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20075cc: 13 00 80 ce sethi %hi(0x2033800), %o1 <== NOT EXECUTED
20075d0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
20075d4: 92 12 61 e8 or %o1, 0x1e8, %o1 <== NOT EXECUTED
20075d8: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
20075dc: 7f ff f6 25 call 2004e70 <rtems_fdisk_info> <== NOT EXECUTED
20075e0: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
20075e4: 10 bf ff 9b b 2007450 <rtems_fdisk_ioctl+0x1174> <== NOT EXECUTED
20075e8: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
20075ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20075f0: 02 bf fc 6f be 20067ac <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
20075f4: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
{
if (!fd->devices[device].segments)
20075f8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
20075fc: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
2007600: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2007604: 02 bf fc 69 be 20067a8 <rtems_fdisk_ioctl+0x4cc> <== NOT EXECUTED
2007608: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
200760c: b4 10 20 0c mov 0xc, %i2 <== NOT EXECUTED
2007610: 10 80 00 0b b 200763c <rtems_fdisk_ioctl+0x1360> <== NOT EXECUTED
2007614: b6 10 20 00 clr %i3 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
2007618: b6 06 e0 01 inc %i3 <== NOT EXECUTED
200761c: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2007620: 1a bf fc 63 bcc 20067ac <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
2007624: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
{
if (!fd->devices[device].segments)
2007628: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
200762c: c2 00 40 1a ld [ %g1 + %i2 ], %g1 <== NOT EXECUTED
2007630: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2007634: 02 80 00 0b be 2007660 <rtems_fdisk_ioctl+0x1384> <== NOT EXECUTED
2007638: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
200763c: 7f ff fa 33 call 2005f08 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
2007640: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (ret)
2007644: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2007648: 22 bf ff f4 be,a 2007618 <rtems_fdisk_ioctl+0x133c> <== NOT EXECUTED
200764c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2007650: 10 bf fc 57 b 20067ac <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
2007654: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
2007658: 10 bf fc 54 b 20067a8 <rtems_fdisk_ioctl+0x4cc> <== NOT EXECUTED
200765c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
return ENOMEM;
2007660: 10 bf fc 52 b 20067a8 <rtems_fdisk_ioctl+0x4cc> <== NOT EXECUTED
2007664: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
/*
* 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))
rtems_fdisk_compact (fd);
2007668: 7f ff f9 72 call 2005c30 <rtems_fdisk_compact> <== NOT EXECUTED
200766c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* 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)
{
if (queue->head)
2007670: f6 07 60 34 ld [ %i5 + 0x34 ], %i3 <== NOT EXECUTED
2007674: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
2007678: 32 bf fe 34 bne,a 2006f48 <rtems_fdisk_ioctl+0xc6c> <== NOT EXECUTED
200767c: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
2007680: 10 bf fe bc b 2007170 <rtems_fdisk_ioctl+0xe94> <== NOT EXECUTED
2007684: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
2007688: e8 06 e0 0c ld [ %i3 + 0xc ], %l4 <== NOT EXECUTED
200768c: 40 00 78 d2 call 20259d4 <strerror> <== NOT EXECUTED
2007690: f0 06 20 04 ld [ %i0 + 4 ], %i0 <== NOT EXECUTED
2007694: 13 00 80 cf sethi %hi(0x2033c00), %o1 <== NOT EXECUTED
2007698: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
200769c: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
20076a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20076a4: 92 12 60 b8 or %o1, 0xb8, %o1 <== NOT EXECUTED
20076a8: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
20076ac: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
20076b0: 7f ff f5 f0 call 2004e70 <rtems_fdisk_info> <== NOT EXECUTED
20076b4: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
20076b8: 10 bf fe 88 b 20070d8 <rtems_fdisk_ioctl+0xdfc> <== NOT EXECUTED
20076bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
02005500 <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)
{
2005500: 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",
2005504: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
2005508: 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",
200550c: d4 06 60 08 ld [ %i1 + 8 ], %o2
2005510: d6 06 60 0c ld [ %i1 + 0xc ], %o3
2005514: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
2005518: da 06 60 1c ld [ %i1 + 0x1c ], %o5
200551c: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
2005520: 80 a0 60 00 cmp %g1, 0
2005524: 02 80 00 2b be 20055d0 <rtems_fdisk_queue_segment+0xd0> <== ALWAYS TAKEN
2005528: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
200552c: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
2005530: 03 00 80 cd sethi %hi(0x2033400), %g1 <== NOT EXECUTED
2005534: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2005538: 02 80 00 2b be 20055e4 <rtems_fdisk_queue_segment+0xe4> <== NOT EXECUTED
200553c: 82 10 61 10 or %g1, 0x110, %g1 <== NOT EXECUTED
2005540: 05 00 80 cd sethi %hi(0x2033400), %g2
2005544: 84 10 a1 20 or %g2, 0x120, %g2 ! 2033520 <__FUNCTION__.7127+0x588>
2005548: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
200554c: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
2005550: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
2005554: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
2005558: 90 10 00 18 mov %i0, %o0
200555c: 13 00 80 cd sethi %hi(0x2033400), %o1
2005560: 7f ff fe 44 call 2004e70 <rtems_fdisk_info>
2005564: 92 12 61 30 or %o1, 0x130, %o1 ! 2033530 <__FUNCTION__.7127+0x598>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
2005568: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
200556c: 80 a0 60 00 cmp %g1, 0
2005570: 22 80 00 2c be,a 2005620 <rtems_fdisk_queue_segment+0x120><== ALWAYS TAKEN
2005574: 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;
2005578: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED
while (it)
200557c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005580: 02 80 00 89 be 20057a4 <rtems_fdisk_queue_segment+0x2a4> <== NOT EXECUTED
2005584: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
{
if (it == sc)
2005588: 32 80 00 06 bne,a 20055a0 <rtems_fdisk_queue_segment+0xa0><== NOT EXECUTED
200558c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
2005590: 30 80 00 89 b,a 20057b4 <rtems_fdisk_queue_segment+0x2b4><== NOT EXECUTED
2005594: 02 80 00 88 be 20057b4 <rtems_fdisk_queue_segment+0x2b4> <== NOT EXECUTED
2005598: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
200559c: 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)
20055a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20055a4: 12 bf ff fc bne 2005594 <rtems_fdisk_queue_segment+0x94> <== NOT EXECUTED
20055a8: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
20055ac: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
20055b0: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
20055b4: f4 20 40 00 st %i2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
20055b8: f4 26 20 5c st %i2, [ %i0 + 0x5c ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
20055bc: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 <== NOT EXECUTED
20055c0: 82 00 60 01 inc %g1 <== NOT EXECUTED
20055c4: c2 26 20 60 st %g1, [ %i0 + 0x60 ] <== NOT EXECUTED
20055c8: 81 c7 e0 08 ret <== NOT EXECUTED
20055cc: 81 e8 00 00 restore <== NOT EXECUTED
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
20055d0: c4 06 80 00 ld [ %i2 ], %g2
20055d4: 03 00 80 cd sethi %hi(0x2033400), %g1
20055d8: 80 a0 a0 00 cmp %g2, 0
20055dc: 12 bf ff d9 bne 2005540 <rtems_fdisk_queue_segment+0x40>
20055e0: 82 10 61 18 or %g1, 0x118, %g1
20055e4: 05 00 80 cd sethi %hi(0x2033400), %g2
20055e8: 84 10 a1 28 or %g2, 0x128, %g2 ! 2033528 <__FUNCTION__.7127+0x590>
20055ec: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
20055f0: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
20055f4: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
20055f8: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
20055fc: 90 10 00 18 mov %i0, %o0
2005600: 13 00 80 cd sethi %hi(0x2033400), %o1
2005604: 7f ff fe 1b call 2004e70 <rtems_fdisk_info>
2005608: 92 12 61 30 or %o1, 0x130, %o1 ! 2033530 <__FUNCTION__.7127+0x598>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
200560c: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
2005610: 80 a0 60 00 cmp %g1, 0
2005614: 32 bf ff da bne,a 200557c <rtems_fdisk_queue_segment+0x7c><== NEVER TAKEN
2005618: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
200561c: 92 10 00 1a mov %i2, %o1
2005620: b8 06 20 34 add %i0, 0x34, %i4
2005624: 7f ff fd 94 call 2004c74 <rtems_fdisk_segment_queue_remove>
2005628: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
200562c: b6 06 20 40 add %i0, 0x40, %i3
2005630: 92 10 00 1a mov %i2, %o1
2005634: 7f ff fd 90 call 2004c74 <rtems_fdisk_segment_queue_remove>
2005638: 90 10 00 1b mov %i3, %o0
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
200563c: c6 06 a0 1c ld [ %i2 + 0x1c ], %g3
2005640: fa 06 a0 14 ld [ %i2 + 0x14 ], %i5
2005644: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1
2005648: c4 06 a0 24 ld [ %i2 + 0x24 ], %g2
200564c: 88 00 40 03 add %g1, %g3, %g4
2005650: 84 01 00 02 add %g4, %g2, %g2
* 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)
2005654: 80 a7 40 02 cmp %i5, %g2
2005658: 02 80 00 29 be 20056fc <rtems_fdisk_queue_segment+0x1fc>
200565c: 80 a0 e0 00 cmp %g3, 0
* bit is cleared for that segment. When 32 erasers
* has occurred the page is re-written to the flash
* 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;
2005660: f2 06 20 34 ld [ %i0 + 0x34 ], %i1
while (seg)
2005664: 80 a6 60 00 cmp %i1, 0
2005668: 22 80 00 57 be,a 20057c4 <rtems_fdisk_queue_segment+0x2c4>
200566c: c0 26 80 00 clr [ %i2 ]
*
* @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)
2005670: f6 06 60 20 ld [ %i1 + 0x20 ], %i3
2005674: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
2005678: c8 06 60 14 ld [ %i1 + 0x14 ], %g4
200567c: c6 06 60 1c ld [ %i1 + 0x1c ], %g3
2005680: ba 27 40 02 sub %i5, %g2, %i5
*
* @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)
2005684: 82 06 c0 01 add %i3, %g1, %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
2005688: 82 21 00 01 sub %g4, %g1, %g1
200568c: 82 20 40 03 sub %g1, %g3, %g1
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
2005690: 80 a7 40 01 cmp %i5, %g1
2005694: 3a 80 00 0e bcc,a 20056cc <rtems_fdisk_queue_segment+0x1cc>
2005698: f2 06 40 00 ld [ %i1 ], %i1
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
200569c: 7f ff ff 6f call 2005458 <rtems_fdisk_segment_queue_insert_before>
20056a0: 91 e8 00 1c restore %g0, %i4, %o0
*
* @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)
20056a4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
20056a8: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
20056ac: c4 06 60 1c ld [ %i1 + 0x1c ], %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)
20056b0: 82 01 00 01 add %g4, %g1, %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
20056b4: 82 20 c0 01 sub %g3, %g1, %g1
20056b8: 82 20 40 02 sub %g1, %g2, %g1
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
20056bc: 80 a7 40 01 cmp %i5, %g1
20056c0: 0a bf ff f7 bcs 200569c <rtems_fdisk_queue_segment+0x19c> <== NEVER TAKEN
20056c4: 01 00 00 00 nop
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
20056c8: 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)
20056cc: 80 a6 60 00 cmp %i1, 0
20056d0: 32 bf ff f5 bne,a 20056a4 <rtems_fdisk_queue_segment+0x1a4>
20056d4: c8 06 60 24 ld [ %i1 + 0x24 ], %g4
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
20056d8: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
20056dc: c0 26 80 00 clr [ %i2 ]
if (queue->head)
{
queue->tail->next = sc;
20056e0: f4 20 40 00 st %i2, [ %g1 ]
queue->tail = sc;
20056e4: f4 26 20 38 st %i2, [ %i0 + 0x38 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
20056e8: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
20056ec: 82 00 60 01 inc %g1
20056f0: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
20056f4: 81 c7 e0 08 ret
20056f8: 81 e8 00 00 restore
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
{
if (sc->pages_active)
20056fc: 22 80 00 1b be,a 2005768 <rtems_fdisk_queue_segment+0x268><== NEVER TAKEN
2005700: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
/*
* Keep the used queue sorted by the most number of used
* 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;
2005704: f2 06 20 40 ld [ %i0 + 0x40 ], %i1
while (seg)
2005708: 80 a6 60 00 cmp %i1, 0
200570c: 22 80 00 36 be,a 20057e4 <rtems_fdisk_queue_segment+0x2e4>
2005710: c0 26 80 00 clr [ %i2 ]
{
if (sc->pages_used > seg->pages_used)
2005714: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2005718: 80 a0 40 02 cmp %g1, %g2
200571c: 28 80 00 07 bleu,a 2005738 <rtems_fdisk_queue_segment+0x238>
2005720: f2 06 40 00 ld [ %i1 ], %i1
2005724: 30 80 00 26 b,a 20057bc <rtems_fdisk_queue_segment+0x2bc>
2005728: 80 a0 80 01 cmp %g2, %g1
200572c: 0a 80 00 24 bcs 20057bc <rtems_fdisk_queue_segment+0x2bc>
2005730: 01 00 00 00 nop
break;
seg = seg->next;
2005734: 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)
2005738: 80 a6 60 00 cmp %i1, 0
200573c: 32 bf ff fb bne,a 2005728 <rtems_fdisk_queue_segment+0x228>
2005740: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
2005744: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
2005748: c0 26 80 00 clr [ %i2 ]
if (queue->head)
{
queue->tail->next = sc;
200574c: f4 20 40 00 st %i2, [ %g1 ]
queue->tail = sc;
2005750: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
2005754: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
2005758: 82 00 60 01 inc %g1
200575c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
2005760: 81 c7 e0 08 ret
2005764: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
2005768: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
200576c: 02 80 00 19 be 20057d0 <rtems_fdisk_queue_segment+0x2d0> <== NOT EXECUTED
2005770: 01 00 00 00 nop <== NOT EXECUTED
{
if (sc)
{
sc->next = 0;
if (queue->head)
2005774: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED
2005778: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200577c: 02 80 00 17 be 20057d8 <rtems_fdisk_queue_segment+0x2d8> <== NOT EXECUTED
2005780: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
{
queue->tail->next = sc;
2005784: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 <== NOT EXECUTED
2005788: f4 20 40 00 st %i2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
200578c: f4 26 20 50 st %i2, [ %i0 + 0x50 ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
2005790: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED
2005794: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005798: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED
200579c: 81 c7 e0 08 ret <== NOT EXECUTED
20057a0: 81 e8 00 00 restore <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
20057a4: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
20057a8: f4 26 20 5c st %i2, [ %i0 + 0x5c ] <== NOT EXECUTED
20057ac: 10 bf ff 84 b 20055bc <rtems_fdisk_queue_segment+0xbc> <== NOT EXECUTED
20057b0: f4 26 20 58 st %i2, [ %i0 + 0x58 ] <== NOT EXECUTED
20057b4: 81 c7 e0 08 ret <== NOT EXECUTED
20057b8: 81 e8 00 00 restore <== NOT EXECUTED
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc);
20057bc: 7f ff ff 27 call 2005458 <rtems_fdisk_segment_queue_insert_before>
20057c0: 91 e8 00 1b restore %g0, %i3, %o0
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
20057c4: f4 26 20 38 st %i2, [ %i0 + 0x38 ]
20057c8: 10 bf ff c8 b 20056e8 <rtems_fdisk_queue_segment+0x1e8>
20057cc: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
20057d0: 7f ff fe c3 call 20052dc <rtems_fdisk_erase_segment> <== NOT EXECUTED
20057d4: 93 e8 00 1a restore %g0, %i2, %o1 <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
20057d8: f4 26 20 50 st %i2, [ %i0 + 0x50 ] <== NOT EXECUTED
20057dc: 10 bf ff ed b 2005790 <rtems_fdisk_queue_segment+0x290> <== NOT EXECUTED
20057e0: f4 26 20 4c st %i2, [ %i0 + 0x4c ] <== NOT EXECUTED
20057e4: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
20057e8: 10 bf ff db b 2005754 <rtems_fdisk_queue_segment+0x254>
20057ec: f4 26 20 40 st %i2, [ %i0 + 0x40 ]
02004cf8 <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;
2004cf8: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
while (it)
2004cfc: 80 a0 60 00 cmp %g1, 0
2004d00: 12 80 00 07 bne 2004d1c <rtems_fdisk_queue_status+0x24> <== ALWAYS TAKEN
2004d04: 80 a2 40 01 cmp %o1, %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' : '-';
2004d08: 10 80 00 0a b 2004d30 <rtems_fdisk_queue_status+0x38> <== NOT EXECUTED
2004d0c: 82 10 20 2d mov 0x2d, %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)
2004d10: 80 a0 60 00 cmp %g1, 0
2004d14: 02 80 00 06 be 2004d2c <rtems_fdisk_queue_status+0x34> <== ALWAYS TAKEN
2004d18: 80 a2 40 01 cmp %o1, %g1
{
if (it == sc)
2004d1c: 32 bf ff fd bne,a 2004d10 <rtems_fdisk_queue_status+0x18>
2004d20: c2 00 40 00 ld [ %g1 ], %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' : '-';
2004d24: 10 80 00 03 b 2004d30 <rtems_fdisk_queue_status+0x38>
2004d28: 82 10 20 41 mov 0x41, %g1
2004d2c: 82 10 20 2d mov 0x2d, %g1
2004d30: 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;
2004d34: c2 02 20 40 ld [ %o0 + 0x40 ], %g1
while (it)
2004d38: 80 a0 60 00 cmp %g1, 0
2004d3c: 12 80 00 07 bne 2004d58 <rtems_fdisk_queue_status+0x60> <== ALWAYS TAKEN
2004d40: 80 a2 40 01 cmp %o1, %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' : '-';
2004d44: 10 80 00 0a b 2004d6c <rtems_fdisk_queue_status+0x74> <== NOT EXECUTED
2004d48: 82 10 20 2d mov 0x2d, %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)
2004d4c: 80 a0 60 00 cmp %g1, 0
2004d50: 02 80 00 06 be 2004d68 <rtems_fdisk_queue_status+0x70>
2004d54: 80 a2 40 01 cmp %o1, %g1
{
if (it == sc)
2004d58: 32 bf ff fd bne,a 2004d4c <rtems_fdisk_queue_status+0x54>
2004d5c: c2 00 40 00 ld [ %g1 ], %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' : '-';
2004d60: 10 80 00 03 b 2004d6c <rtems_fdisk_queue_status+0x74>
2004d64: 82 10 20 55 mov 0x55, %g1
2004d68: 82 10 20 2d mov 0x2d, %g1
2004d6c: 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;
2004d70: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
while (it)
2004d74: 80 a0 60 00 cmp %g1, 0
2004d78: 12 80 00 07 bne 2004d94 <rtems_fdisk_queue_status+0x9c> <== NEVER TAKEN
2004d7c: 80 a2 40 01 cmp %o1, %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' : '-';
2004d80: 10 80 00 0a b 2004da8 <rtems_fdisk_queue_status+0xb0>
2004d84: 82 10 20 2d mov 0x2d, %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)
2004d88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004d8c: 02 80 00 06 be 2004da4 <rtems_fdisk_queue_status+0xac> <== NOT EXECUTED
2004d90: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
{
if (it == sc)
2004d94: 32 bf ff fd bne,a 2004d88 <rtems_fdisk_queue_status+0x90><== NOT EXECUTED
2004d98: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
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' : '-';
2004d9c: 10 80 00 03 b 2004da8 <rtems_fdisk_queue_status+0xb0> <== NOT EXECUTED
2004da0: 82 10 20 45 mov 0x45, %g1 <== NOT EXECUTED
2004da4: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
2004da8: 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;
2004dac: c2 02 20 58 ld [ %o0 + 0x58 ], %g1
while (it)
2004db0: 80 a0 60 00 cmp %g1, 0
2004db4: 12 80 00 07 bne 2004dd0 <rtems_fdisk_queue_status+0xd8> <== NEVER TAKEN
2004db8: 80 a2 40 01 cmp %o1, %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' : '-';
2004dbc: 10 80 00 0c b 2004dec <rtems_fdisk_queue_status+0xf4>
2004dc0: 82 10 20 2d mov 0x2d, %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)
2004dc4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004dc8: 02 80 00 08 be 2004de8 <rtems_fdisk_queue_status+0xf0> <== NOT EXECUTED
2004dcc: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
{
if (it == sc)
2004dd0: 32 bf ff fd bne,a 2004dc4 <rtems_fdisk_queue_status+0xcc><== NOT EXECUTED
2004dd4: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
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' : '-';
2004dd8: 82 10 20 46 mov 0x46, %g1 <== NOT EXECUTED
queues[4] = '\0';
2004ddc: c0 2a a0 04 clrb [ %o2 + 4 ] <== NOT EXECUTED
2004de0: 81 c3 e0 08 retl <== NOT EXECUTED
2004de4: c2 2a a0 03 stb %g1, [ %o2 + 3 ] <== NOT EXECUTED
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' : '-';
2004de8: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
queues[4] = '\0';
2004dec: c0 2a a0 04 clrb [ %o2 + 4 ]
2004df0: 81 c3 e0 08 retl
2004df4: c2 2a a0 03 stb %g1, [ %o2 + 3 ]
02005f08 <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
2005f08: 9d e3 bf 90 save %sp, -112, %sp
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
2005f0c: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
2005f10: 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;
2005f14: c0 26 20 38 clr [ %i0 + 0x38 ]
2005f18: c0 26 20 34 clr [ %i0 + 0x34 ]
queue->count = 0;
2005f1c: c0 26 20 3c clr [ %i0 + 0x3c ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005f20: c0 26 20 44 clr [ %i0 + 0x44 ]
2005f24: c0 26 20 40 clr [ %i0 + 0x40 ]
queue->count = 0;
2005f28: c0 26 20 48 clr [ %i0 + 0x48 ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005f2c: c0 26 20 50 clr [ %i0 + 0x50 ]
2005f30: c0 26 20 4c clr [ %i0 + 0x4c ]
queue->count = 0;
2005f34: c0 26 20 54 clr [ %i0 + 0x54 ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005f38: c0 26 20 5c clr [ %i0 + 0x5c ]
2005f3c: c0 26 20 58 clr [ %i0 + 0x58 ]
queue->count = 0;
2005f40: c0 26 20 60 clr [ %i0 + 0x60 ]
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
2005f44: 92 10 20 00 clr %o1
2005f48: 40 00 79 db call 20246b4 <memset>
2005f4c: 95 2a a0 03 sll %o2, 3, %o2
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
2005f50: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
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;
2005f54: c0 26 20 28 clr [ %i0 + 0x28 ]
fd->starvation_threshold = 0;
2005f58: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
2005f5c: 80 a0 e0 00 cmp %g3, 0
2005f60: 02 80 00 82 be 2006168 <rtems_fdisk_recover_block_mappings+0x260><== NEVER TAKEN
2005f64: ae 10 00 18 mov %i0, %l7
2005f68: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
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);
2005f6c: 25 00 80 ce sethi %hi(0x2033800), %l2
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005f70: 29 00 80 ce sethi %hi(0x2033800), %l4
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2005f74: 2d 00 80 ce sethi %hi(0x2033800), %l6
* 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: " \
2005f78: 27 00 80 ce sethi %hi(0x2033800), %l3
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,
2005f7c: 2b 00 80 ce sethi %hi(0x2033800), %l5
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
2005f80: a2 10 20 00 clr %l1
2005f84: b2 10 20 00 clr %i1
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
2005f88: a4 14 a0 18 or %l2, 0x18, %l2
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005f8c: a8 15 20 88 or %l4, 0x88, %l4
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2005f90: ac 15 a0 a8 or %l6, 0xa8, %l6
* 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: " \
2005f94: a6 14 e1 00 or %l3, 0x100, %l3
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,
2005f98: aa 15 60 d0 or %l5, 0xd0, %l5
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
2005f9c: 82 00 80 11 add %g2, %l1, %g1
2005fa0: c8 00 60 04 ld [ %g1 + 4 ], %g4
2005fa4: a0 10 20 00 clr %l0
2005fa8: 80 a1 20 00 cmp %g4, 0
2005fac: 02 80 00 6b be 2006158 <rtems_fdisk_recover_block_mappings+0x250><== NEVER TAKEN
2005fb0: b4 10 20 00 clr %i2
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
2005fb4: f6 00 40 00 ld [ %g1 ], %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);
2005fb8: 94 10 00 19 mov %i1, %o2
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
2005fbc: b6 06 c0 10 add %i3, %l0, %i3
const rtems_fdisk_segment_desc* sd = sc->descriptor;
2005fc0: fa 06 e0 04 ld [ %i3 + 4 ], %i5
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);
2005fc4: 96 10 00 1a mov %i2, %o3
2005fc8: 92 10 00 12 mov %l2, %o1
2005fcc: 7f ff fb a9 call 2004e70 <rtems_fdisk_info>
2005fd0: 90 10 00 17 mov %l7, %o0
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
2005fd4: d0 07 60 08 ld [ %i5 + 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);
2005fd8: f8 05 e0 14 ld [ %l7 + 0x14 ], %i4
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
2005fdc: 7f ff f1 ae call 2002694 <.udiv>
2005fe0: 92 10 00 1c mov %i4, %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;
2005fe4: 92 10 00 1c mov %i4, %o1
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
2005fe8: ba 10 00 08 mov %o0, %i5
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);
2005fec: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
2005ff0: 7f ff f1 a9 call 2002694 <.udiv>
2005ff4: 90 02 3f ff add %o0, -1, %o0
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
2005ff8: c4 05 e0 24 ld [ %l7 + 0x24 ], %g2
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;
2005ffc: 90 02 20 01 inc %o0
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;
2006000: 82 27 40 08 sub %i5, %o0, %g1
#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);
2006004: d0 26 e0 18 st %o0, [ %i3 + 0x18 ]
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
2006008: 80 a0 40 02 cmp %g1, %g2
200600c: 08 80 00 03 bleu 2006018 <rtems_fdisk_recover_block_mappings+0x110>
2006010: c2 26 e0 14 st %g1, [ %i3 + 0x14 ]
fd->starvation_threshold = sc->pages;
2006014: c2 25 e0 24 st %g1, [ %l7 + 0x24 ]
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
2006018: fa 06 e0 10 ld [ %i3 + 0x10 ], %i5
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
sc->pages_active = 0;
200601c: c0 26 e0 1c clr [ %i3 + 0x1c ]
sc->pages_used = 0;
2006020: c0 26 e0 20 clr [ %i3 + 0x20 ]
sc->pages_bad = 0;
2006024: c0 26 e0 24 clr [ %i3 + 0x24 ]
sc->failed = false;
2006028: c0 26 e0 28 clr [ %i3 + 0x28 ]
if (!sc->page_descriptors)
200602c: 80 a7 60 00 cmp %i5, 0
2006030: 02 80 00 94 be 2006280 <rtems_fdisk_recover_block_mappings+0x378><== ALWAYS TAKEN
2006034: 92 10 00 1c mov %i4, %o1
2006038: 7f ff f1 5d call 20025ac <.umul> <== NOT EXECUTED
200603c: 01 00 00 00 nop <== NOT EXECUTED
2006040: 98 10 00 08 mov %o0, %o4 <== 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,
2006044: 90 10 00 17 mov %l7, %o0
2006048: 92 10 00 1b mov %i3, %o1
200604c: 94 10 20 00 clr %o2
2006050: 7f ff fb cc call 2004f80 <rtems_fdisk_seg_read>
2006054: 96 10 00 1d mov %i5, %o3
sc->pages_desc * fd->block_size);
if (ret)
2006058: b0 92 20 00 orcc %o0, 0, %i0
200605c: 12 80 00 95 bne 20062b0 <rtems_fdisk_recover_block_mappings+0x3a8><== NEVER TAKEN
2006060: 01 00 00 00 nop
* 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++)
2006064: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
2006068: 80 a0 a0 00 cmp %g2, 0
200606c: 12 80 00 0a bne 2006094 <rtems_fdisk_recover_block_mappings+0x18c><== ALWAYS TAKEN
2006070: b8 10 20 00 clr %i4
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
2006074: 10 80 00 2f b 2006130 <rtems_fdisk_recover_block_mappings+0x228><== NOT EXECUTED
2006078: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
{
sc->pages_used++;
200607c: 82 00 60 01 inc %g1 <== NOT EXECUTED
2006080: c2 26 e0 20 st %g1, [ %i3 + 0x20 ] <== 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++)
2006084: b8 07 20 01 inc %i4
2006088: 80 a0 80 1c cmp %g2, %i4
200608c: 08 80 00 28 bleu 200612c <rtems_fdisk_recover_block_mappings+0x224>
2006090: ba 07 60 08 add %i5, 8, %i5
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
2006094: c2 07 40 00 ld [ %i5 ], %g1
2006098: 80 a0 7f ff cmp %g1, -1
200609c: 22 80 00 35 be,a 2006170 <rtems_fdisk_recover_block_mappings+0x268><== ALWAYS TAKEN
20060a0: c2 07 60 04 ld [ %i5 + 4 ], %g1
* 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;
20060a4: c2 17 60 02 lduh [ %i5 + 2 ], %g1 <== NOT EXECUTED
sc->pages_used++;
}
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
20060a8: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
20060ac: 22 bf ff f4 be,a 200607c <rtems_fdisk_recover_block_mappings+0x174><== NOT EXECUTED
20060b0: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
{
sc->pages_used++;
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
20060b4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
20060b8: 32 80 00 43 bne,a 20061c4 <rtems_fdisk_recover_block_mappings+0x2bc><== NOT EXECUTED
20060bc: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
20060c0: da 07 60 04 ld [ %i5 + 4 ], %o5 <== NOT EXECUTED
20060c4: c2 05 e0 1c ld [ %l7 + 0x1c ], %g1 <== NOT EXECUTED
20060c8: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
20060cc: 1a 80 00 57 bcc 2006228 <rtems_fdisk_recover_block_mappings+0x320><== NOT EXECUTED
20060d0: 90 10 00 17 mov %l7, %o0 <== 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)
20060d4: c6 05 e0 18 ld [ %l7 + 0x18 ], %g3 <== NOT EXECUTED
20060d8: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
20060dc: c2 00 c0 0d ld [ %g3 + %o5 ], %g1 <== NOT EXECUTED
20060e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20060e4: 02 80 00 5b be 2006250 <rtems_fdisk_recover_block_mappings+0x348><== NOT EXECUTED
20060e8: 88 00 c0 0d add %g3, %o5, %g4 <== 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: " \
20060ec: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
20060f0: d4 00 60 0c ld [ %g1 + 0xc ], %o2 <== NOT EXECUTED
20060f4: d6 01 20 04 ld [ %g4 + 4 ], %o3 <== NOT EXECUTED
20060f8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
20060fc: f8 23 a0 5c st %i4, [ %sp + 0x5c ] <== NOT EXECUTED
2006100: 98 10 00 19 mov %i1, %o4 <== NOT EXECUTED
2006104: 7f ff fc 57 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2006108: 9a 10 00 1a mov %i2, %o5 <== NOT EXECUTED
"duplicate: %d-%d-%d",
bsc->device, bsc->segment,
fd->blocks[pd->block].page,
device, segment, page);
sc->pages_bad++;
200610c: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
2006110: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
2006114: 82 00 60 01 inc %g1 <== NOT EXECUTED
2006118: c2 26 e0 24 st %g1, [ %i3 + 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++)
200611c: b8 07 20 01 inc %i4 <== NOT EXECUTED
2006120: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED
2006124: 18 bf ff dc bgu 2006094 <rtems_fdisk_recover_block_mappings+0x18c><== NOT EXECUTED
2006128: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
200612c: 90 10 00 17 mov %l7, %o0
2006130: 7f ff fc f4 call 2005500 <rtems_fdisk_queue_segment>
2006134: 92 10 00 1b mov %i3, %o1
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
2006138: c4 05 e0 2c ld [ %l7 + 0x2c ], %g2
200613c: b4 06 a0 01 inc %i2
2006140: 82 00 80 11 add %g2, %l1, %g1
2006144: c6 00 60 04 ld [ %g1 + 4 ], %g3
2006148: 80 a0 c0 1a cmp %g3, %i2
200614c: 18 bf ff 9a bgu 2005fb4 <rtems_fdisk_recover_block_mappings+0xac>
2006150: a0 04 20 30 add %l0, 0x30, %l0
2006154: c6 05 e0 30 ld [ %l7 + 0x30 ], %g3
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
2006158: b2 06 60 01 inc %i1
200615c: 80 a0 c0 19 cmp %g3, %i1
2006160: 18 bf ff 8f bgu 2005f9c <rtems_fdisk_recover_block_mappings+0x94><== NEVER TAKEN
2006164: a2 04 60 0c add %l1, 0xc, %l1
*/
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
2006168: 81 c7 e0 08 ret
200616c: 91 e8 20 00 restore %g0, 0, %o0
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
2006170: 80 a0 7f ff cmp %g1, -1
2006174: 32 bf ff cd bne,a 20060a8 <rtems_fdisk_recover_block_mappings+0x1a0><== NEVER TAKEN
2006178: c2 17 60 02 lduh [ %i5 + 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);
200617c: f0 05 e0 14 ld [ %l7 + 0x14 ], %i0
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
2006180: d0 06 e0 18 ld [ %i3 + 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,
2006184: 92 10 00 18 mov %i0, %o1
2006188: 7f ff f1 09 call 20025ac <.umul>
200618c: 90 07 00 08 add %i4, %o0, %o0
2006190: 92 10 00 1b mov %i3, %o1
2006194: 94 10 00 08 mov %o0, %o2
2006198: 96 10 00 18 mov %i0, %o3
200619c: 7f ff fb 9b call 2005008 <rtems_fdisk_seg_blank_check>
20061a0: 90 10 00 17 mov %l7, %o0
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
page + sc->pages_desc);
if (ret == 0)
20061a4: 80 a2 20 00 cmp %o0, 0
20061a8: 32 80 00 0a bne,a 20061d0 <rtems_fdisk_recover_block_mappings+0x2c8><== NEVER TAKEN
20061ac: da 07 60 04 ld [ %i5 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
20061b0: c2 05 e0 28 ld [ %l7 + 0x28 ], %g1
20061b4: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
20061b8: 82 00 60 01 inc %g1
20061bc: 10 bf ff b2 b 2006084 <rtems_fdisk_recover_block_mappings+0x17c>
20061c0: c2 25 e0 28 st %g1, [ %l7 + 0x28 ]
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
20061c4: 82 00 60 01 inc %g1 <== NOT EXECUTED
20061c8: 10 bf ff af b 2006084 <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
20061cc: c2 26 e0 24 st %g1, [ %i3 + 0x24 ] <== NOT EXECUTED
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
20061d0: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
20061d4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
20061d8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
20061dc: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
20061e0: 7f ff fb fe call 20051d8 <rtems_fdisk_warning> <== NOT EXECUTED
20061e4: 90 10 00 17 mov %l7, %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;
20061e8: c2 17 60 02 lduh [ %i5 + 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,
20061ec: 90 10 00 17 mov %l7, %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;
20061f0: 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,
20061f4: 92 10 00 1b mov %i3, %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;
20061f8: c2 37 60 02 sth %g1, [ %i5 + 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,
20061fc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2006200: 7f ff fb c9 call 2005124 <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
2006204: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
page, pd);
if (ret)
2006208: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200620c: 12 80 00 17 bne 2006268 <rtems_fdisk_recover_block_mappings+0x360><== NOT EXECUTED
2006210: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
device, segment, page);
}
sc->pages_used++;
2006214: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
2006218: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
200621c: 82 00 60 01 inc %g1 <== NOT EXECUTED
2006220: 10 bf ff 99 b 2006084 <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
2006224: c2 26 e0 20 st %g1, [ %i3 + 0x20 ] <== NOT EXECUTED
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,
2006228: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
200622c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2006230: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
2006234: 7f ff fb e9 call 20051d8 <rtems_fdisk_warning> <== NOT EXECUTED
2006238: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
200623c: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
2006240: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
2006244: 82 00 60 01 inc %g1 <== NOT EXECUTED
2006248: 10 bf ff 8f b 2006084 <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
200624c: c2 26 e0 24 st %g1, [ %i3 + 0x24 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
2006250: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
2006254: f6 20 c0 0d st %i3, [ %g3 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
2006258: f8 21 20 04 st %i4, [ %g4 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
200625c: 82 00 60 01 inc %g1 <== NOT EXECUTED
2006260: 10 bf ff 89 b 2006084 <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
2006264: c2 26 e0 1c st %g1, [ %i3 + 0x1c ] <== NOT EXECUTED
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2006268: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200626c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2006270: 7f ff fb fc call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2006274: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
device, segment, page);
}
sc->pages_used++;
2006278: 10 bf ff e8 b 2006218 <rtems_fdisk_recover_block_mappings+0x310><== NOT EXECUTED
200627c: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
2006280: 7f ff f0 cb call 20025ac <.umul>
2006284: 01 00 00 00 nop
2006288: 40 00 0a fc call 2008e78 <malloc>
200628c: d0 27 bf fc st %o0, [ %fp + -4 ]
2006290: d0 26 e0 10 st %o0, [ %i3 + 0x10 ]
2006294: ba 10 00 08 mov %o0, %i5
if (!sc->page_descriptors)
2006298: 80 a2 20 00 cmp %o0, 0
200629c: 12 bf ff 6a bne 2006044 <rtems_fdisk_recover_block_mappings+0x13c><== ALWAYS TAKEN
20062a0: d8 07 bf fc ld [ %fp + -4 ], %o4
rtems_fdisk_abort ("no memory for page descriptors");
20062a4: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
20062a8: 40 00 06 53 call 2007bf4 <rtems_fdisk_abort.constprop.1> <== NOT EXECUTED
20062ac: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 20337f8 <__FUNCTION__.7127+0x860><== NOT EXECUTED
ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,
sc->pages_desc * fd->block_size);
if (ret)
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
20062b0: 40 00 7d c9 call 20259d4 <strerror> <== NOT EXECUTED
20062b4: 01 00 00 00 nop <== NOT EXECUTED
20062b8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20062bc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20062c0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20062c4: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
20062c8: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
20062cc: 7f ff fb e5 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
20062d0: 90 12 20 40 or %o0, 0x40, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
20062d4: 81 c7 e0 08 ret <== NOT EXECUTED
20062d8: 81 e8 00 00 restore <== NOT EXECUTED
020057f0 <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)
{
20057f0: 9d e3 bf 78 save %sp, -136, %sp
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
20057f4: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
20057f8: c0 27 bf f8 clr [ %fp + -8 ]
20057fc: 80 a0 e0 00 cmp %g3, 0
2005800: 02 80 00 7f be 20059fc <rtems_fdisk_recycle_segment+0x20c><== NEVER TAKEN
2005804: a4 10 20 00 clr %l2
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005808: 82 06 20 34 add %i0, 0x34, %g1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
200580c: b8 10 20 00 clr %i4
/*
* 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);
2005810: c2 27 bf f4 st %g1, [ %fp + -12 ]
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
2005814: e2 06 60 10 ld [ %i1 + 0x10 ], %l1
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005818: a1 2f 20 03 sll %i4, 3, %l0
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
200581c: 80 a6 a0 00 cmp %i2, 0
2005820: 02 80 00 8d be 2005a54 <rtems_fdisk_recycle_segment+0x264>
2005824: ac 04 40 10 add %l1, %l0, %l6
* 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;
2005828: c4 15 a0 02 lduh [ %l6 + 2 ], %g2
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
200582c: 80 88 a0 01 btst 1, %g2
2005830: 32 80 00 6b bne,a 20059dc <rtems_fdisk_recycle_segment+0x1ec><== NEVER TAKEN
2005834: c4 04 40 10 ld [ %l1 + %l0 ], %g2 <== NOT EXECUTED
2005838: 80 88 a0 02 btst 2, %g2
200583c: 22 80 00 68 be,a 20059dc <rtems_fdisk_recycle_segment+0x1ec>
2005840: c4 04 40 10 ld [ %l1 + %l0 ], %g2
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++)
2005844: de 06 a0 14 ld [ %i2 + 0x14 ], %o7
2005848: 80 a3 e0 00 cmp %o7, 0
200584c: 02 80 00 8d be 2005a80 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
2005850: ee 06 a0 10 ld [ %i2 + 0x10 ], %l7
2005854: 84 10 00 17 mov %l7, %g2
2005858: 10 80 00 05 b 200586c <rtems_fdisk_recycle_segment+0x7c>
200585c: ba 10 20 00 clr %i5
2005860: 80 a7 40 0f cmp %i5, %o7
2005864: 02 80 00 87 be 2005a80 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
2005868: 84 00 a0 08 add %g2, 8, %g2
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
200586c: c8 00 80 00 ld [ %g2 ], %g4
2005870: 80 a1 3f ff cmp %g4, -1
2005874: 32 bf ff fb bne,a 2005860 <rtems_fdisk_recycle_segment+0x70>
2005878: ba 07 60 01 inc %i5
200587c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
2005880: 80 a1 3f ff cmp %g4, -1
2005884: 32 bf ff f7 bne,a 2005860 <rtems_fdisk_recycle_segment+0x70><== NEVER TAKEN
2005888: ba 07 60 01 inc %i5 <== NOT EXECUTED
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
200588c: 83 2f 60 03 sll %i5, 3, %g1
2005890: c2 27 bf fc st %g1, [ %fp + -4 ]
active++;
2005894: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (dpage >= dsc->pages)
2005898: 80 a7 40 0f cmp %i5, %o7
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
200589c: 82 00 60 01 inc %g1
20058a0: c2 27 bf f8 st %g1, [ %fp + -8 ]
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
20058a4: c2 07 bf fc ld [ %fp + -4 ], %g1
active++;
if (dpage >= dsc->pages)
20058a8: 1a 80 00 76 bcc 2005a80 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
20058ac: a6 05 c0 01 add %l7, %g1, %l3
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",
20058b0: da 06 a0 08 ld [ %i2 + 8 ], %o5
20058b4: c4 06 a0 0c ld [ %i2 + 0xc ], %g2
20058b8: d4 06 60 08 ld [ %i1 + 8 ], %o2
20058bc: d6 06 60 0c ld [ %i1 + 0xc ], %o3
20058c0: 98 10 00 1c mov %i4, %o4
20058c4: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
20058c8: 13 00 80 cd sethi %hi(0x2033400), %o1
20058cc: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
20058d0: 92 12 61 c0 or %o1, 0x1c0, %o1
20058d4: 7f ff fd 67 call 2004e70 <rtems_fdisk_info>
20058d8: 90 10 00 18 mov %i0, %o0
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
20058dc: c8 06 a0 18 ld [ %i2 + 0x18 ], %g4
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",
20058e0: da 06 a0 08 ld [ %i2 + 8 ], %o5
20058e4: de 06 a0 0c ld [ %i2 + 0xc ], %o7
#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,
20058e8: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
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",
20058ec: d4 06 60 08 ld [ %i1 + 8 ], %o2
20058f0: 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,
20058f4: a8 07 00 02 add %i4, %g2, %l4
20058f8: aa 07 40 04 add %i5, %g4, %l5
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",
20058fc: de 23 a0 5c st %o7, [ %sp + 0x5c ]
2005900: 98 10 00 14 mov %l4, %o4
2005904: 13 00 80 cd sethi %hi(0x2033400), %o1
2005908: ea 23 a0 60 st %l5, [ %sp + 0x60 ]
200590c: 92 12 61 e8 or %o1, 0x1e8, %o1
2005910: 7f ff fd 7a call 2004ef8 <rtems_fdisk_printf>
2005914: 90 10 00 18 mov %i0, %o0
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
page * fd->block_size, buffer, fd->block_size);
2005918: 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,
200591c: 90 10 00 14 mov %l4, %o0
2005920: 92 10 00 0c mov %o4, %o1
2005924: 7f ff f3 22 call 20025ac <.umul>
2005928: d8 27 bf ec st %o4, [ %fp + -20 ]
200592c: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
2005930: d8 07 bf ec ld [ %fp + -20 ], %o4
2005934: 94 10 00 08 mov %o0, %o2
2005938: 92 10 00 19 mov %i1, %o1
200593c: 7f ff fd 91 call 2004f80 <rtems_fdisk_seg_read>
2005940: 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)
2005944: 84 92 20 00 orcc %o0, 0, %g2
2005948: 22 80 00 6a be,a 2005af0 <rtems_fdisk_recycle_segment+0x300><== ALWAYS TAKEN
200594c: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005950: e2 06 a0 08 ld [ %i2 + 8 ], %l1 <== NOT EXECUTED
2005954: e0 06 a0 0c ld [ %i2 + 0xc ], %l0 <== NOT EXECUTED
2005958: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
200595c: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2005960: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2005964: 40 00 80 1c call 20259d4 <strerror> <== NOT EXECUTED
2005968: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
200596c: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
2005970: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2005974: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2005978: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
200597c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
2005980: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
2005984: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
2005988: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
200598c: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED
2005990: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2005994: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005998: 7f ff fe 32 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
200599c: 01 00 00 00 nop <== 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);
20059a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20059a4: 7f ff fe d7 call 2005500 <rtems_fdisk_queue_segment> <== NOT EXECUTED
20059a8: 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;
20059ac: c6 06 20 40 ld [ %i0 + 0x40 ], %g3 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
20059b0: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== 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;
20059b4: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
20059b8: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
if (queue->tail == 0)
20059bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20059c0: 02 80 00 98 be 2005c20 <rtems_fdisk_recycle_segment+0x430><== NOT EXECUTED
20059c4: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
queue->tail = sc;
queue->count++;
20059c8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
20059cc: 82 00 60 01 inc %g1 <== NOT EXECUTED
20059d0: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
}
ret = rtems_fdisk_erase_segment (fd, ssc);
return ret;
}
20059d4: 81 c7 e0 08 ret <== NOT EXECUTED
20059d8: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
20059dc: 80 a0 bf ff cmp %g2, -1
20059e0: 22 80 00 16 be,a 2005a38 <rtems_fdisk_recycle_segment+0x248><== NEVER TAKEN
20059e4: c2 05 a0 04 ld [ %l6 + 4 ], %g1 <== NOT EXECUTED
{
--fd->erased_blocks;
}
else
{
used++;
20059e8: a4 04 a0 01 inc %l2
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
20059ec: b8 07 20 01 inc %i4
20059f0: 80 a0 c0 1c cmp %g3, %i4
20059f4: 38 bf ff 89 bgu,a 2005818 <rtems_fdisk_recycle_segment+0x28>
20059f8: e2 06 60 10 ld [ %i1 + 0x10 ], %l1
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
20059fc: d4 06 60 08 ld [ %i1 + 8 ], %o2
2005a00: d6 06 60 0c ld [ %i1 + 0xc ], %o3
2005a04: da 07 bf f8 ld [ %fp + -8 ], %o5
2005a08: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
2005a0c: 90 10 00 18 mov %i0, %o0
2005a10: 13 00 80 cd sethi %hi(0x2033400), %o1
2005a14: 98 10 00 1b mov %i3, %o4
2005a18: 7f ff fd 38 call 2004ef8 <rtems_fdisk_printf>
2005a1c: 92 12 62 a8 or %o1, 0x2a8, %o1
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
2005a20: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
2005a24: 80 a2 60 00 cmp %o1, 0
2005a28: 12 80 00 69 bne 2005bcc <rtems_fdisk_recycle_segment+0x3dc><== NEVER TAKEN
2005a2c: 11 00 80 cd sethi %hi(0x2033400), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
2005a30: 7f ff fe 2b call 20052dc <rtems_fdisk_erase_segment>
2005a34: 81 e8 00 00 restore
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
2005a38: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
2005a3c: 32 bf ff ec bne,a 20059ec <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
2005a40: a4 04 a0 01 inc %l2 <== NOT EXECUTED
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
{
--fd->erased_blocks;
2005a44: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
2005a48: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2005a4c: 10 bf ff e8 b 20059ec <rtems_fdisk_recycle_segment+0x1fc> <== NOT EXECUTED
2005a50: c2 26 20 28 st %g1, [ %i0 + 0x28 ] <== NOT EXECUTED
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
2005a54: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
2005a58: 80 a0 a0 00 cmp %g2, 0
2005a5c: 22 bf ff 74 be,a 200582c <rtems_fdisk_recycle_segment+0x3c><== ALWAYS TAKEN
2005a60: c4 15 a0 02 lduh [ %l6 + 2 ], %g2
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
2005a64: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
{
rtems_fdisk_error ("recycle: no available dst segment");
2005a68: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
2005a6c: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
2005a70: 7f ff fd fc call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2005a74: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED
return EIO;
2005a78: 10 bf ff d7 b 20059d4 <rtems_fdisk_recycle_segment+0x1e4> <== NOT EXECUTED
2005a7c: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005a80: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2 <== NOT EXECUTED
2005a84: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1 <== NOT EXECUTED
2005a88: d6 06 a0 24 ld [ %i2 + 0x24 ], %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
2005a8c: d2 06 a0 08 ld [ %i2 + 8 ], %o1 <== NOT EXECUTED
2005a90: d4 06 a0 0c ld [ %i2 + 0xc ], %o2 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005a94: 96 02 c0 02 add %o3, %g2, %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
2005a98: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005a9c: 96 02 c0 01 add %o3, %g1, %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
2005aa0: 96 23 c0 0b sub %o7, %o3, %o3 <== NOT EXECUTED
2005aa4: 7f ff fd ef call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2005aa8: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
2005aac: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
2005ab0: 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;
2005ab4: c2 26 a0 28 st %g1, [ %i2 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
2005ab8: 7f ff fe 92 call 2005500 <rtems_fdisk_queue_segment> <== NOT EXECUTED
2005abc: 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;
2005ac0: c4 06 20 40 ld [ %i0 + 0x40 ], %g2 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
2005ac4: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== 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;
2005ac8: c4 26 40 00 st %g2, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
2005acc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005ad0: 02 80 00 56 be 2005c28 <rtems_fdisk_recycle_segment+0x438><== NOT EXECUTED
2005ad4: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
queue->tail = sc;
queue->count++;
2005ad8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return EIO;
2005adc: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
sc->next = queue->head;
queue->head = sc;
if (queue->tail == 0)
queue->tail = sc;
queue->count++;
2005ae0: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005ae4: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
}
ret = rtems_fdisk_erase_segment (fd, ssc);
return ret;
}
2005ae8: 81 c7 e0 08 ret <== NOT EXECUTED
2005aec: 91 e8 00 02 restore %g0, %g2, %o0 <== 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,
2005af0: 90 10 00 18 mov %i0, %o0
2005af4: 92 10 00 1a mov %i2, %o1
2005af8: 7f ff fd 9c call 2005168 <rtems_fdisk_seg_write_page>
2005afc: 94 10 00 15 mov %l5, %o2
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
2005b00: 84 92 20 00 orcc %o0, 0, %g2
2005b04: 12 bf ff 93 bne 2005950 <rtems_fdisk_recycle_segment+0x160><== NEVER TAKEN
2005b08: c2 07 bf fc ld [ %fp + -4 ], %g1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
2005b0c: c4 04 40 10 ld [ %l1 + %l0 ], %g2
ret = rtems_fdisk_seg_write_page_desc (fd,
2005b10: 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;
2005b14: c4 25 c0 01 st %g2, [ %l7 + %g1 ]
2005b18: c4 05 a0 04 ld [ %l6 + 4 ], %g2
ret = rtems_fdisk_seg_write_page_desc (fd,
2005b1c: 92 10 00 1a mov %i2, %o1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
2005b20: c4 24 e0 04 st %g2, [ %l3 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
2005b24: 94 10 00 1d mov %i5, %o2
2005b28: 7f ff fd 7f call 2005124 <rtems_fdisk_seg_write_page_desc>
2005b2c: 96 10 00 13 mov %l3, %o3
dsc,
dpage, dpd);
if (ret)
2005b30: 84 92 20 00 orcc %o0, 0, %g2
2005b34: 32 80 00 2a bne,a 2005bdc <rtems_fdisk_recycle_segment+0x3ec><== NEVER TAKEN
2005b38: e2 06 a0 08 ld [ %i2 + 8 ], %l1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
2005b3c: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
ssc->pages_used++;
2005b40: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
2005b44: 84 00 a0 01 inc %g2
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
2005b48: c2 05 a0 04 ld [ %l6 + 4 ], %g1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
2005b4c: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
2005b50: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
* 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--;
2005b54: c8 06 60 1c ld [ %i1 + 0x1c ], %g4
ssc->pages_used++;
2005b58: 86 00 e0 01 inc %g3
fd->blocks[spd->block].segment = dsc;
2005b5c: 83 28 60 03 sll %g1, 3, %g1
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
ssc->pages_used++;
2005b60: c6 26 60 20 st %g3, [ %i1 + 0x20 ]
* 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--;
2005b64: 88 01 3f ff add %g4, -1, %g4
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
2005b68: 86 00 80 01 add %g2, %g1, %g3
* 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--;
2005b6c: c8 26 60 1c st %g4, [ %i1 + 0x1c ]
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
2005b70: f4 20 80 01 st %i2, [ %g2 + %g1 ]
fd->blocks[spd->block].page = dpage;
2005b74: fa 20 e0 04 st %i5, [ %g3 + 4 ]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
2005b78: 90 10 00 18 mov %i0, %o0
2005b7c: 7f ff fe 61 call 2005500 <rtems_fdisk_queue_segment>
2005b80: 92 10 00 1a mov %i2, %o1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
2005b84: c8 06 a0 20 ld [ %i2 + 0x20 ], %g4
2005b88: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
2005b8c: c6 06 a0 24 ld [ %i2 + 0x24 ], %g3
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
2005b90: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
2005b94: 82 01 00 01 add %g4, %g1, %g1
2005b98: 82 00 40 03 add %g1, %g3, %g1
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
2005b9c: 80 a0 80 01 cmp %g2, %g1
2005ba0: 02 80 00 07 be 2005bbc <rtems_fdisk_recycle_segment+0x3cc>
2005ba4: 01 00 00 00 nop
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
2005ba8: c2 06 c0 00 ld [ %i3 ], %g1
2005bac: 82 00 7f ff add %g1, -1, %g1
2005bb0: c2 26 c0 00 st %g1, [ %i3 ]
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
!rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
{
2005bb4: 10 bf ff 8e b 20059ec <rtems_fdisk_recycle_segment+0x1fc>
2005bb8: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
/*
* 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);
2005bbc: 7f ff fc 8f call 2004df8 <rtems_fdisk_seg_most_available>
2005bc0: d0 07 bf f4 ld [ %fp + -12 ], %o0
2005bc4: 10 bf ff f9 b 2005ba8 <rtems_fdisk_recycle_segment+0x3b8>
2005bc8: b4 10 00 08 mov %o0, %i2
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
2005bcc: 7f ff fd a5 call 2005260 <rtems_fdisk_error> <== NOT EXECUTED
2005bd0: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
2005bd4: 7f ff fd c2 call 20052dc <rtems_fdisk_erase_segment> <== NOT EXECUTED
2005bd8: 81 e8 00 00 restore <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005bdc: e0 06 a0 0c ld [ %i2 + 0xc ], %l0 <== NOT EXECUTED
2005be0: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
2005be4: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2005be8: 40 00 7f 7b call 20259d4 <strerror> <== NOT EXECUTED
2005bec: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
2005bf0: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
2005bf4: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2005bf8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2005bfc: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
2005c00: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
2005c04: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
2005c08: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
2005c0c: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
2005c10: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED
2005c14: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2005c18: 10 bf ff 60 b 2005998 <rtems_fdisk_recycle_segment+0x1a8> <== NOT EXECUTED
2005c1c: 90 12 22 60 or %o0, 0x260, %o0 <== NOT EXECUTED
{
sc->next = queue->head;
queue->head = sc;
if (queue->tail == 0)
queue->tail = sc;
2005c20: 10 bf ff 6a b 20059c8 <rtems_fdisk_recycle_segment+0x1d8> <== NOT EXECUTED
2005c24: f2 26 20 44 st %i1, [ %i0 + 0x44 ] <== NOT EXECUTED
2005c28: 10 bf ff ac b 2005ad8 <rtems_fdisk_recycle_segment+0x2e8> <== NOT EXECUTED
2005c2c: f2 26 20 44 st %i1, [ %i0 + 0x44 ] <== NOT EXECUTED
0200508c <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)
{
200508c: 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;
2005090: e0 06 60 08 ld [ %i1 + 8 ], %l0
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;
2005094: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
2005098: 87 2c 20 04 sll %l0, 4, %g3
uint32_t device;
uint32_t segment;
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
200509c: 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;
20050a0: 83 2c 20 02 sll %l0, 2, %g1
20050a4: 82 20 c0 01 sub %g3, %g1, %g1
20050a8: 86 00 80 01 add %g2, %g1, %g3
20050ac: c2 00 80 01 ld [ %g2 + %g1 ], %g1
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;
20050b0: 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;
20050b4: 85 2f 60 04 sll %i5, 4, %g2
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;
20050b8: e2 00 e0 08 ld [ %g3 + 8 ], %l1
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;
20050bc: 87 2f 60 06 sll %i5, 6, %g3
20050c0: 84 20 c0 02 sub %g3, %g2, %g2
20050c4: 82 00 40 02 add %g1, %g2, %g1
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",
20050c8: 94 10 00 10 mov %l0, %o2
20050cc: 96 10 00 1d mov %i5, %o3
20050d0: 98 10 00 1a mov %i2, %o4
20050d4: 9a 10 00 1c mov %i4, %o5
20050d8: 90 10 00 18 mov %i0, %o0
20050dc: 13 00 80 cd sethi %hi(0x2033400), %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;
20050e0: f0 00 60 04 ld [ %g1 + 4 ], %i0
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",
20050e4: 7f ff ff 85 call 2004ef8 <rtems_fdisk_printf>
20050e8: 92 12 60 90 or %o1, 0x90, %o1
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
20050ec: c2 04 60 04 ld [ %l1 + 4 ], %g1
20050f0: 90 10 00 18 mov %i0, %o0
20050f4: 92 10 00 10 mov %l0, %o1
20050f8: 94 10 00 1d mov %i5, %o2
20050fc: 96 10 00 1a mov %i2, %o3
2005100: 98 10 00 1b mov %i3, %o4
2005104: 9f c0 40 00 call %g1
2005108: 9a 10 00 1c mov %i4, %o5
if (ret)
200510c: b0 92 20 00 orcc %o0, 0, %i0
2005110: 02 80 00 03 be 200511c <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
2005114: 82 10 20 01 mov 1, %g1
sc->failed = true;
2005118: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
200511c: 81 c7 e0 08 ret
2005120: 81 e8 00 00 restore
02005168 <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)
{
2005168: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
200516c: c2 06 20 08 ld [ %i0 + 8 ], %g1
2005170: 80 88 60 08 btst 8, %g1
2005174: 22 80 00 0f be,a 20051b0 <rtems_fdisk_seg_write_page+0x48><== NEVER TAKEN
2005178: c2 06 20 28 ld [ %i0 + 0x28 ], %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);
200517c: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
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,
2005180: 90 10 00 1a mov %i2, %o0
2005184: 7f ff f5 0a call 20025ac <.umul>
2005188: 92 10 00 1d mov %i5, %o1
200518c: 92 10 00 19 mov %i1, %o1
2005190: 94 10 00 08 mov %o0, %o2
2005194: 96 10 00 1d mov %i5, %o3
2005198: 7f ff ff 9c call 2005008 <rtems_fdisk_seg_blank_check>
200519c: 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)
20051a0: 80 a2 20 00 cmp %o0, 0
20051a4: 12 80 00 0b bne 20051d0 <rtems_fdisk_seg_write_page+0x68> <== NEVER TAKEN
20051a8: 01 00 00 00 nop
return ret;
}
--fd->erased_blocks;
20051ac: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
20051b0: 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;
20051b4: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
20051b8: 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;
20051bc: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
return rtems_fdisk_seg_write (fd, sc,
20051c0: 7f ff f4 fb call 20025ac <.umul>
20051c4: 92 10 00 1c mov %i4, %o1
20051c8: 7f ff ff b1 call 200508c <rtems_fdisk_seg_write>
20051cc: 95 e8 00 08 restore %g0, %o0, %o2
page * fd->block_size, buffer, fd->block_size);
}
20051d0: 81 c7 e0 08 ret <== NOT EXECUTED
20051d4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02005124 <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)
{
2005124: 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))
2005128: c2 06 20 08 ld [ %i0 + 8 ], %g1
200512c: 80 88 60 08 btst 8, %g1
2005130: 02 80 00 0a be 2005158 <rtems_fdisk_seg_write_page_desc+0x34><== NEVER TAKEN
2005134: b5 2e a0 03 sll %i2, 3, %i2
{
int ret = rtems_fdisk_seg_blank_check (fd, sc,
2005138: 90 10 00 18 mov %i0, %o0
200513c: 92 10 00 19 mov %i1, %o1
2005140: 94 10 00 1a mov %i2, %o2
2005144: 7f ff ff b1 call 2005008 <rtems_fdisk_seg_blank_check>
2005148: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
200514c: 80 a2 20 00 cmp %o0, 0
2005150: 12 80 00 04 bne 2005160 <rtems_fdisk_seg_write_page_desc+0x3c><== NEVER TAKEN
2005154: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
2005158: 7f ff ff cd call 200508c <rtems_fdisk_seg_write>
200515c: 99 e8 20 08 restore %g0, 8, %o4
page_desc, sizeof (rtems_fdisk_page_desc));
}
2005160: 81 c7 e0 08 ret <== NOT EXECUTED
2005164: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02005458 <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)
2005458: 80 a2 60 00 cmp %o1, 0
200545c: 02 80 00 12 be 20054a4 <rtems_fdisk_segment_queue_insert_before+0x4c><== NEVER TAKEN
2005460: 80 a2 a0 00 cmp %o2, 0
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
2005464: c4 02 00 00 ld [ %o0 ], %g2
while (it)
2005468: 80 a0 a0 00 cmp %g2, 0
200546c: 02 80 00 0d be 20054a0 <rtems_fdisk_segment_queue_insert_before+0x48><== NEVER TAKEN
2005470: 80 a2 40 02 cmp %o1, %g2
{
if (item == it)
2005474: 32 80 00 08 bne,a 2005494 <rtems_fdisk_segment_queue_insert_before+0x3c>
2005478: c2 00 80 00 ld [ %g2 ], %g1
rtems_fdisk_segment_ctl* item,
rtems_fdisk_segment_ctl* sc)
{
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
200547c: 10 80 00 18 b 20054dc <rtems_fdisk_segment_queue_insert_before+0x84>
2005480: 84 10 00 08 mov %o0, %g2
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
{
if (item == it)
2005484: 22 80 00 17 be,a 20054e0 <rtems_fdisk_segment_queue_insert_before+0x88><== ALWAYS TAKEN
2005488: c2 02 20 08 ld [ %o0 + 8 ], %g1
200548c: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED
queue->count++;
return;
}
prev = &it->next;
it = it->next;
2005490: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2005494: 80 a0 60 00 cmp %g1, 0
2005498: 12 bf ff fb bne 2005484 <rtems_fdisk_segment_queue_insert_before+0x2c><== ALWAYS TAKEN
200549c: 80 a2 40 01 cmp %o1, %g1
*/
static void
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
20054a0: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED
20054a4: 02 80 00 0c be 20054d4 <rtems_fdisk_segment_queue_insert_before+0x7c><== NOT EXECUTED
20054a8: 01 00 00 00 nop <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
20054ac: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
20054b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20054b4: 02 80 00 10 be 20054f4 <rtems_fdisk_segment_queue_insert_before+0x9c><== NOT EXECUTED
20054b8: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
{
queue->tail->next = sc;
20054bc: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
20054c0: d4 20 40 00 st %o2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
20054c4: d4 22 20 04 st %o2, [ %o0 + 4 ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
20054c8: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
20054cc: 82 00 60 01 inc %g1 <== NOT EXECUTED
20054d0: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED
20054d4: 81 c3 e0 08 retl <== NOT EXECUTED
20054d8: 01 00 00 00 nop <== NOT EXECUTED
{
if (item == it)
{
sc->next = item;
*prev = sc;
queue->count++;
20054dc: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
20054e0: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
20054e4: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
20054e8: 82 00 60 01 inc %g1
return;
20054ec: 81 c3 e0 08 retl
20054f0: c2 22 20 08 st %g1, [ %o0 + 8 ]
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
20054f4: d4 22 20 04 st %o2, [ %o0 + 4 ] <== NOT EXECUTED
20054f8: 10 bf ff f4 b 20054c8 <rtems_fdisk_segment_queue_insert_before+0x70><== NOT EXECUTED
20054fc: d4 22 00 00 st %o2, [ %o0 ] <== NOT EXECUTED
02004c74 <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;
2004c74: c4 02 00 00 ld [ %o0 ], %g2
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004c78: 80 a0 a0 00 cmp %g2, 0
2004c7c: 02 80 00 0d be 2004cb0 <rtems_fdisk_segment_queue_remove+0x3c>
2004c80: 80 a0 80 09 cmp %g2, %o1
{
if (sc == it)
2004c84: 32 80 00 08 bne,a 2004ca4 <rtems_fdisk_segment_queue_remove+0x30>
2004c88: c2 00 80 00 ld [ %g2 ], %g1
{
if (prev == 0)
{
queue->head = sc->next;
2004c8c: 10 80 00 16 b 2004ce4 <rtems_fdisk_segment_queue_remove+0x70>
2004c90: c2 02 40 00 ld [ %o1 ], %g1
* Do not change sc->next as sc could be on another queue.
*/
while (it)
{
if (sc == it)
2004c94: 22 80 00 09 be,a 2004cb8 <rtems_fdisk_segment_queue_remove+0x44>
2004c98: c6 02 40 00 ld [ %o1 ], %g3
2004c9c: 84 10 00 01 mov %g1, %g2
queue->count--;
break;
}
prev = it;
it = it->next;
2004ca0: c2 00 80 00 ld [ %g2 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004ca4: 80 a0 60 00 cmp %g1, 0
2004ca8: 12 bf ff fb bne 2004c94 <rtems_fdisk_segment_queue_remove+0x20>
2004cac: 80 a2 40 01 cmp %o1, %g1
2004cb0: 81 c3 e0 08 retl
2004cb4: 01 00 00 00 nop
queue->tail = 0;
}
else
{
prev->next = sc->next;
if (queue->tail == sc)
2004cb8: c2 02 20 04 ld [ %o0 + 4 ], %g1
2004cbc: 80 a0 40 09 cmp %g1, %o1
2004cc0: 02 80 00 07 be 2004cdc <rtems_fdisk_segment_queue_remove+0x68><== ALWAYS TAKEN
2004cc4: c6 20 80 00 st %g3, [ %g2 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
2004cc8: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
2004ccc: c0 22 40 00 clr [ %o1 ]
queue->count--;
2004cd0: 82 00 7f ff add %g1, -1, %g1
break;
2004cd4: 81 c3 e0 08 retl
2004cd8: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
else
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
2004cdc: 10 bf ff fb b 2004cc8 <rtems_fdisk_segment_queue_remove+0x54>
2004ce0: c4 22 20 04 st %g2, [ %o0 + 4 ]
if (sc == it)
{
if (prev == 0)
{
queue->head = sc->next;
if (queue->head == 0)
2004ce4: 80 a0 60 00 cmp %g1, 0
2004ce8: 12 bf ff f8 bne 2004cc8 <rtems_fdisk_segment_queue_remove+0x54>
2004cec: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
2004cf0: 10 bf ff f6 b 2004cc8 <rtems_fdisk_segment_queue_remove+0x54>
2004cf4: c0 22 20 04 clr [ %o0 + 4 ]
020051d8 <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, ...)
{
20051d8: 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);
20051dc: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
20051e0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
20051e4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
20051e8: 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)
20051ec: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
20051f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20051f4: 02 80 00 19 be 2005258 <rtems_fdisk_warning+0x80> <== NOT EXECUTED
20051f8: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
20051fc: 3b 00 80 e1 sethi %hi(0x2038400), %i5 <== NOT EXECUTED
2005200: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 ! 2038730 <_impure_ptr><== NOT EXECUTED
2005204: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2005208: d6 00 60 08 ld [ %g1 + 8 ], %o3 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
200520c: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
2005210: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
2005214: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
2005218: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
200521c: 40 00 7c 0f call 2024258 <fwrite> <== NOT EXECUTED
2005220: 90 12 20 b8 or %o0, 0xb8, %o0 ! 20334b8 <__FUNCTION__.7127+0x520><== NOT EXECUTED
ret = vfprintf (stdout, format, args);
2005224: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
2005228: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
200522c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2005230: 40 00 9c c1 call 202c534 <vfprintf> <== NOT EXECUTED
2005234: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2005238: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
200523c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
2005240: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2005244: 40 00 7a 24 call 2023ad4 <fputc> <== NOT EXECUTED
2005248: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
200524c: c2 07 63 30 ld [ %i5 + 0x330 ], %g1 <== NOT EXECUTED
2005250: 40 00 79 09 call 2023674 <fflush> <== NOT EXECUTED
2005254: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2005258: 81 c7 e0 08 ret <== NOT EXECUTED
200525c: 81 e8 00 00 restore <== NOT EXECUTED
0200cc64 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
200cc64: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
200cc68: 7f ff fe fa call 200c850 <geteuid>
200cc6c: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
200cc70: 91 2a 20 10 sll %o0, 0x10, %o0
200cc74: 91 32 20 10 srl %o0, 0x10, %o0
200cc78: 80 a2 00 1a cmp %o0, %i2
200cc7c: 12 80 00 08 bne 200cc9c <rtems_filesystem_check_access+0x38>
200cc80: 80 a2 20 00 cmp %o0, 0
perm_flags <<= RTEMS_FS_USR_SHIFT;
200cc84: b1 2e 20 06 sll %i0, 6, %i0
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
200cc88: b0 2e 00 19 andn %i0, %i1, %i0
}
200cc8c: 80 a0 00 18 cmp %g0, %i0
200cc90: b0 60 3f ff subx %g0, -1, %i0
200cc94: 81 c7 e0 08 ret
200cc98: 81 e8 00 00 restore
)
{
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
if (task_uid == 0 || task_uid == node_uid) {
200cc9c: 22 bf ff fb be,a 200cc88 <rtems_filesystem_check_access+0x24>
200cca0: b1 2e 20 06 sll %i0, 6, %i0
perm_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = getegid();
200cca4: 7f ff fe e7 call 200c840 <getegid>
200cca8: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
200ccac: 91 2a 20 10 sll %o0, 0x10, %o0
200ccb0: 91 32 20 10 srl %o0, 0x10, %o0
200ccb4: 80 a2 00 1b cmp %o0, %i3
200ccb8: 12 80 00 08 bne 200ccd8 <rtems_filesystem_check_access+0x74>
200ccbc: 80 a2 20 00 cmp %o0, 0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
200ccc0: b1 2e 20 03 sll %i0, 3, %i0
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
200ccc4: b0 2e 00 19 andn %i0, %i1, %i0
}
200ccc8: 80 a0 00 18 cmp %g0, %i0
200cccc: b0 60 3f ff subx %g0, -1, %i0
200ccd0: 81 c7 e0 08 ret
200ccd4: 81 e8 00 00 restore
if (task_uid == 0 || task_uid == node_uid) {
perm_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = getegid();
if (task_gid == 0 || task_gid == node_gid) {
200ccd8: 32 bf ff ed bne,a 200cc8c <rtems_filesystem_check_access+0x28><== ALWAYS TAKEN
200ccdc: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
200cce0: 10 bf ff f9 b 200ccc4 <rtems_filesystem_check_access+0x60><== NOT EXECUTED
200cce4: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
02004ce4 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
2004ce4: 9d e3 bf a0 save %sp, -96, %sp
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2004ce8: 3b 00 80 78 sethi %hi(0x201e000), %i5
2004cec: d0 07 61 9c ld [ %i5 + 0x19c ], %o0 ! 201e19c <rtems_libio_semaphore>
2004cf0: 92 10 20 00 clr %o1
2004cf4: 40 00 0b 9b call 2007b60 <rtems_semaphore_obtain>
2004cf8: 94 10 20 00 clr %o2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2004cfc: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
2004d00: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2004d04: d0 07 61 9c ld [ %i5 + 0x19c ], %o0
next->previous = previous;
2004d08: c2 20 a0 04 st %g1, [ %g2 + 4 ]
2004d0c: 40 00 0b e4 call 2007c9c <rtems_semaphore_release>
2004d10: c4 20 40 00 st %g2, [ %g1 ]
rtems_filesystem_mt_lock();
rtems_chain_extract_unprotected(&mt_entry->mt_node);
rtems_filesystem_mt_unlock();
rtems_filesystem_global_location_release(mt_entry->mt_point_node);
2004d14: 40 00 00 6d call 2004ec8 <rtems_filesystem_global_location_release>
2004d18: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
2004d1c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2004d20: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
2004d24: 9f c0 40 00 call %g1
2004d28: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
2004d2c: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
2004d30: 80 a2 20 00 cmp %o0, 0
2004d34: 02 80 00 07 be 2004d50 <rtems_filesystem_do_unmount+0x6c> <== NEVER TAKEN
2004d38: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
2004d3c: 40 00 0c 03 call 2007d48 <rtems_event_system_send>
2004d40: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
2004d44: 80 a2 20 00 cmp %o0, 0
2004d48: 32 80 00 04 bne,a 2004d58 <rtems_filesystem_do_unmount+0x74><== NEVER TAKEN
2004d4c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
2004d50: 7f ff fa 48 call 2003670 <free>
2004d54: 81 e8 00 00 restore
if (mt_entry->unmount_task != 0) {
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
2004d58: 40 00 0d 67 call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004d5c: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
0200cf14 <rtems_filesystem_eval_path_eat_delimiter>:
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
const char *current = ctx->path;
200cf14: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
200cf18: c6 02 20 04 ld [ %o0 + 4 ], %g3
200cf1c: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
200cf20: 80 a0 40 03 cmp %g1, %g3
200cf24: 32 80 00 08 bne,a 200cf44 <rtems_filesystem_eval_path_eat_delimiter+0x30><== ALWAYS TAKEN
200cf28: c4 48 40 00 ldsb [ %g1 ], %g2
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
200cf2c: 10 80 00 0d b 200cf60 <rtems_filesystem_eval_path_eat_delimiter+0x4c><== NOT EXECUTED
200cf30: 86 20 c0 01 sub %g3, %g1, %g3 <== NOT EXECUTED
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
200cf34: 80 a0 c0 01 cmp %g3, %g1
200cf38: 22 80 00 0a be,a 200cf60 <rtems_filesystem_eval_path_eat_delimiter+0x4c>
200cf3c: 86 20 c0 01 sub %g3, %g1, %g3
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
200cf40: c4 48 40 00 ldsb [ %g1 ], %g2
200cf44: 80 a0 a0 5c cmp %g2, 0x5c
200cf48: 22 bf ff fb be,a 200cf34 <rtems_filesystem_eval_path_eat_delimiter+0x20>
200cf4c: 82 00 60 01 inc %g1
200cf50: 80 a0 a0 2f cmp %g2, 0x2f
200cf54: 22 bf ff f8 be,a 200cf34 <rtems_filesystem_eval_path_eat_delimiter+0x20>
200cf58: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
200cf5c: 86 20 c0 01 sub %g3, %g1, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
200cf60: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
200cf64: 81 c3 e0 08 retl
200cf68: c6 22 20 04 st %g3, [ %o0 + 4 ]
0200cd1c <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
)
{
200cd1c: 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);
200cd20: 03 00 80 71 sethi %hi(0x201c400), %g1
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 =
200cd24: b6 06 20 18 add %i0, 0x18, %i3
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200cd28: a2 10 61 78 or %g1, 0x178, %l1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200cd2c: 03 00 80 70 sethi %hi(0x201c000), %g1
200cd30: a0 10 60 e0 or %g1, 0xe0, %l0 ! 201c0e0 <rtems_filesystem_default_pathconf+0x4c>
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
200cd34: 40 00 00 8e call 200cf6c <rtems_filesystem_eval_path_next_token>
200cd38: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
200cd3c: fa 06 20 0c ld [ %i0 + 0xc ], %i5
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
200cd40: 80 a7 60 00 cmp %i5, 0
200cd44: 02 80 00 18 be 200cda4 <rtems_filesystem_eval_path_generic+0x88>
200cd48: f8 06 20 08 ld [ %i0 + 8 ], %i4
if ((*config->is_directory)(ctx, arg)) {
200cd4c: c2 06 80 00 ld [ %i2 ], %g1
200cd50: 90 10 00 18 mov %i0, %o0
200cd54: 9f c0 40 00 call %g1
200cd58: 92 10 00 19 mov %i1, %o1
200cd5c: 80 8a 20 ff btst 0xff, %o0
200cd60: 02 80 00 13 be 200cdac <rtems_filesystem_eval_path_generic+0x90>
200cd64: 80 a7 60 01 cmp %i5, 1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200cd68: 02 80 00 23 be 200cdf4 <rtems_filesystem_eval_path_generic+0xd8>
200cd6c: 80 a7 60 02 cmp %i5, 2
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200cd70: 22 80 00 2f be,a 200ce2c <rtems_filesystem_eval_path_generic+0x110>
200cd74: c2 4f 00 00 ldsb [ %i4 ], %g1
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
200cd78: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200cd7c: 90 10 00 18 mov %i0, %o0
200cd80: 92 10 00 19 mov %i1, %o1
200cd84: 94 10 00 1c mov %i4, %o2
200cd88: 9f c0 40 00 call %g1
200cd8c: 96 10 00 1d mov %i5, %o3
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
200cd90: 80 a2 20 02 cmp %o0, 2
200cd94: 02 80 00 08 be 200cdb4 <rtems_filesystem_eval_path_generic+0x98>
200cd98: 80 a2 20 00 cmp %o0, 0
)
{
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
200cd9c: 02 bf ff e6 be 200cd34 <rtems_filesystem_eval_path_generic+0x18>
200cda0: 01 00 00 00 nop
200cda4: 81 c7 e0 08 ret
200cda8: 81 e8 00 00 restore
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
200cdac: 7f ff de 5d call 2004720 <rtems_filesystem_eval_path_error>
200cdb0: 93 e8 20 14 restore %g0, 0x14, %o1
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
if (rtems_filesystem_eval_path_has_path(ctx)) {
200cdb4: c2 06 20 04 ld [ %i0 + 4 ], %g1
200cdb8: 80 a0 60 00 cmp %g1, 0
200cdbc: 02 bf ff fa be 200cda4 <rtems_filesystem_eval_path_generic+0x88>
200cdc0: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
200cdc4: 40 00 00 54 call 200cf14 <rtems_filesystem_eval_path_eat_delimiter>
200cdc8: 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
200cdcc: 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 (
200cdd0: 80 88 60 80 btst 0x80, %g1
200cdd4: 02 80 00 06 be 200cdec <rtems_filesystem_eval_path_generic+0xd0>
200cdd8: 01 00 00 00 nop
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
200cddc: c2 06 20 04 ld [ %i0 + 4 ], %g1
200cde0: 80 a0 60 00 cmp %g1, 0
200cde4: 02 bf ff f0 be 200cda4 <rtems_filesystem_eval_path_generic+0x88>
200cde8: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200cdec: 7f ff de 4d call 2004720 <rtems_filesystem_eval_path_error>
200cdf0: 93 e8 20 02 restore %g0, 2, %o1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200cdf4: c2 4f 00 00 ldsb [ %i4 ], %g1
200cdf8: 80 a0 60 2e cmp %g1, 0x2e
200cdfc: 32 bf ff e0 bne,a 200cd7c <rtems_filesystem_eval_path_generic+0x60>
200ce00: c2 06 a0 04 ld [ %i2 + 4 ], %g1
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
if ((*config->is_directory)(ctx, arg)) {
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
if (rtems_filesystem_eval_path_has_path(ctx)) {
200ce04: c2 06 20 04 ld [ %i0 + 4 ], %g1
200ce08: 80 a0 60 00 cmp %g1, 0
200ce0c: 32 80 00 2c bne,a 200cebc <rtems_filesystem_eval_path_generic+0x1a0>
200ce10: 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) {
200ce14: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
200ce18: 80 88 a1 00 btst 0x100, %g2
200ce1c: 22 80 00 28 be,a 200cebc <rtems_filesystem_eval_path_generic+0x1a0>
200ce20: c2 06 a0 04 ld [ %i2 + 4 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
200ce24: 7f ff de 3f call 2004720 <rtems_filesystem_eval_path_error>
200ce28: 93 e8 20 16 restore %g0, 0x16, %o1
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200ce2c: 80 a0 60 2e cmp %g1, 0x2e
200ce30: 32 bf ff d3 bne,a 200cd7c <rtems_filesystem_eval_path_generic+0x60>
200ce34: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200ce38: c2 4f 20 01 ldsb [ %i4 + 1 ], %g1
200ce3c: 80 a0 60 2e cmp %g1, 0x2e
200ce40: 32 bf ff cf bne,a 200cd7c <rtems_filesystem_eval_path_generic+0x60><== NEVER TAKEN
200ce44: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
200ce48: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
static bool is_eval_path_root(
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
200ce4c: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
200ce50: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
200ce54: 80 a0 80 01 cmp %g2, %g1
200ce58: 22 80 00 27 be,a 200cef4 <rtems_filesystem_eval_path_generic+0x1d8>
200ce5c: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *mt_fs_root =
&mt_entry->mt_fs_root->location;
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
200ce60: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
200ce64: d2 00 a0 24 ld [ %g2 + 0x24 ], %o1
200ce68: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200ce6c: 9f c0 40 00 call %g1
200ce70: 90 10 00 1b mov %i3, %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)) {
200ce74: 80 8a 20 ff btst 0xff, %o0
200ce78: 22 80 00 18 be,a 200ced8 <rtems_filesystem_eval_path_generic+0x1bc>
200ce7c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
200ce80: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
200ce84: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
200ce88: 80 a0 a0 00 cmp %g2, 0
200ce8c: 22 80 00 0c be,a 200cebc <rtems_filesystem_eval_path_generic+0x1a0><== NEVER TAKEN
200ce90: 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;
200ce94: c4 06 20 0c ld [ %i0 + 0xc ], %g2
ctx->path -= tokenlen;
200ce98: c6 06 00 00 ld [ %i0 ], %g3
ctx->pathlen += tokenlen;
200ce9c: c8 06 20 04 ld [ %i0 + 4 ], %g4
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
200cea0: 86 20 c0 02 sub %g3, %g2, %g3
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
200cea4: c0 26 20 0c clr [ %i0 + 0xc ]
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
ctx->pathlen += tokenlen;
200cea8: 84 01 00 02 add %g4, %g2, %g2
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
200ceac: c6 26 00 00 st %g3, [ %i0 ]
ctx->pathlen += tokenlen;
200ceb0: c4 26 20 04 st %g2, [ %i0 + 4 ]
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
200ceb4: 7f ff df 2a call 2004b5c <rtems_filesystem_eval_path_restart>
200ceb8: 93 e8 60 20 restore %g1, 0x20, %o1
rtems_filesystem_location_info_t *currentloc =
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);
200cebc: 90 10 00 18 mov %i0, %o0
200cec0: 92 10 00 19 mov %i1, %o1
200cec4: 94 10 00 10 mov %l0, %o2
200cec8: 9f c0 40 00 call %g1
200cecc: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
200ced0: 10 bf ff b1 b 200cd94 <rtems_filesystem_eval_path_generic+0x78>
200ced4: 80 a2 20 02 cmp %o0, 2
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200ced8: 90 10 00 18 mov %i0, %o0
200cedc: 92 10 00 19 mov %i1, %o1
200cee0: 94 10 00 11 mov %l1, %o2
200cee4: 9f c0 40 00 call %g1
200cee8: 96 10 20 02 mov 2, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
200ceec: 10 bf ff aa b 200cd94 <rtems_filesystem_eval_path_generic+0x78>
200cef0: 80 a2 20 02 cmp %o0, 2
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
200cef4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200cef8: 9f c0 40 00 call %g1
200cefc: 90 10 00 1b mov %i3, %o0
200cf00: 80 8a 20 ff btst 0xff, %o0
200cf04: 32 bf ff ee bne,a 200cebc <rtems_filesystem_eval_path_generic+0x1a0>
200cf08: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200cf0c: 10 bf ff d5 b 200ce60 <rtems_filesystem_eval_path_generic+0x144>
200cf10: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
0200cf6c <rtems_filesystem_eval_path_next_token>:
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
const char *current = ctx->path;
200cf6c: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
200cf70: c8 02 20 04 ld [ %o0 + 4 ], %g4
200cf74: 88 00 40 04 add %g1, %g4, %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
200cf78: 80 a0 40 04 cmp %g1, %g4
200cf7c: 22 80 00 10 be,a 200cfbc <rtems_filesystem_eval_path_next_token+0x50>
200cf80: 88 21 00 01 sub %g4, %g1, %g4
200cf84: c4 48 40 00 ldsb [ %g1 ], %g2
200cf88: 80 a0 a0 2f cmp %g2, 0x2f
200cf8c: 22 80 00 08 be,a 200cfac <rtems_filesystem_eval_path_next_token+0x40>
200cf90: 82 00 60 01 inc %g1
200cf94: 10 80 00 38 b 200d074 <rtems_filesystem_eval_path_next_token+0x108>
200cf98: 80 a0 a0 5c cmp %g2, 0x5c
200cf9c: 80 a0 a0 5c cmp %g2, 0x5c
200cfa0: 12 80 00 26 bne 200d038 <rtems_filesystem_eval_path_next_token+0xcc>
200cfa4: 80 a0 a0 2f cmp %g2, 0x2f
++current;
200cfa8: 82 00 60 01 inc %g1
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
200cfac: 80 a1 00 01 cmp %g4, %g1
200cfb0: 32 bf ff fb bne,a 200cf9c <rtems_filesystem_eval_path_next_token+0x30>
200cfb4: c4 48 40 00 ldsb [ %g1 ], %g2
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
200cfb8: 88 21 00 01 sub %g4, %g1, %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
200cfbc: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
200cfc0: c8 22 20 04 st %g4, [ %o0 + 4 ]
}
static void next_token(rtems_filesystem_eval_path_context_t *ctx)
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
200cfc4: 88 00 40 04 add %g1, %g4, %g4
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
200cfc8: 80 a1 00 01 cmp %g4, %g1
200cfcc: 02 80 00 27 be 200d068 <rtems_filesystem_eval_path_next_token+0xfc>
200cfd0: 9a 10 00 01 mov %g1, %o5
200cfd4: c4 48 40 00 ldsb [ %g1 ], %g2
200cfd8: 80 a0 a0 5c cmp %g2, 0x5c
200cfdc: 02 80 00 23 be 200d068 <rtems_filesystem_eval_path_next_token+0xfc><== NEVER TAKEN
200cfe0: 80 a0 a0 2f cmp %g2, 0x2f
200cfe4: 02 80 00 22 be 200d06c <rtems_filesystem_eval_path_next_token+0x100><== NEVER TAKEN
200cfe8: 84 10 00 01 mov %g1, %g2
++current;
200cfec: 10 80 00 08 b 200d00c <rtems_filesystem_eval_path_next_token+0xa0>
200cff0: 84 00 a0 01 inc %g2
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
200cff4: 80 a0 e0 5c cmp %g3, 0x5c
200cff8: 02 80 00 14 be 200d048 <rtems_filesystem_eval_path_next_token+0xdc>
200cffc: 80 a0 e0 2f cmp %g3, 0x2f
200d000: 02 80 00 13 be 200d04c <rtems_filesystem_eval_path_next_token+0xe0>
200d004: 9a 10 00 02 mov %g2, %o5
++current;
200d008: 84 00 a0 01 inc %g2
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
200d00c: 80 a1 00 02 cmp %g4, %g2
200d010: 32 bf ff f9 bne,a 200cff4 <rtems_filesystem_eval_path_next_token+0x88>
200d014: c6 48 80 00 ldsb [ %g2 ], %g3
200d018: 9a 10 00 04 mov %g4, %o5
200d01c: 86 21 00 01 sub %g4, %g1, %g3
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
200d020: 88 21 00 0d sub %g4, %o5, %g4
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
200d024: c4 22 00 00 st %g2, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
200d028: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
200d02c: c2 22 20 08 st %g1, [ %o0 + 8 ]
ctx->tokenlen = (size_t) (current - begin);
200d030: 81 c3 e0 08 retl
200d034: c6 22 20 0c st %g3, [ %o0 + 0xc ]
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
200d038: 22 bf ff dd be,a 200cfac <rtems_filesystem_eval_path_next_token+0x40>
200d03c: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
200d040: 10 bf ff df b 200cfbc <rtems_filesystem_eval_path_next_token+0x50>
200d044: 88 21 00 01 sub %g4, %g1, %g4
200d048: 9a 10 00 02 mov %g2, %o5
200d04c: 86 20 80 01 sub %g2, %g1, %g3
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
200d050: 88 21 00 0d sub %g4, %o5, %g4
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
200d054: c4 22 00 00 st %g2, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
200d058: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
200d05c: c2 22 20 08 st %g1, [ %o0 + 8 ]
ctx->tokenlen = (size_t) (current - begin);
200d060: 81 c3 e0 08 retl
200d064: c6 22 20 0c st %g3, [ %o0 + 0xc ]
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
200d068: 84 10 00 01 mov %g1, %g2
200d06c: 10 bf ff ed b 200d020 <rtems_filesystem_eval_path_next_token+0xb4>
200d070: 86 10 20 00 clr %g3
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
200d074: 22 bf ff ce be,a 200cfac <rtems_filesystem_eval_path_next_token+0x40>
200d078: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
200d07c: 10 bf ff d0 b 200cfbc <rtems_filesystem_eval_path_next_token+0x50>
200d080: 88 21 00 01 sub %g4, %g1, %g4
02004bc0 <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
2004bc0: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
2004bc4: 80 a6 a0 00 cmp %i2, 0
2004bc8: 02 80 00 22 be 2004c50 <rtems_filesystem_eval_path_recursive+0x90><== NEVER TAKEN
2004bcc: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
2004bd0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2004bd4: 80 a0 60 1f cmp %g1, 0x1f
2004bd8: 14 80 00 25 bg 2004c6c <rtems_filesystem_eval_path_recursive+0xac>
2004bdc: 01 00 00 00 nop
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
2004be0: c4 4e 40 00 ldsb [ %i1 ], %g2
const char *saved_path = ctx->path;
2004be4: f6 06 00 00 ld [ %i0 ], %i3
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
2004be8: 80 a0 a0 5c cmp %g2, 0x5c
2004bec: 02 80 00 1b be 2004c58 <rtems_filesystem_eval_path_recursive+0x98><== NEVER TAKEN
2004bf0: f8 06 20 04 ld [ %i0 + 4 ], %i4
2004bf4: 80 a0 a0 2f cmp %g2, 0x2f
2004bf8: 02 80 00 19 be 2004c5c <rtems_filesystem_eval_path_recursive+0x9c>
2004bfc: 90 10 00 1d mov %i5, %o0
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
2004c00: 82 00 60 01 inc %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
2004c04: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
2004c08: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
2004c0c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
2004c10: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2004c14: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2004c18: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004c1c: 9f c0 40 00 call %g1
2004c20: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
2004c24: c2 07 60 04 ld [ %i5 + 4 ], %g1
2004c28: 80 a0 60 00 cmp %g1, 0
2004c2c: 32 bf ff fa bne,a 2004c14 <rtems_filesystem_eval_path_recursive+0x54>
2004c30: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004c34: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
2004c38: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004c3c: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
2004c40: f8 27 60 04 st %i4, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004c44: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
2004c48: 81 c7 e0 08 ret
2004c4c: 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);
2004c50: 7f ff fe b4 call 2004720 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2004c54: 93 e8 20 02 restore %g0, 2, %o1 <== NOT EXECUTED
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
const char *saved_path = ctx->path;
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
2004c58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2004c5c: 7f ff ff c0 call 2004b5c <rtems_filesystem_eval_path_restart>
2004c60: 92 07 60 30 add %i5, 0x30, %o1
2004c64: 10 bf ff e7 b 2004c00 <rtems_filesystem_eval_path_recursive+0x40>
2004c68: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
--ctx->recursionlevel;
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
2004c6c: 7f ff fe ad call 2004720 <rtems_filesystem_eval_path_error>
2004c70: 93 e8 20 5c restore %g0, 0x5c, %o1
02004a28 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
2004a28: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
2004a2c: 40 00 33 d0 call 201196c <strlen>
2004a30: 90 10 00 19 mov %i1, %o0
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
2004a34: 80 a2 20 00 cmp %o0, 0
2004a38: 02 80 00 32 be 2004b00 <rtems_filesystem_eval_path_start_with_parent+0xd8>
2004a3c: 92 10 00 19 mov %i1, %o1
size_t i = pathlen - 1;
2004a40: 94 02 3f ff add %o0, -1, %o2
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
2004a44: c2 4e 40 0a ldsb [ %i1 + %o2 ], %g1
if (rtems_filesystem_is_delimiter(path [i])) {
2004a48: 80 a0 60 5c cmp %g1, 0x5c
2004a4c: 02 80 00 2a be 2004af4 <rtems_filesystem_eval_path_start_with_parent+0xcc><== NEVER TAKEN
2004a50: 80 a0 60 2f cmp %g1, 0x2f
2004a54: 12 80 00 08 bne 2004a74 <rtems_filesystem_eval_path_start_with_parent+0x4c>
2004a58: 80 a2 a0 00 cmp %o2, 0
2004a5c: 10 80 00 27 b 2004af8 <rtems_filesystem_eval_path_start_with_parent+0xd0>
2004a60: 94 10 00 08 mov %o0, %o2
2004a64: 02 80 00 0b be 2004a90 <rtems_filesystem_eval_path_start_with_parent+0x68>
2004a68: a0 22 00 0a sub %o0, %o2, %l0
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
2004a6c: 94 10 00 01 mov %g1, %o2
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
2004a70: 80 a2 a0 00 cmp %o2, 0
2004a74: 02 80 00 1a be 2004adc <rtems_filesystem_eval_path_start_with_parent+0xb4>
2004a78: 82 02 bf ff add %o2, -1, %g1
2004a7c: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
2004a80: 80 a0 a0 5c cmp %g2, 0x5c
2004a84: 12 bf ff f8 bne 2004a64 <rtems_filesystem_eval_path_start_with_parent+0x3c><== ALWAYS TAKEN
2004a88: 80 a0 a0 2f cmp %g2, 0x2f
2004a8c: a0 22 00 0a sub %o0, %o2, %l0 <== NOT EXECUTED
parentpath = ".";
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
2004a90: ba 06 40 0a add %i1, %o2, %i5
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
2004a94: 92 10 00 19 mov %i1, %o1
currentloc = eval_path_start(
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
2004a98: 03 00 80 76 sethi %hi(0x201d800), %g1
2004a9c: da 00 60 38 ld [ %g1 + 0x38 ], %o5 ! 201d838 <rtems_current_user_env>
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
2004aa0: 96 10 00 1c mov %i4, %o3
2004aa4: 98 03 60 04 add %o5, 4, %o4
2004aa8: 7f ff ff 7a call 2004890 <eval_path_start>
2004aac: 90 10 00 18 mov %i0, %o0
2004ab0: 92 10 00 08 mov %o0, %o1
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
2004ab4: 40 00 1f 1a call 200c71c <rtems_filesystem_location_clone>
2004ab8: 90 10 00 1b mov %i3, %o0
ctx->path = name;
ctx->pathlen = namelen;
ctx->flags = eval_flags;
rtems_filesystem_eval_path_continue(ctx);
2004abc: 90 10 00 18 mov %i0, %o0
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
ctx->path = name;
2004ac0: fa 26 00 00 st %i5, [ %i0 ]
ctx->pathlen = namelen;
2004ac4: e0 26 20 04 st %l0, [ %i0 + 4 ]
ctx->flags = eval_flags;
2004ac8: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
rtems_filesystem_eval_path_continue(ctx);
2004acc: 7f ff ff 54 call 200481c <rtems_filesystem_eval_path_continue>
2004ad0: b0 06 20 18 add %i0, 0x18, %i0
2004ad4: 81 c7 e0 08 ret
2004ad8: 81 e8 00 00 restore
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
2004adc: 13 00 80 70 sethi %hi(0x201c000), %o1
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
2004ae0: a0 10 00 08 mov %o0, %l0
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
name = path;
2004ae4: ba 10 00 19 mov %i1, %i5
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
2004ae8: 94 10 20 01 mov 1, %o2
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
2004aec: 10 bf ff eb b 2004a98 <rtems_filesystem_eval_path_start_with_parent+0x70>
2004af0: 92 12 60 e0 or %o1, 0xe0, %o1
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
2004af4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2004af8: 10 bf ff e6 b 2004a90 <rtems_filesystem_eval_path_start_with_parent+0x68>
2004afc: a0 10 20 00 clr %l0
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
2004b00: a0 10 20 00 clr %l0
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
2004b04: ba 10 20 00 clr %i5
}
pathlen = i;
}
return 0;
2004b08: 10 bf ff e4 b 2004a98 <rtems_filesystem_eval_path_start_with_parent+0x70>
2004b0c: 94 10 20 00 clr %o2
0200ca80 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
200ca80: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
200ca84: f0 27 bf f8 st %i0, [ %fp + -8 ]
200ca88: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
200ca8c: 82 10 00 18 mov %i0, %g1
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
200ca90: 80 a0 60 00 cmp %g1, 0
200ca94: 02 80 00 07 be 200cab0 <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
200ca98: b0 10 20 00 clr %i0
rtems_filesystem_iterate( find_handler, &fa );
200ca9c: 92 07 bf f8 add %fp, -8, %o1
200caa0: 11 00 80 32 sethi %hi(0x200c800), %o0
200caa4: 7f ff ff c9 call 200c9c8 <rtems_filesystem_iterate>
200caa8: 90 12 21 94 or %o0, 0x194, %o0 ! 200c994 <find_handler>
200caac: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
200cab0: 81 c7 e0 08 ret
200cab4: 81 e8 00 00 restore
02004f48 <rtems_filesystem_global_location_obtain>:
}
rtems_filesystem_global_location_t *rtems_filesystem_global_location_obtain(
rtems_filesystem_global_location_t *const *global_loc_ptr
)
{
2004f48: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
rtems_filesystem_global_location_t *global_loc;
if (deferred_released_global_locations != NULL) {
2004f4c: 37 00 80 77 sethi %hi(0x201dc00), %i3
2004f50: c2 06 e3 10 ld [ %i3 + 0x310 ], %g1 ! 201df10 <deferred_released_global_locations>
2004f54: 80 a0 60 00 cmp %g1, 0
2004f58: 02 80 00 1e be 2004fd0 <rtems_filesystem_global_location_obtain+0x88>
2004f5c: 01 00 00 00 nop
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2004f60: 39 00 80 78 sethi %hi(0x201e000), %i4
2004f64: c2 07 23 20 ld [ %i4 + 0x320 ], %g1 ! 201e320 <_Thread_Dispatch_disable_level>
++level;
2004f68: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
2004f6c: c2 27 23 20 st %g1, [ %i4 + 0x320 ]
do {
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
2004f70: fa 06 e3 10 ld [ %i3 + 0x310 ], %i5
if (current != NULL) {
2004f74: 80 a7 60 00 cmp %i5, 0
2004f78: 02 80 00 14 be 2004fc8 <rtems_filesystem_global_location_obtain+0x80><== NEVER TAKEN
2004f7c: 01 00 00 00 nop
2004f80: b6 16 e3 10 or %i3, 0x310, %i3
2004f84: b8 17 23 20 or %i4, 0x320, %i4
deferred_released_global_locations = current->deferred_released_next;
2004f88: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
count = current->deferred_released_count;
2004f8c: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
if (current != NULL) {
deferred_released_global_locations = current->deferred_released_next;
2004f90: c2 26 c0 00 st %g1, [ %i3 ]
count = current->deferred_released_count;
current->deferred_released_next = NULL;
2004f94: c0 27 60 1c clr [ %i5 + 0x1c ]
current->deferred_released_count = 0;
}
_Thread_Enable_dispatch();
2004f98: 40 00 15 f8 call 200a778 <_Thread_Enable_dispatch>
2004f9c: c0 27 60 20 clr [ %i5 + 0x20 ]
if (current != NULL) {
release_with_count(current, count);
2004fa0: 90 10 00 1d mov %i5, %o0
2004fa4: 7f ff ff 9e call 2004e1c <release_with_count>
2004fa8: 92 10 00 1a mov %i2, %o1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2004fac: c2 07 00 00 ld [ %i4 ], %g1
++level;
2004fb0: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
2004fb4: c2 27 00 00 st %g1, [ %i4 ]
do {
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
2004fb8: fa 06 c0 00 ld [ %i3 ], %i5
if (current != NULL) {
2004fbc: 80 a7 60 00 cmp %i5, 0
2004fc0: 32 bf ff f3 bne,a 2004f8c <rtems_filesystem_global_location_obtain+0x44><== NEVER TAKEN
2004fc4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
count = current->deferred_released_count;
current->deferred_released_next = NULL;
current->deferred_released_count = 0;
}
_Thread_Enable_dispatch();
2004fc8: 40 00 15 ec call 200a778 <_Thread_Enable_dispatch>
2004fcc: 01 00 00 00 nop
if (deferred_released_global_locations != NULL) {
deferred_release();
}
rtems_filesystem_mt_entry_lock(lock_context);
2004fd0: 7f ff f5 8f call 200260c <sparc_disable_interrupts>
2004fd4: 01 00 00 00 nop
2004fd8: ba 10 00 08 mov %o0, %i5
global_loc = *global_loc_ptr;
2004fdc: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
2004fe0: 80 a6 20 00 cmp %i0, 0
2004fe4: 02 80 00 07 be 2005000 <rtems_filesystem_global_location_obtain+0xb8>
2004fe8: 01 00 00 00 nop
2004fec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2004ff0: c2 08 60 28 ldub [ %g1 + 0x28 ], %g1
2004ff4: 80 a0 60 00 cmp %g1, 0
2004ff8: 32 80 00 08 bne,a 2005018 <rtems_filesystem_global_location_obtain+0xd0>
2004ffc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
global_loc = &rtems_filesystem_global_location_null;
errno = ENXIO;
2005000: 40 00 2c f6 call 20103d8 <__errno>
2005004: 31 00 80 76 sethi %hi(0x201d800), %i0
2005008: 82 10 20 06 mov 6, %g1
200500c: c2 22 00 00 st %g1, [ %o0 ]
}
rtems_filesystem_mt_entry_lock(lock_context);
global_loc = *global_loc_ptr;
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
global_loc = &rtems_filesystem_global_location_null;
2005010: b0 16 20 68 or %i0, 0x68, %i0
errno = ENXIO;
}
++global_loc->reference_count;
2005014: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2005018: 82 00 60 01 inc %g1
200501c: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
rtems_filesystem_mt_entry_unlock(lock_context);
2005020: 7f ff f5 7f call 200261c <sparc_enable_interrupts>
2005024: 90 10 00 1d mov %i5, %o0
2005028: 81 c7 e0 08 ret
200502c: 81 e8 00 00 restore
0200334c <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
200334c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
2003350: 05 00 80 6d sethi %hi(0x201b400), %g2
2003354: 82 10 a1 14 or %g2, 0x114, %g1 ! 201b514 <rtems_filesystem_root_configuration>
2003358: d0 00 a1 14 ld [ %g2 + 0x114 ], %o0
200335c: d2 00 60 04 ld [ %g1 + 4 ], %o1
2003360: d4 00 60 08 ld [ %g1 + 8 ], %o2
2003364: d6 00 60 0c ld [ %g1 + 0xc ], %o3
2003368: 40 00 02 22 call 2003bf0 <mount>
200336c: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
2003370: 80 a2 20 00 cmp %o0, 0
2003374: 12 80 00 0a bne 200339c <rtems_filesystem_initialize+0x50><== NEVER TAKEN
2003378: 92 10 21 ff mov 0x1ff, %o1
*
* 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);
200337c: 11 00 80 6e sethi %hi(0x201b800), %o0
2003380: 40 00 01 d3 call 2003acc <mkdir>
2003384: 90 12 23 68 or %o0, 0x368, %o0 ! 201bb68 <IMFS_node_control_default+0x18>
if ( rv != 0 )
2003388: 80 a2 20 00 cmp %o0, 0
200338c: 12 80 00 07 bne 20033a8 <rtems_filesystem_initialize+0x5c><== NEVER TAKEN
2003390: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
2003394: 81 c7 e0 08 ret
2003398: 81 e8 00 00 restore
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0002 );
200339c: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
20033a0: 40 00 13 d5 call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
20033a4: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0xa98d0002><== NOT EXECUTED
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
20033a8: 40 00 13 d3 call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
20033ac: 90 12 20 03 or %o0, 3, %o0 <== NOT EXECUTED
0200c9c8 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
200c9c8: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
200c9cc: 3b 00 80 6d sethi %hi(0x201b400), %i5
200c9d0: c2 07 61 28 ld [ %i5 + 0x128 ], %g1 ! 201b528 <rtems_filesystem_table>
200c9d4: 80 a0 60 00 cmp %g1, 0
200c9d8: 12 80 00 06 bne 200c9f0 <rtems_filesystem_iterate+0x28> <== ALWAYS TAKEN
200c9dc: ba 17 61 28 or %i5, 0x128, %i5
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200c9e0: 10 80 00 0e b 200ca18 <rtems_filesystem_iterate+0x50> <== NOT EXECUTED
200c9e4: 35 00 80 78 sethi %hi(0x201e000), %i2 <== NOT EXECUTED
200c9e8: 12 80 00 24 bne 200ca78 <rtems_filesystem_iterate+0xb0>
200c9ec: 01 00 00 00 nop
stop = (*routine)( table_entry, routine_arg );
200c9f0: 90 10 00 1d mov %i5, %o0
200c9f4: 9f c6 00 00 call %i0
200c9f8: 92 10 00 19 mov %i1, %o1
++table_entry;
200c9fc: ba 07 60 08 add %i5, 8, %i5
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
200ca00: c2 07 40 00 ld [ %i5 ], %g1
200ca04: 80 a0 60 00 cmp %g1, 0
200ca08: 12 bf ff f8 bne 200c9e8 <rtems_filesystem_iterate+0x20>
200ca0c: b8 8a 20 ff andcc %o0, 0xff, %i4
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
200ca10: 12 80 00 1a bne 200ca78 <rtems_filesystem_iterate+0xb0>
200ca14: 35 00 80 78 sethi %hi(0x201e000), %i2
200ca18: d0 06 a1 9c ld [ %i2 + 0x19c ], %o0 ! 201e19c <rtems_libio_semaphore>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200ca1c: 37 00 80 76 sethi %hi(0x201d800), %i3
200ca20: 92 10 20 00 clr %o1
200ca24: 7f ff ec 4f call 2007b60 <rtems_semaphore_obtain>
200ca28: 94 10 20 00 clr %o2
200ca2c: fa 06 e0 e8 ld [ %i3 + 0xe8 ], %i5
200ca30: b6 16 e0 e8 or %i3, 0xe8, %i3
rtems_libio_lock();
for (
200ca34: b6 06 e0 04 add %i3, 4, %i3
200ca38: 80 a7 40 1b cmp %i5, %i3
200ca3c: 12 80 00 05 bne 200ca50 <rtems_filesystem_iterate+0x88>
200ca40: b8 10 20 00 clr %i4
200ca44: 30 80 00 0b b,a 200ca70 <rtems_filesystem_iterate+0xa8>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
200ca48: 12 80 00 0a bne 200ca70 <rtems_filesystem_iterate+0xa8> <== NEVER TAKEN
200ca4c: 01 00 00 00 nop
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
200ca50: 90 07 60 08 add %i5, 8, %o0
200ca54: 9f c6 00 00 call %i0
200ca58: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200ca5c: fa 07 40 00 ld [ %i5 ], %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
200ca60: 80 a7 40 1b cmp %i5, %i3
200ca64: 12 bf ff f9 bne 200ca48 <rtems_filesystem_iterate+0x80>
200ca68: b8 8a 20 ff andcc %o0, 0xff, %i4
200ca6c: b8 0a 20 ff and %o0, 0xff, %i4
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200ca70: 7f ff ec 8b call 2007c9c <rtems_semaphore_release>
200ca74: d0 06 a1 9c ld [ %i2 + 0x19c ], %o0
}
rtems_libio_unlock();
}
return stop;
}
200ca78: 81 c7 e0 08 ret
200ca7c: 91 e8 00 1c restore %g0, %i4, %o0
02004d64 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
2004d64: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
bool do_unmount;
rtems_filesystem_mt_entry_lock(lock_context);
2004d68: 7f ff f6 29 call 200260c <sparc_disable_interrupts>
2004d6c: 01 00 00 00 nop
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
2004d70: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2004d74: c6 06 00 00 ld [ %i0 ], %g3
previous = the_node->previous;
2004d78: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
2004d7c: c8 08 60 28 ldub [ %g1 + 0x28 ], %g4
next->previous = previous;
2004d80: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
2004d84: c6 20 80 00 st %g3, [ %g2 ]
2004d88: 80 a1 20 00 cmp %g4, 0
2004d8c: 12 80 00 07 bne 2004da8 <rtems_filesystem_location_remove_from_mt_entry+0x44>
2004d90: ba 10 20 00 clr %i5
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
2004d94: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
2004d98: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
2004d9c: 80 a0 c0 02 cmp %g3, %g2
2004da0: 22 80 00 0b be,a 2004dcc <rtems_filesystem_location_remove_from_mt_entry+0x68>
2004da4: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
rtems_filesystem_mt_entry_unlock(lock_context);
2004da8: 7f ff f6 1d call 200261c <sparc_enable_interrupts>
2004dac: 01 00 00 00 nop
if (do_unmount) {
2004db0: 80 8f 60 ff btst 0xff, %i5
2004db4: 32 80 00 04 bne,a 2004dc4 <rtems_filesystem_location_remove_from_mt_entry+0x60><== NEVER TAKEN
2004db8: f0 06 20 14 ld [ %i0 + 0x14 ], %i0 <== NOT EXECUTED
2004dbc: 81 c7 e0 08 ret
2004dc0: 81 e8 00 00 restore
rtems_filesystem_do_unmount(loc->mt_entry);
2004dc4: 7f ff ff c8 call 2004ce4 <rtems_filesystem_do_unmount> <== NOT EXECUTED
2004dc8: 81 e8 00 00 restore <== NOT EXECUTED
&& mt_entry->mt_fs_root->reference_count == 1;
2004dcc: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2
2004dd0: 80 a0 a0 01 cmp %g2, 1
2004dd4: 12 bf ff f5 bne 2004da8 <rtems_filesystem_location_remove_from_mt_entry+0x44><== ALWAYS TAKEN
2004dd8: 84 00 60 14 add %g1, 0x14, %g2
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 );
2004ddc: 86 00 60 18 add %g1, 0x18, %g3 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
2004de0: c0 20 60 18 clr [ %g1 + 0x18 ] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2004de4: c6 20 60 14 st %g3, [ %g1 + 0x14 ] <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
2004de8: c4 20 60 1c st %g2, [ %g1 + 0x1c ] <== NOT EXECUTED
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
2004dec: 10 bf ff ef b 2004da8 <rtems_filesystem_location_remove_from_mt_entry+0x44><== NOT EXECUTED
2004df0: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
02005030 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
2005030: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
2005034: 7f ff fa 69 call 20039d8 <malloc>
2005038: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
200503c: ba 92 20 00 orcc %o0, 0, %i5
2005040: 02 80 00 0c be 2005070 <rtems_filesystem_location_transform_to_global+0x40><== NEVER TAKEN
2005044: 82 10 20 01 mov 1, %g1
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
2005048: 92 10 00 18 mov %i0, %o1
)
{
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
if (global_loc != NULL) {
global_loc->reference_count = 1;
200504c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
global_loc->deferred_released_next = NULL;
2005050: c0 27 60 1c clr [ %i5 + 0x1c ]
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
2005054: 7f ff ff 08 call 2004c74 <rtems_filesystem_location_copy>
2005058: c0 27 60 20 clr [ %i5 + 0x20 ]
rtems_filesystem_location_remove_from_mt_entry(loc);
200505c: 90 10 00 18 mov %i0, %o0
2005060: 7f ff ff 41 call 2004d64 <rtems_filesystem_location_remove_from_mt_entry>
2005064: b0 10 00 1d mov %i5, %i0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
2005068: 81 c7 e0 08 ret
200506c: 81 e8 00 00 restore
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);
2005070: 40 00 1d bd call 200c764 <rtems_filesystem_location_free> <== NOT EXECUTED
2005074: 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 );
2005078: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
200507c: 7f ff ff b3 call 2004f48 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
2005080: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
2005084: 40 00 2c d5 call 20103d8 <__errno> <== NOT EXECUTED
2005088: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
200508c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
2005090: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
2005094: 81 c7 e0 08 ret <== NOT EXECUTED
2005098: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
02003ae8 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2003ae8: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
2003aec: 03 00 80 76 sethi %hi(0x201d800), %g1
2003af0: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 201d838 <rtems_current_user_env>
switch (mode & S_IFMT) {
2003af4: 05 00 00 10 sethi %hi(0x4000), %g2
dev_t dev
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
2003af8: d6 00 60 08 ld [ %g1 + 8 ], %o3
switch (mode & S_IFMT) {
2003afc: 03 00 00 3c sethi %hi(0xf000), %g1
dev_t dev
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
2003b00: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
2003b04: 82 0a c0 01 and %o3, %g1, %g1
2003b08: 80 a0 40 02 cmp %g1, %g2
2003b0c: 22 80 00 18 be,a 2003b6c <rtems_filesystem_mknod+0x84>
2003b10: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2003b14: 08 80 00 0f bleu 2003b50 <rtems_filesystem_mknod+0x68>
2003b18: 05 00 00 04 sethi %hi(0x1000), %g2
2003b1c: 05 00 00 18 sethi %hi(0x6000), %g2
2003b20: 80 a0 40 02 cmp %g1, %g2
2003b24: 02 80 00 11 be 2003b68 <rtems_filesystem_mknod+0x80>
2003b28: 05 00 00 20 sethi %hi(0x8000), %g2
2003b2c: 80 a0 40 02 cmp %g1, %g2
2003b30: 22 80 00 0f be,a 2003b6c <rtems_filesystem_mknod+0x84> <== ALWAYS TAKEN
2003b34: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
case S_IFDIR:
case S_IFIFO:
case S_IFREG:
break;
default:
errno = EINVAL;
2003b38: 40 00 32 28 call 20103d8 <__errno>
2003b3c: b0 10 3f ff mov -1, %i0
2003b40: 82 10 20 16 mov 0x16, %g1
2003b44: c2 22 00 00 st %g1, [ %o0 ]
2003b48: 81 c7 e0 08 ret
2003b4c: 81 e8 00 00 restore
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
2003b50: 80 a0 40 02 cmp %g1, %g2
2003b54: 02 80 00 05 be 2003b68 <rtems_filesystem_mknod+0x80>
2003b58: 05 00 00 08 sethi %hi(0x2000), %g2
2003b5c: 80 a0 40 02 cmp %g1, %g2
2003b60: 12 bf ff f6 bne 2003b38 <rtems_filesystem_mknod+0x50>
2003b64: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
2003b68: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
2003b6c: 90 10 00 18 mov %i0, %o0
2003b70: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2003b74: 92 10 00 19 mov %i1, %o1
2003b78: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
2003b7c: 94 10 00 1a mov %i2, %o2
2003b80: 98 10 00 1c mov %i4, %o4
2003b84: 9f c0 40 00 call %g1
2003b88: 9a 10 00 1d mov %i5, %o5
}
return rv;
}
2003b8c: 81 c7 e0 08 ret
2003b90: 91 e8 00 08 restore %g0, %o0, %o0
0200cb84 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
200cb84: 9d e3 bf a0 save %sp, -96, %sp
rtems_chain_node *node = NULL;
if ( type == NULL ) {
200cb88: 80 a6 20 00 cmp %i0, 0
200cb8c: 02 80 00 29 be 200cc30 <rtems_filesystem_unregister+0xac>
200cb90: 37 00 80 78 sethi %hi(0x201e000), %i3
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200cb94: d0 06 e1 9c ld [ %i3 + 0x19c ], %o0 ! 201e19c <rtems_libio_semaphore>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200cb98: 39 00 80 76 sethi %hi(0x201d800), %i4
200cb9c: 92 10 20 00 clr %o1
200cba0: 7f ff eb f0 call 2007b60 <rtems_semaphore_obtain>
200cba4: 94 10 20 00 clr %o2
200cba8: fa 07 20 e8 ld [ %i4 + 0xe8 ], %i5
200cbac: b8 17 20 e8 or %i4, 0xe8, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
200cbb0: b8 07 20 04 add %i4, 4, %i4
200cbb4: 80 a7 40 1c cmp %i5, %i4
200cbb8: 32 80 00 08 bne,a 200cbd8 <rtems_filesystem_unregister+0x54>
200cbbc: d0 07 60 08 ld [ %i5 + 8 ], %o0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200cbc0: 10 80 00 14 b 200cc10 <rtems_filesystem_unregister+0x8c>
200cbc4: d0 06 e1 9c ld [ %i3 + 0x19c ], %o0
200cbc8: 80 a7 40 1c cmp %i5, %i4
200cbcc: 02 80 00 11 be 200cc10 <rtems_filesystem_unregister+0x8c> <== ALWAYS TAKEN
200cbd0: d0 06 e1 9c ld [ %i3 + 0x19c ], %o0
!rtems_chain_is_tail( &filesystem_chain, node );
node = rtems_chain_next( node )
) {
filesystem_node *fsn = (filesystem_node *) node;
if ( strcmp( fsn->entry.type, type ) == 0 ) {
200cbd4: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
200cbd8: 40 00 11 9a call 2011240 <strcmp>
200cbdc: 92 10 00 18 mov %i0, %o1
200cbe0: 80 a2 20 00 cmp %o0, 0
200cbe4: 32 bf ff f9 bne,a 200cbc8 <rtems_filesystem_unregister+0x44>
200cbe8: fa 07 40 00 ld [ %i5 ], %i5
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
200cbec: 40 00 04 46 call 200dd04 <_Chain_Extract>
200cbf0: 90 10 00 1d mov %i5, %o0
rtems_chain_extract( node );
free( fsn );
200cbf4: 7f ff da 9f call 2003670 <free>
200cbf8: 90 10 00 1d mov %i5, %o0
200cbfc: d0 06 e1 9c ld [ %i3 + 0x19c ], %o0
200cc00: 7f ff ec 27 call 2007c9c <rtems_semaphore_release>
200cc04: b0 10 20 00 clr %i0
200cc08: 81 c7 e0 08 ret
200cc0c: 81 e8 00 00 restore
200cc10: 7f ff ec 23 call 2007c9c <rtems_semaphore_release>
200cc14: b0 10 3f ff mov -1, %i0
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
200cc18: 40 00 0d f0 call 20103d8 <__errno>
200cc1c: 01 00 00 00 nop
200cc20: 82 10 20 02 mov 2, %g1 ! 2 <PROM_START+0x2>
200cc24: c2 22 00 00 st %g1, [ %o0 ]
}
200cc28: 81 c7 e0 08 ret
200cc2c: 81 e8 00 00 restore
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
200cc30: 40 00 0d ea call 20103d8 <__errno>
200cc34: b0 10 3f ff mov -1, %i0
200cc38: 82 10 20 16 mov 0x16, %g1
200cc3c: c2 22 00 00 st %g1, [ %o0 ]
200cc40: 81 c7 e0 08 ret
200cc44: 81 e8 00 00 restore
02003ea0 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2003ea0: 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 ) );
2003ea4: 40 00 01 0c call 20042d4 <malloc>
2003ea8: 90 10 20 08 mov 8, %o0
*key = new_key;
new_key->val = NULL;
2003eac: c0 22 00 00 clr [ %o0 ]
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
2003eb0: 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 ) );
2003eb4: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
new_key->dtor = dtor;
2003eb8: 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 );
2003ebc: 92 10 00 1d mov %i5, %o1
2003ec0: 90 10 20 00 clr %o0
2003ec4: 94 10 00 19 mov %i1, %o2
2003ec8: 40 00 13 09 call 2008aec <rtems_task_variable_add>
2003ecc: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
2003ed0: 80 a2 20 00 cmp %o0, 0
2003ed4: 02 80 00 04 be 2003ee4 <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
2003ed8: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
2003edc: 7f ff ff 81 call 2003ce0 <free> <== NOT EXECUTED
2003ee0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
2003ee4: 81 c7 e0 08 ret
2003ee8: 81 e8 00 00 restore
02003ef8 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
2003ef8: 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 );
2003efc: 90 10 20 00 clr %o0
2003f00: 40 00 13 2d call 2008bb4 <rtems_task_variable_delete>
2003f04: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
2003f08: 80 a2 20 00 cmp %o0, 0
2003f0c: 12 80 00 06 bne 2003f24 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2003f10: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
2003f14: 02 80 00 04 be 2003f24 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2003f18: 01 00 00 00 nop
2003f1c: 7f ff ff 71 call 2003ce0 <free>
2003f20: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
2003f24: 81 c7 e0 08 ret
2003f28: 91 e8 20 00 restore %g0, 0, %o0
02003e30 <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))
{
2003e30: 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 ) {
2003e34: c2 06 00 00 ld [ %i0 ], %g1
2003e38: 80 a0 60 00 cmp %g1, 0
2003e3c: 02 80 00 04 be 2003e4c <rtems_gxx_once+0x1c>
2003e40: 92 10 21 00 mov 0x100, %o1
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
2003e44: 81 c7 e0 08 ret
2003e48: 91 e8 20 00 restore %g0, 0, %o0
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2003e4c: 94 07 bf fc add %fp, -4, %o2
2003e50: 40 00 12 9d call 20088c4 <rtems_task_mode>
2003e54: 90 10 21 00 mov 0x100, %o0
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2003e58: c2 06 00 00 ld [ %i0 ], %g1
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2003e5c: d0 07 bf fc ld [ %fp + -4 ], %o0
2003e60: 92 10 21 00 mov 0x100, %o1
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2003e64: 80 a0 60 00 cmp %g1, 0
2003e68: 12 80 00 0a bne 2003e90 <rtems_gxx_once+0x60> <== NEVER TAKEN
2003e6c: 94 07 bf fc add %fp, -4, %o2
*(volatile __gthread_once_t *)once = 1;
2003e70: 82 10 20 01 mov 1, %g1
2003e74: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2003e78: 40 00 12 93 call 20088c4 <rtems_task_mode>
2003e7c: b0 10 20 00 clr %i0
if ( o == 0 )
(*func)();
2003e80: 9f c6 40 00 call %i1
2003e84: 01 00 00 00 nop
}
return 0;
}
2003e88: 81 c7 e0 08 ret
2003e8c: 81 e8 00 00 restore
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2003e90: 40 00 12 8d call 20088c4 <rtems_task_mode> <== NOT EXECUTED
2003e94: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( o == 0 )
(*func)();
}
return 0;
}
2003e98: 81 c7 e0 08 ret <== NOT EXECUTED
2003e9c: 81 e8 00 00 restore <== NOT EXECUTED
02003f94 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
2003f94: 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 );
2003f98: d4 06 20 04 ld [ %i0 + 4 ], %o2
2003f9c: 90 10 20 00 clr %o0
2003fa0: 40 00 12 d3 call 2008aec <rtems_task_variable_add>
2003fa4: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
2003fa8: 80 a2 20 00 cmp %o0, 0
2003fac: 12 80 00 05 bne 2003fc0 <rtems_gxx_setspecific+0x2c> <== NEVER TAKEN
2003fb0: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
2003fb4: f2 26 00 00 st %i1, [ %i0 ]
return 0;
2003fb8: 81 c7 e0 08 ret
2003fbc: 91 e8 20 00 restore %g0, 0, %o0
}
return -1;
}
2003fc0: 81 c7 e0 08 ret <== NOT EXECUTED
2003fc4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02007f68 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007f68: 9d e3 bf a0 save %sp, -96, %sp
if (
2007f6c: 03 00 80 96 sethi %hi(0x2025800), %g1
2007f70: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 ! 2025968 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007f74: ba 10 00 18 mov %i0, %i5
2007f78: b8 10 00 19 mov %i1, %i4
if (
2007f7c: 80 a0 60 03 cmp %g1, 3
2007f80: 02 80 00 08 be 2007fa0 <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
2007f84: b6 10 00 1a mov %i2, %i3
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
2007f88: 7f ff fb d4 call 2006ed8 <malloc_deferred_frees_process>
2007f8c: b2 10 00 1d mov %i5, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
2007f90: 03 00 80 8f sethi %hi(0x2023c00), %g1
2007f94: f0 00 63 54 ld [ %g1 + 0x354 ], %i0 ! 2023f54 <RTEMS_Malloc_Heap>
2007f98: 40 00 19 7f call 200e594 <_Protected_heap_Allocate_aligned_with_boundary>
2007f9c: 95 e8 00 1c restore %g0, %i4, %o2
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
2007fa0: 7f ff fb c1 call 2006ea4 <malloc_is_system_state_OK>
2007fa4: 01 00 00 00 nop
2007fa8: 80 8a 20 ff btst 0xff, %o0
2007fac: 12 bf ff f7 bne 2007f88 <rtems_heap_allocate_aligned_with_boundary+0x20>
2007fb0: b0 10 20 00 clr %i0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
2007fb4: 81 c7 e0 08 ret
2007fb8: 81 e8 00 00 restore
0200466c <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
200466c: 9d e3 bf a0 save %sp, -96, %sp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
2004670: 03 00 80 79 sethi %hi(0x201e400), %g1
2004674: f8 00 61 00 ld [ %g1 + 0x100 ], %i4 ! 201e500 <RTEMS_Malloc_Sbrk_amount>
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_size % sbrk_amount;
2004678: 90 10 00 19 mov %i1, %o0
200467c: 92 10 00 1c mov %i4, %o1
2004680: 40 00 54 3a call 2019768 <.rem>
2004684: ba 10 00 19 mov %i1, %i5
void *return_this = NULL;
if ( misaligned != 0 ) {
2004688: 80 a2 20 00 cmp %o0, 0
200468c: 02 80 00 05 be 20046a0 <rtems_heap_extend_via_sbrk+0x34>
2004690: 80 a7 60 00 cmp %i5, 0
sbrk_size += sbrk_amount - misaligned;
2004694: ba 27 00 08 sub %i4, %o0, %i5
2004698: ba 06 40 1d add %i1, %i5, %i5
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
200469c: 80 a7 60 00 cmp %i5, 0
20046a0: 04 80 00 17 ble 20046fc <rtems_heap_extend_via_sbrk+0x90> <== NEVER TAKEN
20046a4: 80 a7 20 00 cmp %i4, 0
20046a8: 04 80 00 15 ble 20046fc <rtems_heap_extend_via_sbrk+0x90> <== NEVER TAKEN
20046ac: 01 00 00 00 nop
void *area_begin = sbrk( sbrk_size );
20046b0: 7f ff f3 8c call 20014e0 <sbrk>
20046b4: 90 10 00 1d mov %i5, %o0
if ( area_begin != (void *) -1 ) {
20046b8: 80 a2 3f ff cmp %o0, -1
20046bc: 02 80 00 10 be 20046fc <rtems_heap_extend_via_sbrk+0x90>
20046c0: 92 10 00 08 mov %o0, %o1
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
20046c4: 90 10 00 18 mov %i0, %o0
20046c8: 40 00 14 c7 call 20099e4 <_Protected_heap_Extend>
20046cc: 94 10 00 1d mov %i5, %o2
if ( ok ) {
20046d0: 80 8a 20 ff btst 0xff, %o0
20046d4: 02 80 00 08 be 20046f4 <rtems_heap_extend_via_sbrk+0x88>
20046d8: 03 00 80 79 sethi %hi(0x201e400), %g1
MSBUMP( space_available, sbrk_size );
20046dc: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 201e4d0 <rtems_malloc_statistics>
20046e0: b4 10 20 00 clr %i2
20046e4: ba 07 40 02 add %i5, %g2, %i5
20046e8: fa 20 60 d0 st %i5, [ %g1 + 0xd0 ]
20046ec: 40 00 14 b0 call 20099ac <_Protected_heap_Allocate_aligned_with_boundary>
20046f0: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( heap, alloc_size );
} else {
sbrk( -sbrk_size );
20046f4: 7f ff f3 7b call 20014e0 <sbrk>
20046f8: 90 20 00 1d neg %i5, %o0
}
}
}
return return_this;
}
20046fc: 81 c7 e0 08 ret
2004700: 91 e8 20 00 restore %g0, 0, %o0
02004674 <rtems_heap_null_extend>:
Heap_Control *heap __attribute__((unused)),
size_t alloc_size __attribute__((unused))
)
{
return NULL;
}
2004674: 81 c3 e0 08 retl
2004678: 90 10 20 00 clr %o0
0200505c <rtems_ide_part_table_free>:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
200505c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2005060: 7f ff fe bb call 2004b4c <partition_table_free> <== NOT EXECUTED
2005064: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02005068 <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 );
2005068: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
200506c: 7f ff ff 89 call 2004e90 <partition_table_get> <== NOT EXECUTED
2005070: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02005074 <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)
{
2005074: 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));
2005078: 90 10 20 01 mov 1, %o0
200507c: 92 10 21 28 mov 0x128, %o1
2005080: 40 00 02 19 call 20058e4 <calloc>
2005084: b2 10 00 18 mov %i0, %i1
if (disk_desc == NULL)
{
return RTEMS_NO_MEMORY;
2005088: b0 10 20 1a mov 0x1a, %i0
/* 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));
if (disk_desc == NULL)
200508c: 80 a2 20 00 cmp %o0, 0
2005090: 02 80 00 33 be 200515c <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
2005094: b4 10 00 08 mov %o0, %i2
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
2005098: 90 10 00 19 mov %i1, %o0
200509c: 7f ff ff 7d call 2004e90 <partition_table_get>
20050a0: 92 10 00 1a mov %i2, %o1
if (rc != RTEMS_SUCCESSFUL)
20050a4: b0 92 20 00 orcc %o0, 0, %i0
20050a8: 12 80 00 36 bne 2005180 <rtems_ide_part_table_initialize+0x10c><== NEVER TAKEN
20050ac: ba 10 20 00 clr %i5
*/
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++)
20050b0: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
20050b4: b6 07 bf f0 add %fp, -16, %i3
20050b8: 21 00 80 95 sethi %hi(0x2025400), %l0
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);
20050bc: 27 00 80 95 sethi %hi(0x2025400), %l3
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);
20050c0: a0 14 22 e8 or %l0, 0x2e8, %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++)
20050c4: 80 a7 40 01 cmp %i5, %g1
/* 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);
20050c8: e4 06 80 00 ld [ %i2 ], %l2
/* 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);
20050cc: ba 07 60 01 inc %i5
/* 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);
20050d0: e2 06 a0 04 ld [ %i2 + 4 ], %l1
* 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)
20050d4: b8 06 a0 28 add %i2, 0x28, %i4
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);
20050d8: 29 00 80 9d sethi %hi(0x2027400), %l4
20050dc: a6 14 e2 f0 or %l3, 0x2f0, %l3
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);
20050e0: 92 10 00 10 mov %l0, %o1
20050e4: 94 10 00 19 mov %i1, %o2
20050e8: 90 10 00 1b mov %i3, %o0
*/
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++)
20050ec: 16 80 00 1a bge 2005154 <rtems_ide_part_table_initialize+0xe0><== NEVER TAKEN
20050f0: 96 10 00 1d mov %i5, %o3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
20050f4: 40 00 48 35 call 20171c8 <sprintf>
20050f8: 01 00 00 00 nop
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
20050fc: c2 07 00 00 ld [ %i4 ], %g1
if (part_desc == NULL)
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
2005100: 90 10 00 12 mov %l2, %o0
{
sprintf(name, "%s%d", dev_name, part_num + 1);
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
if (part_desc == NULL)
2005104: 80 a0 60 00 cmp %g1, 0
2005108: 02 80 00 0a be 2005130 <rtems_ide_part_table_initialize+0xbc>
200510c: 92 07 40 11 add %i5, %l1, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
2005110: d8 00 60 04 ld [ %g1 + 4 ], %o4
2005114: da 00 60 08 ld [ %g1 + 8 ], %o5
2005118: d4 1e 80 00 ldd [ %i2 ], %o2
200511c: 7f ff fd 47 call 2004638 <rtems_disk_create_log>
2005120: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
2005124: 96 92 20 00 orcc %o0, 0, %o3
2005128: 12 80 00 0f bne 2005164 <rtems_ide_part_table_initialize+0xf0><== NEVER TAKEN
200512c: c2 05 22 a8 ld [ %l4 + 0x2a8 ], %g1
2005130: b8 07 20 04 add %i4, 4, %i4
*/
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++)
2005134: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2005138: 92 10 00 10 mov %l0, %o1
*/
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++)
200513c: 80 a7 40 01 cmp %i5, %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2005140: 94 10 00 19 mov %i1, %o2
2005144: ba 07 60 01 inc %i5
2005148: 90 10 00 1b mov %i3, %o0
*/
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++)
200514c: 06 bf ff ea bl 20050f4 <rtems_ide_part_table_initialize+0x80>
2005150: 96 10 00 1d mov %i5, %o3
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
continue;
}
}
partition_table_free(disk_desc);
2005154: 7f ff fe 7e call 2004b4c <partition_table_free>
2005158: 90 10 00 1a mov %i2, %o0
return RTEMS_SUCCESSFUL;
}
200515c: 81 c7 e0 08 ret
2005160: 81 e8 00 00 restore
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);
2005164: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2005168: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
200516c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2005170: 40 00 45 88 call 2016790 <fprintf> <== NOT EXECUTED
2005174: b8 07 20 04 add %i4, 4, %i4 <== NOT EXECUTED
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2005178: 10 bf ff f0 b 2005138 <rtems_ide_part_table_initialize+0xc4><== NOT EXECUTED
200517c: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1 <== NOT EXECUTED
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(disk_desc);
2005180: 40 00 02 aa call 2005c28 <free> <== NOT EXECUTED
2005184: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2005188: 81 c7 e0 08 ret <== NOT EXECUTED
200518c: 81 e8 00 00 restore <== NOT EXECUTED
020097a8 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
20097a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
20097ac: 03 00 80 8b sethi %hi(0x2022c00), %g1
20097b0: c4 00 63 d8 ld [ %g1 + 0x3d8 ], %g2 ! 2022fd8 <_Per_CPU_Information+0x8>
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
20097b4: ba 10 00 18 mov %i0, %i5
rtems_device_major_number major_limit = _IO_Number_of_drivers;
20097b8: 03 00 80 8d sethi %hi(0x2023400), %g1
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
20097bc: 86 10 00 19 mov %i1, %g3
rtems_device_major_number major_limit = _IO_Number_of_drivers;
20097c0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
if ( rtems_interrupt_is_in_progress() )
20097c4: 80 a0 a0 00 cmp %g2, 0
20097c8: 12 80 00 1f bne 2009844 <rtems_io_register_driver+0x9c>
20097cc: b0 10 20 12 mov 0x12, %i0
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
20097d0: 80 a6 a0 00 cmp %i2, 0
20097d4: 02 80 00 21 be 2009858 <rtems_io_register_driver+0xb0>
20097d8: 80 a6 60 00 cmp %i1, 0
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
20097dc: 02 80 00 1f be 2009858 <rtems_io_register_driver+0xb0>
20097e0: c8 26 80 00 st %g4, [ %i2 ]
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
20097e4: c4 06 40 00 ld [ %i1 ], %g2
20097e8: 80 a0 a0 00 cmp %g2, 0
20097ec: 22 80 00 18 be,a 200984c <rtems_io_register_driver+0xa4>
20097f0: c4 06 60 04 ld [ %i1 + 4 ], %g2
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
20097f4: 80 a1 00 1d cmp %g4, %i5
20097f8: 08 80 00 13 bleu 2009844 <rtems_io_register_driver+0x9c>
20097fc: b0 10 20 0a mov 0xa, %i0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2009800: 05 00 80 8a sethi %hi(0x2022800), %g2
2009804: c8 00 a2 b0 ld [ %g2 + 0x2b0 ], %g4 ! 2022ab0 <_Thread_Dispatch_disable_level>
++level;
2009808: 88 01 20 01 inc %g4
_Thread_Dispatch_disable_level = level;
200980c: c8 20 a2 b0 st %g4, [ %g2 + 0x2b0 ]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
2009810: 80 a7 60 00 cmp %i5, 0
2009814: 02 80 00 13 be 2009860 <rtems_io_register_driver+0xb8>
2009818: 39 00 80 8d sethi %hi(0x2023400), %i4
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
200981c: c8 07 20 1c ld [ %i4 + 0x1c ], %g4 ! 202341c <_IO_Driver_address_table>
2009820: 85 2f 60 03 sll %i5, 3, %g2
2009824: b7 2f 60 05 sll %i5, 5, %i3
2009828: 82 26 c0 02 sub %i3, %g2, %g1
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
200982c: f2 01 00 01 ld [ %g4 + %g1 ], %i1
2009830: 80 a6 60 00 cmp %i1, 0
2009834: 02 80 00 3a be 200991c <rtems_io_register_driver+0x174>
2009838: 82 01 00 01 add %g4, %g1, %g1
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
200983c: 40 00 08 71 call 200ba00 <_Thread_Enable_dispatch>
2009840: b0 10 20 0c mov 0xc, %i0
return RTEMS_RESOURCE_IN_USE;
2009844: 81 c7 e0 08 ret
2009848: 81 e8 00 00 restore
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
200984c: 80 a0 a0 00 cmp %g2, 0
2009850: 12 bf ff ea bne 20097f8 <rtems_io_register_driver+0x50>
2009854: 80 a1 00 1d cmp %g4, %i5
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
2009858: 81 c7 e0 08 ret
200985c: 91 e8 20 09 restore %g0, 9, %o0
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
2009860: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
2009864: 80 a1 20 00 cmp %g4, 0
2009868: 02 80 00 33 be 2009934 <rtems_io_register_driver+0x18c> <== NEVER TAKEN
200986c: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
2009870: 30 80 00 04 b,a 2009880 <rtems_io_register_driver+0xd8>
2009874: 80 a7 40 04 cmp %i5, %g4
2009878: 02 80 00 24 be 2009908 <rtems_io_register_driver+0x160>
200987c: 82 00 60 18 add %g1, 0x18, %g1
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
2009880: c4 00 40 00 ld [ %g1 ], %g2
2009884: 80 a0 a0 00 cmp %g2, 0
2009888: 32 bf ff fb bne,a 2009874 <rtems_io_register_driver+0xcc>
200988c: ba 07 60 01 inc %i5
2009890: c4 00 60 04 ld [ %g1 + 4 ], %g2
2009894: 80 a0 a0 00 cmp %g2, 0
2009898: 32 bf ff f7 bne,a 2009874 <rtems_io_register_driver+0xcc>
200989c: ba 07 60 01 inc %i5
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
20098a0: fa 26 80 00 st %i5, [ %i2 ]
20098a4: 85 2f 60 03 sll %i5, 3, %g2
if ( m != n )
20098a8: 80 a1 00 1d cmp %g4, %i5
20098ac: 02 80 00 18 be 200990c <rtems_io_register_driver+0x164> <== NEVER TAKEN
20098b0: b7 2f 60 05 sll %i5, 5, %i3
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
20098b4: c8 00 c0 00 ld [ %g3 ], %g4
20098b8: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
20098bc: 84 26 c0 02 sub %i3, %g2, %g2
20098c0: c8 20 40 02 st %g4, [ %g1 + %g2 ]
20098c4: c8 00 e0 04 ld [ %g3 + 4 ], %g4
20098c8: 82 00 40 02 add %g1, %g2, %g1
20098cc: c8 20 60 04 st %g4, [ %g1 + 4 ]
20098d0: c4 00 e0 08 ld [ %g3 + 8 ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
20098d4: b2 10 20 00 clr %i1
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
20098d8: c4 20 60 08 st %g2, [ %g1 + 8 ]
20098dc: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
20098e0: b4 10 20 00 clr %i2
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
20098e4: c4 20 60 0c st %g2, [ %g1 + 0xc ]
20098e8: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
20098ec: b0 10 00 1d mov %i5, %i0
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
20098f0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
20098f4: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2
_Thread_Enable_dispatch();
20098f8: 40 00 08 42 call 200ba00 <_Thread_Enable_dispatch>
20098fc: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return rtems_io_initialize( major, 0, NULL );
2009900: 40 00 22 81 call 2012304 <rtems_io_initialize>
2009904: 81 e8 00 00 restore
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
2009908: fa 26 80 00 st %i5, [ %i2 ]
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
200990c: 40 00 08 3d call 200ba00 <_Thread_Enable_dispatch>
2009910: b0 10 20 05 mov 5, %i0
return sc;
2009914: 81 c7 e0 08 ret
2009918: 81 e8 00 00 restore
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
200991c: c2 00 60 04 ld [ %g1 + 4 ], %g1
2009920: 80 a0 60 00 cmp %g1, 0
2009924: 12 bf ff c6 bne 200983c <rtems_io_register_driver+0x94>
2009928: 01 00 00 00 nop
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
200992c: 10 bf ff e2 b 20098b4 <rtems_io_register_driver+0x10c>
2009930: fa 26 80 00 st %i5, [ %i2 ]
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
2009934: 10 bf ff f6 b 200990c <rtems_io_register_driver+0x164> <== NOT EXECUTED
2009938: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
0200a934 <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)
{
200a934: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
200a938: 80 a6 20 00 cmp %i0, 0
200a93c: 02 80 00 20 be 200a9bc <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
200a940: 37 00 80 83 sethi %hi(0x2020c00), %i3
200a944: b6 16 e2 a8 or %i3, 0x2a8, %i3 ! 2020ea8 <_Objects_Information_table+0x4>
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
200a948: b4 06 e0 0c add %i3, 0xc, %i2
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
200a94c: c2 06 c0 00 ld [ %i3 ], %g1
200a950: f8 00 60 04 ld [ %g1 + 4 ], %i4
if ( !information )
200a954: 80 a7 20 00 cmp %i4, 0
200a958: 22 80 00 16 be,a 200a9b0 <rtems_iterate_over_all_threads+0x7c>
200a95c: b6 06 e0 04 add %i3, 4, %i3
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
200a960: c2 17 20 10 lduh [ %i4 + 0x10 ], %g1
200a964: 86 90 60 00 orcc %g1, 0, %g3
200a968: 22 80 00 12 be,a 200a9b0 <rtems_iterate_over_all_threads+0x7c>
200a96c: b6 06 e0 04 add %i3, 4, %i3
200a970: ba 10 20 01 mov 1, %i5
the_thread = (Thread_Control *)information->local_table[ i ];
200a974: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
200a978: 83 2f 60 02 sll %i5, 2, %g1
200a97c: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_thread )
200a980: 90 90 60 00 orcc %g1, 0, %o0
200a984: 02 80 00 05 be 200a998 <rtems_iterate_over_all_threads+0x64>
200a988: ba 07 60 01 inc %i5
continue;
(*routine)(the_thread);
200a98c: 9f c6 00 00 call %i0
200a990: 01 00 00 00 nop
200a994: c6 17 20 10 lduh [ %i4 + 0x10 ], %g3
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
200a998: 83 28 e0 10 sll %g3, 0x10, %g1
200a99c: 83 30 60 10 srl %g1, 0x10, %g1
200a9a0: 80 a0 40 1d cmp %g1, %i5
200a9a4: 3a bf ff f5 bcc,a 200a978 <rtems_iterate_over_all_threads+0x44>
200a9a8: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
200a9ac: b6 06 e0 04 add %i3, 4, %i3
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
200a9b0: 80 a6 c0 1a cmp %i3, %i2
200a9b4: 32 bf ff e7 bne,a 200a950 <rtems_iterate_over_all_threads+0x1c>
200a9b8: c2 06 c0 00 ld [ %i3 ], %g1
200a9bc: 81 c7 e0 08 ret
200a9c0: 81 e8 00 00 restore
020037c0 <rtems_libio_init>:
rtems_id rtems_libio_semaphore;
rtems_libio_t *rtems_libio_iops;
rtems_libio_t *rtems_libio_iop_freelist;
void rtems_libio_init( void )
{
20037c0: 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)
20037c4: 03 00 80 75 sethi %hi(0x201d400), %g1
20037c8: fa 00 63 44 ld [ %g1 + 0x344 ], %i5 ! 201d744 <rtems_libio_number_iops>
20037cc: 80 a7 60 00 cmp %i5, 0
20037d0: 02 80 00 1b be 200383c <rtems_libio_init+0x7c> <== NEVER TAKEN
20037d4: 92 10 20 01 mov 1, %o1
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
20037d8: 90 10 00 1d mov %i5, %o0
20037dc: 7f ff fe f6 call 20033b4 <calloc>
20037e0: 92 10 20 38 mov 0x38, %o1
20037e4: 03 00 80 78 sethi %hi(0x201e000), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
20037e8: 80 a2 20 00 cmp %o0, 0
20037ec: 02 80 00 28 be 200388c <rtems_libio_init+0xcc>
20037f0: d0 20 61 94 st %o0, [ %g1 + 0x194 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
20037f4: 03 00 80 78 sethi %hi(0x201e000), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
20037f8: 80 a7 60 01 cmp %i5, 1
20037fc: 08 80 00 0e bleu 2003834 <rtems_libio_init+0x74>
2003800: d0 20 61 98 st %o0, [ %g1 + 0x198 ]
2003804: 82 10 00 08 mov %o0, %g1
2003808: 84 10 20 01 mov 1, %g2
iop->data1 = iop + 1;
200380c: 82 00 60 38 add %g1, 0x38, %g1
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++)
2003810: 84 00 a0 01 inc %g2
2003814: 80 a0 80 1d cmp %g2, %i5
2003818: 12 bf ff fd bne 200380c <rtems_libio_init+0x4c>
200381c: c2 20 7f f8 st %g1, [ %g1 + -8 ]
rtems_id rtems_libio_semaphore;
rtems_libio_t *rtems_libio_iops;
rtems_libio_t *rtems_libio_iop_freelist;
void rtems_libio_init( void )
2003820: 84 00 bf ff add %g2, -1, %g2
2003824: 83 28 a0 03 sll %g2, 3, %g1
2003828: 85 28 a0 06 sll %g2, 6, %g2
200382c: 84 20 80 01 sub %g2, %g1, %g2
2003830: 90 02 00 02 add %o0, %g2, %o0
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
iop->data1 = iop + 1;
iop->data1 = NULL;
2003834: c0 22 20 30 clr [ %o0 + 0x30 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
2003838: 92 10 20 01 mov 1, %o1
200383c: 11 13 10 92 sethi %hi(0x4c424800), %o0
2003840: 94 10 20 54 mov 0x54, %o2
2003844: 90 12 21 4f or %o0, 0x14f, %o0
2003848: 96 10 20 00 clr %o3
200384c: 19 00 80 78 sethi %hi(0x201e000), %o4
2003850: 40 00 10 1c call 20078c0 <rtems_semaphore_create>
2003854: 98 13 21 9c or %o4, 0x19c, %o4 ! 201e19c <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
2003858: 80 a2 20 00 cmp %o0, 0
200385c: 12 80 00 0a bne 2003884 <rtems_libio_init+0xc4> <== NEVER TAKEN
2003860: 03 00 80 75 sethi %hi(0x201d400), %g1
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
2003864: c2 00 63 48 ld [ %g1 + 0x348 ], %g1 ! 201d748 <rtems_fs_init_helper>
2003868: 80 a0 60 00 cmp %g1, 0
200386c: 02 80 00 04 be 200387c <rtems_libio_init+0xbc>
2003870: 01 00 00 00 nop
(* rtems_fs_init_helper)();
2003874: 9f c0 40 00 call %g1
2003878: 01 00 00 00 nop
200387c: 81 c7 e0 08 ret
2003880: 81 e8 00 00 restore
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
2003884: 40 00 12 9c call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
2003888: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
200388c: 40 00 12 9a call 20082f4 <rtems_fatal_error_occurred>
2003890: 90 10 20 1a mov 0x1a, %o0 ! 1a <PROM_START+0x1a>
020046fc <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
20046fc: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
2004700: 40 00 06 73 call 20060cc <rtems_task_self>
2004704: 37 00 80 4a sethi %hi(0x2012800), %i3
rtems_user_env_t *old_env = rtems_current_user_env;
2004708: fa 06 e3 6c ld [ %i3 + 0x36c ], %i5 ! 2012b6c <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;
200470c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
2004710: 80 a0 40 08 cmp %g1, %o0
2004714: 12 80 00 07 bne 2004730 <rtems_libio_set_private_env+0x34>
2004718: b8 10 00 08 mov %o0, %i4
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
rtems_user_env_t *old_env = rtems_current_user_env;
bool uses_global_env = old_env == &rtems_global_user_env;
200471c: 03 00 80 4a sethi %hi(0x2012800), %g1
2004720: 82 10 63 70 or %g1, 0x370, %g1 ! 2012b70 <rtems_global_user_env>
bool uses_shared_env = old_env->task_id != self_task_id;
if (uses_global_env || uses_shared_env) {
2004724: 80 a7 40 01 cmp %i5, %g1
2004728: 12 80 00 2a bne 20047d0 <rtems_libio_set_private_env+0xd4><== ALWAYS TAKEN
200472c: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
2004730: 90 10 20 01 mov 1, %o0
2004734: 92 10 20 2c mov 0x2c, %o1
2004738: 40 00 15 0e call 2009b70 <calloc>
200473c: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
2004740: 80 a2 20 00 cmp %o0, 0
2004744: 02 80 00 23 be 20047d0 <rtems_libio_set_private_env+0xd4>
2004748: b4 10 00 08 mov %o0, %i2
*new_env = *old_env;
200474c: 92 10 00 1d mov %i5, %o1
2004750: 40 00 21 45 call 200cc64 <memcpy>
2004754: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
2004758: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
200475c: 90 07 60 04 add %i5, 4, %o0
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;
2004760: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
2004764: 40 00 03 10 call 20053a4 <rtems_filesystem_global_location_obtain>
2004768: f8 26 a0 24 st %i4, [ %i2 + 0x24 ]
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
200476c: d0 26 a0 04 st %o0, [ %i2 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
rtems_filesystem_global_location_obtain(&old_env->current_directory);
2004770: 40 00 03 0d call 20053a4 <rtems_filesystem_global_location_obtain>
2004774: 90 10 00 1d mov %i5, %o0
static inline bool rtems_filesystem_location_is_null(
const rtems_filesystem_location_info_t *loc
)
{
return loc->handlers == &rtems_filesystem_null_handlers;
2004778: c2 06 a0 04 ld [ %i2 + 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 =
200477c: d0 26 80 00 st %o0, [ %i2 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
2004780: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2004784: 03 00 80 49 sethi %hi(0x2012400), %g1
2004788: 82 10 60 44 or %g1, 0x44, %g1 ! 2012444 <rtems_filesystem_null_handlers>
200478c: 80 a0 80 01 cmp %g2, %g1
2004790: 22 80 00 0e be,a 20047c8 <rtems_libio_set_private_env+0xcc>
2004794: 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)
2004798: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
200479c: 80 a0 80 01 cmp %g2, %g1
20047a0: 02 80 00 0e be 20047d8 <rtems_libio_set_private_env+0xdc> <== NEVER TAKEN
20047a4: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
20047a8: 92 16 e3 6c or %i3, 0x36c, %o1
20047ac: 15 00 80 11 sethi %hi(0x2004400), %o2
20047b0: 40 00 06 69 call 2006154 <rtems_task_variable_add>
20047b4: 94 12 a2 8c or %o2, 0x28c, %o2 ! 200468c <free_user_env>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
20047b8: b0 92 20 00 orcc %o0, 0, %i0
20047bc: 02 80 00 09 be 20047e0 <rtems_libio_set_private_env+0xe4>
20047c0: 01 00 00 00 nop
free_user_env_protected(old_env);
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
20047c4: b0 10 20 05 mov 5, %i0 ! 5 <PROM_START+0x5>
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
20047c8: 7f ff ff b1 call 200468c <free_user_env>
20047cc: 90 10 00 1a mov %i2, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
20047d0: 81 c7 e0 08 ret
20047d4: 81 e8 00 00 restore
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
}
} else {
sc = RTEMS_UNSATISFIED;
20047d8: 10 bf ff fc b 20047c8 <rtems_libio_set_private_env+0xcc> <== NOT EXECUTED
20047dc: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
free_user_env_protected(old_env);
20047e0: 7f ff ff be call 20046d8 <free_user_env_protected>
20047e4: 90 10 00 1d mov %i5, %o0
rtems_current_user_env = new_env;
20047e8: 03 00 80 4a sethi %hi(0x2012800), %g1
20047ec: f4 20 63 6c st %i2, [ %g1 + 0x36c ] ! 2012b6c <rtems_current_user_env>
20047f0: 81 c7 e0 08 ret
20047f4: 81 e8 00 00 restore
020047f8 <rtems_libio_share_private_env>:
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
20047f8: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
20047fc: 40 00 06 34 call 20060cc <rtems_task_self>
2004800: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
2004804: 80 a2 00 18 cmp %o0, %i0
2004808: 12 80 00 04 bne 2004818 <rtems_libio_share_private_env+0x20>
200480c: 80 a6 20 00 cmp %i0, 0
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
2004810: 81 c7 e0 08 ret
2004814: 91 e8 20 00 restore %g0, 0, %o0
rtems_id self_task_id = rtems_task_self();
if (task_id != RTEMS_SELF && self_task_id != task_id) {
2004818: 02 bf ff fe be 2004810 <rtems_libio_share_private_env+0x18>
200481c: 03 00 80 4d sethi %hi(0x2013400), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2004820: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 20134c0 <_Thread_Dispatch_disable_level>
++level;
2004824: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2004828: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
200482c: 3b 00 80 4a sethi %hi(0x2012800), %i5
2004830: 90 10 00 18 mov %i0, %o0
2004834: 92 17 63 6c or %i5, 0x36c, %o1
2004838: 40 00 06 a7 call 20062d4 <rtems_task_variable_get>
200483c: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
2004840: 80 a2 20 00 cmp %o0, 0
2004844: 12 80 00 14 bne 2004894 <rtems_libio_share_private_env+0x9c>
2004848: c2 07 bf fc ld [ %fp + -4 ], %g1
++env->reference_count;
200484c: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
2004850: 84 00 a0 01 inc %g2
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
2004854: 40 00 0f 2b call 2008500 <_Thread_Enable_dispatch>
2004858: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_task_variable_add(
200485c: 90 10 20 00 clr %o0
2004860: 92 17 63 6c or %i5, 0x36c, %o1
2004864: 15 00 80 11 sethi %hi(0x2004400), %o2
2004868: 40 00 06 3b call 2006154 <rtems_task_variable_add>
200486c: 94 12 a2 8c or %o2, 0x28c, %o2 ! 200468c <free_user_env>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
2004870: b0 92 20 00 orcc %o0, 0, %i0
2004874: 12 80 00 0c bne 20048a4 <rtems_libio_share_private_env+0xac><== NEVER TAKEN
2004878: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
200487c: 7f ff ff 97 call 20046d8 <free_user_env_protected>
2004880: d0 07 63 6c ld [ %i5 + 0x36c ], %o0
rtems_current_user_env = env;
2004884: c2 07 bf fc ld [ %fp + -4 ], %g1
2004888: c2 27 63 6c st %g1, [ %i5 + 0x36c ]
200488c: 81 c7 e0 08 ret
2004890: 81 e8 00 00 restore
if (sc == RTEMS_SUCCESSFUL) {
++env->reference_count;
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
2004894: 40 00 0f 1b call 2008500 <_Thread_Enable_dispatch>
2004898: b0 10 20 0d mov 0xd, %i0
}
}
}
return sc;
}
200489c: 81 c7 e0 08 ret
20048a0: 81 e8 00 00 restore
);
if (sc == RTEMS_SUCCESSFUL) {
free_user_env_protected(rtems_current_user_env);
rtems_current_user_env = env;
} else {
free_user_env_protected(env);
20048a4: 7f ff ff 8d call 20046d8 <free_user_env_protected> <== NOT EXECUTED
20048a8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
20048ac: 81 c7 e0 08 ret <== NOT EXECUTED
20048b0: 81 e8 00 00 restore <== NOT EXECUTED
0200c894 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
200c894: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
200c898: 84 08 60 06 and %g1, 6, %g2
200c89c: 80 a0 a0 06 cmp %g2, 6
200c8a0: 02 80 00 05 be 200c8b4 <rtems_libio_to_fcntl_flags+0x20>
200c8a4: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
200c8a8: 80 88 60 02 btst 2, %g1
200c8ac: 02 80 00 0e be 200c8e4 <rtems_libio_to_fcntl_flags+0x50> <== NEVER TAKEN
200c8b0: 90 10 20 00 clr %o0
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 ) {
200c8b4: 80 88 60 01 btst 1, %g1
200c8b8: 02 80 00 04 be 200c8c8 <rtems_libio_to_fcntl_flags+0x34>
200c8bc: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
200c8c0: 05 00 00 10 sethi %hi(0x4000), %g2
200c8c4: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
200c8c8: 32 80 00 02 bne,a 200c8d0 <rtems_libio_to_fcntl_flags+0x3c>
200c8cc: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
200c8d0: 80 88 64 00 btst 0x400, %g1
200c8d4: 32 80 00 02 bne,a 200c8dc <rtems_libio_to_fcntl_flags+0x48>
200c8d8: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
200c8dc: 81 c3 e0 08 retl
200c8e0: 01 00 00 00 nop
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
200c8e4: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
200c8e8: 10 bf ff f3 b 200c8b4 <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
200c8ec: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
020048b4 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
20048b4: 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) {
20048b8: 3b 00 80 4a sethi %hi(0x2012800), %i5
20048bc: c2 07 63 6c ld [ %i5 + 0x36c ], %g1 ! 2012b6c <rtems_current_user_env>
20048c0: 39 00 80 4a sethi %hi(0x2012800), %i4
20048c4: b8 17 23 70 or %i4, 0x370, %i4 ! 2012b70 <rtems_global_user_env>
20048c8: 80 a0 40 1c cmp %g1, %i4
20048cc: 02 80 00 08 be 20048ec <rtems_libio_use_global_env+0x38>
20048d0: 92 17 63 6c or %i5, 0x36c, %o1
sc = rtems_task_variable_delete(
20048d4: 40 00 06 52 call 200621c <rtems_task_variable_delete>
20048d8: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
20048dc: 80 a2 20 00 cmp %o0, 0
20048e0: 12 80 00 05 bne 20048f4 <rtems_libio_use_global_env+0x40> <== NEVER TAKEN
20048e4: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
}
rtems_current_user_env = &rtems_global_user_env;
20048e8: f8 27 63 6c st %i4, [ %i5 + 0x36c ]
20048ec: 81 c7 e0 08 ret
20048f0: 81 e8 00 00 restore
sc = rtems_task_variable_delete(
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
20048f4: 40 00 07 0c call 2006524 <rtems_fatal_error_occurred> <== NOT EXECUTED
20048f8: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
02007234 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
2007234: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
2007238: 03 00 80 8f sethi %hi(0x2023c00), %g1
200723c: d0 00 63 54 ld [ %g1 + 0x354 ], %o0 ! 2023f54 <RTEMS_Malloc_Heap>
2007240: 92 10 00 18 mov %i0, %o1
2007244: 40 00 1c ff call 200e640 <_Protected_heap_Get_block_size>
2007248: 94 07 bf fc add %fp, -4, %o2
200724c: 80 8a 20 ff btst 0xff, %o0
2007250: 02 80 00 08 be 2007270 <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
2007254: 03 00 80 94 sethi %hi(0x2025000), %g1
MSBUMP(lifetime_freed, size);
2007258: c8 07 bf fc ld [ %fp + -4 ], %g4
200725c: 82 10 62 d0 or %g1, 0x2d0, %g1
2007260: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
2007264: 86 80 c0 04 addcc %g3, %g4, %g3
2007268: 84 40 a0 00 addx %g2, 0, %g2
200726c: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
2007270: 81 c7 e0 08 ret
2007274: 81 e8 00 00 restore
02007278 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
2007278: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
200727c: 80 a6 20 00 cmp %i0, 0
2007280: 02 80 00 14 be 20072d0 <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
2007284: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
2007288: 03 00 80 8f sethi %hi(0x2023c00), %g1
200728c: d0 00 63 54 ld [ %g1 + 0x354 ], %o0 ! 2023f54 <RTEMS_Malloc_Heap>
2007290: 92 10 00 18 mov %i0, %o1
2007294: 40 00 1c eb call 200e640 <_Protected_heap_Get_block_size>
2007298: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
200729c: 03 00 80 94 sethi %hi(0x2025000), %g1
20072a0: f8 07 bf fc ld [ %fp + -4 ], %i4
20072a4: 82 10 62 d0 or %g1, 0x2d0, %g1
20072a8: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
20072ac: fa 00 60 2c ld [ %g1 + 0x2c ], %i5
if (current_depth > s->max_depth)
20072b0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
20072b4: 86 80 c0 1c addcc %g3, %i4, %g3
20072b8: 84 40 a0 00 addx %g2, 0, %g2
20072bc: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
20072c0: 84 20 c0 1d sub %g3, %i5, %g2
if (current_depth > s->max_depth)
20072c4: 80 a0 80 04 cmp %g2, %g4
20072c8: 38 80 00 02 bgu,a 20072d0 <rtems_malloc_statistics_at_malloc+0x58>
20072cc: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
20072d0: 81 c7 e0 08 ret
20072d4: 81 e8 00 00 restore
02010f48 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
2010f48: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
2010f4c: ba 96 20 00 orcc %i0, 0, %i5
2010f50: 02 80 00 21 be 2010fd4 <rtems_memalign+0x8c>
2010f54: 03 00 80 8b sethi %hi(0x2022c00), %g1
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2010f58: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 2022fc8 <_System_state_Current>
2010f5c: 80 a0 60 03 cmp %g1, 3
2010f60: 02 80 00 18 be 2010fc0 <rtems_memalign+0x78>
2010f64: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2010f68: 7f ff cf 4a call 2004c90 <malloc_deferred_frees_process>
2010f6c: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
2010f70: 03 00 80 87 sethi %hi(0x2021c00), %g1
2010f74: d0 00 61 e8 ld [ %g1 + 0x1e8 ], %o0 ! 2021de8 <RTEMS_Malloc_Heap>
2010f78: 92 10 00 1a mov %i2, %o1
2010f7c: 94 10 00 19 mov %i1, %o2
2010f80: 7f ff e7 c1 call 200ae84 <_Protected_heap_Allocate_aligned_with_boundary>
2010f84: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
2010f88: 80 a2 20 00 cmp %o0, 0
2010f8c: 02 80 00 14 be 2010fdc <rtems_memalign+0x94>
2010f90: b8 10 00 08 mov %o0, %i4
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
2010f94: 03 00 80 89 sethi %hi(0x2022400), %g1
2010f98: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 20225c0 <rtems_malloc_statistics_helpers>
2010f9c: 80 a0 60 00 cmp %g1, 0
2010fa0: 22 80 00 06 be,a 2010fb8 <rtems_memalign+0x70>
2010fa4: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
2010fa8: c2 00 60 04 ld [ %g1 + 4 ], %g1
2010fac: 9f c0 40 00 call %g1
2010fb0: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
2010fb4: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
2010fb8: 81 c7 e0 08 ret
2010fbc: 91 e8 20 00 restore %g0, 0, %o0
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
2010fc0: 7f ff cf 27 call 2004c5c <malloc_is_system_state_OK>
2010fc4: 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()) &&
2010fc8: 80 8a 20 ff btst 0xff, %o0
2010fcc: 12 bf ff e7 bne 2010f68 <rtems_memalign+0x20> <== ALWAYS TAKEN
2010fd0: 01 00 00 00 nop
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
2010fd4: 81 c7 e0 08 ret
2010fd8: 91 e8 20 16 restore %g0, 0x16, %o0
2010fdc: 81 c7 e0 08 ret
2010fe0: 81 e8 00 00 restore
02009cd0 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
2009cd0: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
2009cd4: 40 00 6d a8 call 2025374 <strdup>
2009cd8: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
2009cdc: b6 92 20 00 orcc %o0, 0, %i3
2009ce0: 02 80 00 69 be 2009e84 <rtems_mkdir+0x1b4>
2009ce4: 01 00 00 00 nop
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009ce8: c2 0e c0 00 ldub [ %i3 ], %g1
2009cec: 83 28 60 18 sll %g1, 0x18, %g1
2009cf0: 85 38 60 18 sra %g1, 0x18, %g2
2009cf4: 80 a0 a0 2f cmp %g2, 0x2f
2009cf8: 02 80 00 57 be 2009e54 <rtems_mkdir+0x184>
2009cfc: ba 10 00 1b mov %i3, %i5
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
2009d00: 83 38 60 18 sra %g1, 0x18, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009d04: b4 10 20 00 clr %i2
2009d08: 84 10 20 01 mov 1, %g2
retval = 0;
break;
}
}
if (!last)
*p = '/';
2009d0c: b0 10 20 2f mov 0x2f, %i0
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)) {
2009d10: 23 00 00 3c sethi %hi(0xf000), %l1
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
2009d14: 80 a0 60 00 cmp %g1, 0
2009d18: 02 80 00 0b be 2009d44 <rtems_mkdir+0x74> <== NEVER TAKEN
2009d1c: 21 00 00 10 sethi %hi(0x4000), %l0
last = 1;
else if (p[0] != '/')
2009d20: 80 a0 60 2f cmp %g1, 0x2f
2009d24: 22 80 00 2f be,a 2009de0 <rtems_mkdir+0x110>
2009d28: c2 4f 60 01 ldsb [ %i5 + 1 ], %g1
2009d2c: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
2009d30: 83 28 60 18 sll %g1, 0x18, %g1
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
2009d34: 83 38 60 18 sra %g1, 0x18, %g1
2009d38: 80 a0 60 00 cmp %g1, 0
2009d3c: 12 bf ff f9 bne 2009d20 <rtems_mkdir+0x50>
2009d40: ba 07 60 01 inc %i5
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
2009d44: c0 2f 40 00 clrb [ %i5 ]
2009d48: b8 10 20 01 mov 1, %i4
if (!last && p[1] == '\0')
last = 1;
if (first) {
2009d4c: 80 a0 a0 00 cmp %g2, 0
2009d50: 12 80 00 1d bne 2009dc4 <rtems_mkdir+0xf4>
2009d54: 01 00 00 00 nop
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
2009d58: 80 a7 20 00 cmp %i4, 0
2009d5c: 12 80 00 0a bne 2009d84 <rtems_mkdir+0xb4>
2009d60: 90 10 00 1b mov %i3, %o0
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
2009d64: 7f ff fc 82 call 2008f6c <mkdir>
2009d68: 92 10 21 ff mov 0x1ff, %o1
2009d6c: 80 a2 20 00 cmp %o0, 0
2009d70: 06 80 00 20 bl 2009df0 <rtems_mkdir+0x120>
2009d74: 01 00 00 00 nop
retval = 0;
break;
}
}
if (!last)
*p = '/';
2009d78: f0 2f 40 00 stb %i0, [ %i5 ]
2009d7c: 10 bf ff ec b 2009d2c <rtems_mkdir+0x5c>
2009d80: 84 10 20 00 clr %g2
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
2009d84: 40 00 0a b0 call 200c844 <umask>
2009d88: 90 10 00 1a mov %i2, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
2009d8c: 90 10 00 1b mov %i3, %o0
2009d90: 7f ff fc 77 call 2008f6c <mkdir>
2009d94: 92 10 00 19 mov %i1, %o1
2009d98: 80 a2 20 00 cmp %o0, 0
2009d9c: 06 80 00 15 bl 2009df0 <rtems_mkdir+0x120>
2009da0: 01 00 00 00 nop
2009da4: ba 10 20 01 mov 1, %i5 ! 1 <PROM_START+0x1>
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
2009da8: 7f ff fa 97 call 2008804 <free>
2009dac: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
2009db0: 80 a7 60 00 cmp %i5, 0
2009db4: 02 80 00 34 be 2009e84 <rtems_mkdir+0x1b4> <== NEVER TAKEN
2009db8: b0 10 20 00 clr %i0
}
2009dbc: 81 c7 e0 08 ret
2009dc0: 81 e8 00 00 restore
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
2009dc4: 40 00 0a a0 call 200c844 <umask>
2009dc8: 90 10 20 00 clr %o0
2009dcc: b4 10 00 08 mov %o0, %i2
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
2009dd0: 40 00 0a 9d call 200c844 <umask>
2009dd4: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
2009dd8: 10 bf ff e1 b 2009d5c <rtems_mkdir+0x8c>
2009ddc: 80 a7 20 00 cmp %i4, 0
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
2009de0: c0 2f 40 00 clrb [ %i5 ]
2009de4: 80 a0 00 01 cmp %g0, %g1
2009de8: 10 bf ff d9 b 2009d4c <rtems_mkdir+0x7c>
2009dec: b8 60 3f ff subx %g0, -1, %i4
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
2009df0: 40 00 65 1e call 2023268 <__errno>
2009df4: 01 00 00 00 nop
2009df8: c2 02 00 00 ld [ %o0 ], %g1
2009dfc: 80 a0 60 11 cmp %g1, 0x11
2009e00: 02 80 00 08 be 2009e20 <rtems_mkdir+0x150>
2009e04: 90 10 00 1b mov %i3, %o0
2009e08: 40 00 65 18 call 2023268 <__errno>
2009e0c: 01 00 00 00 nop
2009e10: c2 02 00 00 ld [ %o0 ], %g1
2009e14: 80 a0 60 15 cmp %g1, 0x15
2009e18: 12 80 00 28 bne 2009eb8 <rtems_mkdir+0x1e8> <== ALWAYS TAKEN
2009e1c: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
2009e20: 40 00 00 2a call 2009ec8 <stat>
2009e24: 92 07 bf b8 add %fp, -72, %o1
2009e28: 80 a2 20 00 cmp %o0, 0
2009e2c: 06 80 00 23 bl 2009eb8 <rtems_mkdir+0x1e8> <== NEVER TAKEN
2009e30: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
2009e34: 82 08 40 11 and %g1, %l1, %g1
2009e38: 80 a0 40 10 cmp %g1, %l0
2009e3c: 12 80 00 0a bne 2009e64 <rtems_mkdir+0x194>
2009e40: 80 a7 20 00 cmp %i4, 0
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
2009e44: 22 bf ff ce be,a 2009d7c <rtems_mkdir+0xac>
2009e48: f0 2f 40 00 stb %i0, [ %i5 ]
retval = 2;
2009e4c: 10 bf ff d7 b 2009da8 <rtems_mkdir+0xd8>
2009e50: ba 10 20 02 mov 2, %i5
2009e54: c2 0e e0 01 ldub [ %i3 + 1 ], %g1
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
2009e58: ba 06 e0 01 add %i3, 1, %i5
2009e5c: 10 bf ff a9 b 2009d00 <rtems_mkdir+0x30>
2009e60: 83 28 60 18 sll %g1, 0x18, %g1
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
2009e64: 02 80 00 0a be 2009e8c <rtems_mkdir+0x1bc>
2009e68: 01 00 00 00 nop
errno = EEXIST;
2009e6c: 40 00 64 ff call 2023268 <__errno>
2009e70: 01 00 00 00 nop
2009e74: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
2009e78: c2 22 00 00 st %g1, [ %o0 ]
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
2009e7c: 7f ff fa 62 call 2008804 <free>
2009e80: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
2009e84: 81 c7 e0 08 ret
2009e88: 91 e8 3f ff restore %g0, -1, %o0
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
2009e8c: 40 00 64 f7 call 2023268 <__errno>
2009e90: 01 00 00 00 nop
2009e94: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2009e98: c2 22 00 00 st %g1, [ %o0 ]
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
2009e9c: 40 00 0a 6a call 200c844 <umask>
2009ea0: 90 10 00 1a mov %i2, %o0
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
2009ea4: 90 10 00 1b mov %i3, %o0
2009ea8: 7f ff fa 57 call 2008804 <free>
2009eac: b0 10 3f ff mov -1, %i0
2009eb0: 81 c7 e0 08 ret
2009eb4: 81 e8 00 00 restore
}
}
if (!last)
*p = '/';
}
if (!first && !last)
2009eb8: 80 a7 20 00 cmp %i4, 0
2009ebc: 02 bf ff f8 be 2009e9c <rtems_mkdir+0x1cc> <== NEVER TAKEN
2009ec0: 90 10 00 1b mov %i3, %o0
2009ec4: 30 bf ff f9 b,a 2009ea8 <rtems_mkdir+0x1d8>
0200953c <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
200953c: 9d e3 bf a0 save %sp, -96, %sp
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
2009540: 80 a6 a0 00 cmp %i2, 0
2009544: 02 80 00 21 be 20095c8 <rtems_object_get_class_information+0x8c>
2009548: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
200954c: 93 2e 60 10 sll %i1, 0x10, %o1
2009550: 90 10 00 18 mov %i0, %o0
2009554: 40 00 07 cc call 200b484 <_Objects_Get_information>
2009558: 93 32 60 10 srl %o1, 0x10, %o1
if ( !obj_info )
200955c: 80 a2 20 00 cmp %o0, 0
2009560: 02 80 00 1a be 20095c8 <rtems_object_get_class_information+0x8c>
2009564: 82 10 20 0a mov 0xa, %g1
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
2009568: c8 12 20 10 lduh [ %o0 + 0x10 ], %g4
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
200956c: c6 02 20 08 ld [ %o0 + 8 ], %g3
info->maximum_id = obj_info->maximum_id;
2009570: c4 02 20 0c ld [ %o0 + 0xc ], %g2
info->auto_extend = obj_info->auto_extend;
2009574: c2 0a 20 12 ldub [ %o0 + 0x12 ], %g1
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
2009578: c6 26 80 00 st %g3, [ %i2 ]
info->maximum_id = obj_info->maximum_id;
200957c: c4 26 a0 04 st %g2, [ %i2 + 4 ]
info->auto_extend = obj_info->auto_extend;
2009580: c2 2e a0 0c stb %g1, [ %i2 + 0xc ]
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
2009584: 80 a1 20 00 cmp %g4, 0
2009588: 02 80 00 12 be 20095d0 <rtems_object_get_class_information+0x94><== NEVER TAKEN
200958c: c8 26 a0 08 st %g4, [ %i2 + 8 ]
2009590: fa 02 20 1c ld [ %o0 + 0x1c ], %i5
2009594: 86 10 20 01 mov 1, %g3
2009598: 82 10 20 01 mov 1, %g1
200959c: 84 10 20 00 clr %g2
if ( !obj_info->local_table[i] )
20095a0: 87 28 e0 02 sll %g3, 2, %g3
20095a4: c6 07 40 03 ld [ %i5 + %g3 ], %g3
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
20095a8: 82 00 60 01 inc %g1
if ( !obj_info->local_table[i] )
unallocated++;
20095ac: 80 a0 00 03 cmp %g0, %g3
20095b0: 84 60 bf ff subx %g2, -1, %g2
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
20095b4: 80 a1 00 01 cmp %g4, %g1
20095b8: 1a bf ff fa bcc 20095a0 <rtems_object_get_class_information+0x64>
20095bc: 86 10 00 01 mov %g1, %g3
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
20095c0: c4 26 a0 10 st %g2, [ %i2 + 0x10 ]
return RTEMS_SUCCESSFUL;
20095c4: 82 10 20 00 clr %g1
}
20095c8: 81 c7 e0 08 ret
20095cc: 91 e8 00 01 restore %g0, %g1, %o0
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
20095d0: 84 10 20 00 clr %g2 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
20095d4: 82 10 20 00 clr %g1 <== NOT EXECUTED
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
20095d8: 10 bf ff fc b 20095c8 <rtems_object_get_class_information+0x8c><== NOT EXECUTED
20095dc: c4 26 a0 10 st %g2, [ %i2 + 0x10 ] <== NOT EXECUTED
02008fd8 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
2008fd8: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
2008fdc: 80 a6 20 00 cmp %i0, 0
2008fe0: 12 80 00 04 bne 2008ff0 <rtems_partition_create+0x18>
2008fe4: 82 10 20 03 mov 3, %g1
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
2008fe8: 81 c7 e0 08 ret
2008fec: 91 e8 00 01 restore %g0, %g1, %o0
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
2008ff0: 80 a6 60 00 cmp %i1, 0
2008ff4: 02 bf ff fd be 2008fe8 <rtems_partition_create+0x10>
2008ff8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
2008ffc: 80 a7 60 00 cmp %i5, 0
2009000: 02 bf ff fa be 2008fe8 <rtems_partition_create+0x10> <== NEVER TAKEN
2009004: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
2009008: 02 bf ff f8 be 2008fe8 <rtems_partition_create+0x10>
200900c: 82 10 20 08 mov 8, %g1
2009010: 80 a6 a0 00 cmp %i2, 0
2009014: 02 bf ff f5 be 2008fe8 <rtems_partition_create+0x10>
2009018: 80 a6 80 1b cmp %i2, %i3
200901c: 0a bf ff f3 bcs 2008fe8 <rtems_partition_create+0x10>
2009020: 80 8e e0 07 btst 7, %i3
2009024: 12 bf ff f1 bne 2008fe8 <rtems_partition_create+0x10>
2009028: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
200902c: 12 bf ff ef bne 2008fe8 <rtems_partition_create+0x10>
2009030: 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)
{
uint32_t level = _Thread_Dispatch_disable_level;
2009034: 03 00 80 8b sethi %hi(0x2022c00), %g1
2009038: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 2022dd0 <_Thread_Dispatch_disable_level>
++level;
200903c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2009040: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
* 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 );
2009044: 23 00 80 8a sethi %hi(0x2022800), %l1
2009048: 40 00 07 6f call 200ae04 <_Objects_Allocate>
200904c: 90 14 63 cc or %l1, 0x3cc, %o0 ! 2022bcc <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
2009050: a0 92 20 00 orcc %o0, 0, %l0
2009054: 02 80 00 1a be 20090bc <rtems_partition_create+0xe4>
2009058: 92 10 00 1b mov %i3, %o1
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
200905c: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
2009060: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
2009064: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
2009068: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
200906c: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
2009070: 40 00 48 32 call 201b138 <.udiv>
2009074: 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,
2009078: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
200907c: 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,
2009080: 96 10 00 1b mov %i3, %o3
2009084: b8 04 20 24 add %l0, 0x24, %i4
2009088: 40 00 04 a5 call 200a31c <_Chain_Initialize>
200908c: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2009090: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2009094: a2 14 63 cc or %l1, 0x3cc, %l1
2009098: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
200909c: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20090a0: 85 28 a0 02 sll %g2, 2, %g2
20090a4: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
20090a8: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
20090ac: 40 00 0c d9 call 200c410 <_Thread_Enable_dispatch>
20090b0: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
20090b4: 10 bf ff cd b 2008fe8 <rtems_partition_create+0x10>
20090b8: 82 10 20 00 clr %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
20090bc: 40 00 0c d5 call 200c410 <_Thread_Enable_dispatch>
20090c0: 01 00 00 00 nop
return RTEMS_TOO_MANY;
20090c4: 10 bf ff c9 b 2008fe8 <rtems_partition_create+0x10>
20090c8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5>
020157b0 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
20157b0: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
20157b4: 11 00 80 f1 sethi %hi(0x203c400), %o0
20157b8: 92 10 00 18 mov %i0, %o1
20157bc: 90 12 23 2c or %o0, 0x32c, %o0
20157c0: 40 00 15 26 call 201ac58 <_Objects_Get>
20157c4: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
20157c8: c2 07 bf fc ld [ %fp + -4 ], %g1
20157cc: 80 a0 60 00 cmp %g1, 0
20157d0: 12 80 00 19 bne 2015834 <rtems_partition_return_buffer+0x84>
20157d4: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
20157d8: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
20157dc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
20157e0: 82 02 00 01 add %o0, %g1, %g1
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
20157e4: 80 a6 40 01 cmp %i1, %g1
20157e8: 18 80 00 15 bgu 201583c <rtems_partition_return_buffer+0x8c><== NEVER TAKEN
20157ec: 80 a6 40 08 cmp %i1, %o0
20157f0: 0a 80 00 13 bcs 201583c <rtems_partition_return_buffer+0x8c>
20157f4: 01 00 00 00 nop
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
20157f8: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
20157fc: 40 00 5a c2 call 202c304 <.urem>
2015800: 90 26 40 08 sub %i1, %o0, %o0
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
2015804: 80 a2 20 00 cmp %o0, 0
2015808: 12 80 00 0d bne 201583c <rtems_partition_return_buffer+0x8c>
201580c: 90 07 60 24 add %i5, 0x24, %o0
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
2015810: 40 00 0d 11 call 2018c54 <_Chain_Append>
2015814: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
2015818: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
201581c: b0 10 20 00 clr %i0
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
2015820: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
2015824: 40 00 19 27 call 201bcc0 <_Thread_Enable_dispatch>
2015828: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
201582c: 81 c7 e0 08 ret
2015830: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2015834: 81 c7 e0 08 ret
2015838: 91 e8 20 04 restore %g0, 4, %o0
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
201583c: 40 00 19 21 call 201bcc0 <_Thread_Enable_dispatch>
2015840: b0 10 20 09 mov 9, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2015844: 81 c7 e0 08 ret
2015848: 81 e8 00 00 restore
020381b4 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
20381b4: 9d e3 bf 98 save %sp, -104, %sp
20381b8: 11 00 81 9f sethi %hi(0x2067c00), %o0
20381bc: 92 10 00 18 mov %i0, %o1
20381c0: 90 12 22 44 or %o0, 0x244, %o0
20381c4: 7f ff 44 ae call 200947c <_Objects_Get>
20381c8: 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 ) {
20381cc: c2 07 bf fc ld [ %fp + -4 ], %g1
20381d0: 80 a0 60 00 cmp %g1, 0
20381d4: 12 80 00 0d bne 2038208 <rtems_rate_monotonic_period+0x54>
20381d8: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
20381dc: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
20381e0: 39 00 81 9e sethi %hi(0x2067800), %i4
20381e4: b8 17 20 80 or %i4, 0x80, %i4 ! 2067880 <_Per_CPU_Information>
20381e8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
20381ec: 80 a0 80 01 cmp %g2, %g1
20381f0: 02 80 00 08 be 2038210 <rtems_rate_monotonic_period+0x5c>
20381f4: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
20381f8: 7f ff 48 8f call 200a434 <_Thread_Enable_dispatch>
20381fc: b0 10 20 17 mov 0x17, %i0
2038200: 81 c7 e0 08 ret
2038204: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2038208: 81 c7 e0 08 ret
203820c: 91 e8 20 04 restore %g0, 4, %o0
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
2038210: 12 80 00 0e bne 2038248 <rtems_rate_monotonic_period+0x94>
2038214: 01 00 00 00 nop
switch ( the_period->state ) {
2038218: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
203821c: 80 a0 60 04 cmp %g1, 4
2038220: 18 80 00 06 bgu 2038238 <rtems_rate_monotonic_period+0x84><== NEVER TAKEN
2038224: b0 10 20 00 clr %i0
2038228: 83 28 60 02 sll %g1, 2, %g1
203822c: 05 00 81 84 sethi %hi(0x2061000), %g2
2038230: 84 10 a0 a8 or %g2, 0xa8, %g2 ! 20610a8 <CSWTCH.24>
2038234: f0 00 80 01 ld [ %g2 + %g1 ], %i0
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
2038238: 7f ff 48 7f call 200a434 <_Thread_Enable_dispatch>
203823c: 01 00 00 00 nop
2038240: 81 c7 e0 08 ret
2038244: 81 e8 00 00 restore
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
2038248: 7f ff 28 65 call 20023dc <sparc_disable_interrupts>
203824c: 01 00 00 00 nop
2038250: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
2038254: f6 07 60 38 ld [ %i5 + 0x38 ], %i3
2038258: 80 a6 e0 00 cmp %i3, 0
203825c: 02 80 00 1c be 20382cc <rtems_rate_monotonic_period+0x118>
2038260: 80 a6 e0 02 cmp %i3, 2
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
2038264: 02 80 00 2e be 203831c <rtems_rate_monotonic_period+0x168>
2038268: 80 a6 e0 04 cmp %i3, 4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
203826c: 12 bf ff e5 bne 2038200 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
2038270: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
2038274: 7f ff ff 5e call 2037fec <_Rate_monotonic_Update_statistics>
2038278: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
203827c: 7f ff 28 5c call 20023ec <sparc_enable_interrupts>
2038280: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
2038284: 82 10 20 02 mov 2, %g1
2038288: 92 07 60 10 add %i5, 0x10, %o1
203828c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
2038290: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2038294: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2038298: 11 00 81 9c sethi %hi(0x2067000), %o0
203829c: 7f ff 4b b8 call 200b17c <_Watchdog_Insert>
20382a0: 90 12 23 fc or %o0, 0x3fc, %o0 ! 20673fc <_Watchdog_Ticks_chain>
20382a4: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
20382a8: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
20382ac: 03 00 81 8c sethi %hi(0x2063000), %g1
20382b0: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 ! 2063024 <_Scheduler+0x34>
20382b4: 9f c0 40 00 call %g1
20382b8: 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();
20382bc: 7f ff 48 5e call 200a434 <_Thread_Enable_dispatch>
20382c0: 01 00 00 00 nop
20382c4: 81 c7 e0 08 ret
20382c8: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
20382cc: 7f ff 28 48 call 20023ec <sparc_enable_interrupts>
20382d0: 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 );
20382d4: 90 10 00 1d mov %i5, %o0
20382d8: 7f ff ff 94 call 2038128 <_Rate_monotonic_Initiate_statistics>
20382dc: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
20382e0: 82 10 20 02 mov 2, %g1
20382e4: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20382e8: 03 00 80 e0 sethi %hi(0x2038000), %g1
20382ec: 82 10 63 90 or %g1, 0x390, %g1 ! 2038390 <_Rate_monotonic_Timeout>
the_watchdog->id = id;
20382f0: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20382f4: 92 07 60 10 add %i5, 0x10, %o1
20382f8: 11 00 81 9c sethi %hi(0x2067000), %o0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20382fc: c0 27 60 18 clr [ %i5 + 0x18 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2038300: 90 12 23 fc or %o0, 0x3fc, %o0
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
2038304: c0 27 60 34 clr [ %i5 + 0x34 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2038308: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203830c: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2038310: 7f ff 4b 9b call 200b17c <_Watchdog_Insert>
2038314: b0 10 20 00 clr %i0
2038318: 30 bf ff c8 b,a 2038238 <rtems_rate_monotonic_period+0x84>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
203831c: 7f ff ff 34 call 2037fec <_Rate_monotonic_Update_statistics>
2038320: 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;
2038324: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
2038328: 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;
203832c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
2038330: 7f ff 28 2f call 20023ec <sparc_enable_interrupts>
2038334: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
2038338: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
203833c: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2038340: 90 10 00 01 mov %g1, %o0
2038344: 13 00 00 10 sethi %hi(0x4000), %o1
2038348: 7f ff 4a 9c call 200adb8 <_Thread_Set_state>
203834c: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
2038350: 7f ff 28 23 call 20023dc <sparc_disable_interrupts>
2038354: 01 00 00 00 nop
local_state = the_period->state;
2038358: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
203835c: f6 27 60 38 st %i3, [ %i5 + 0x38 ]
_ISR_Enable( level );
2038360: 7f ff 28 23 call 20023ec <sparc_enable_interrupts>
2038364: 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 )
2038368: 80 a6 a0 03 cmp %i2, 3
203836c: 22 80 00 06 be,a 2038384 <rtems_rate_monotonic_period+0x1d0>
2038370: d0 07 20 10 ld [ %i4 + 0x10 ], %o0
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
2038374: 7f ff 48 30 call 200a434 <_Thread_Enable_dispatch>
2038378: b0 10 20 00 clr %i0
203837c: 81 c7 e0 08 ret
2038380: 81 e8 00 00 restore
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2038384: 7f ff 47 27 call 200a020 <_Thread_Clear_state>
2038388: 13 00 00 10 sethi %hi(0x4000), %o1
203838c: 30 bf ff fa b,a 2038374 <rtems_rate_monotonic_period+0x1c0>
02029e4c <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2029e4c: 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 )
2029e50: 80 a6 60 00 cmp %i1, 0
2029e54: 02 80 00 48 be 2029f74 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
2029e58: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
2029e5c: 13 00 81 78 sethi %hi(0x205e000), %o1
2029e60: 9f c6 40 00 call %i1
2029e64: 92 12 63 88 or %o1, 0x388, %o1 ! 205e388 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
2029e68: 90 10 00 18 mov %i0, %o0
2029e6c: 13 00 81 78 sethi %hi(0x205e000), %o1
2029e70: 9f c6 40 00 call %i1
2029e74: 92 12 63 a8 or %o1, 0x3a8, %o1 ! 205e3a8 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
2029e78: 90 10 00 18 mov %i0, %o0
2029e7c: 13 00 81 78 sethi %hi(0x205e000), %o1
2029e80: 9f c6 40 00 call %i1
2029e84: 92 12 63 d0 or %o1, 0x3d0, %o1 ! 205e3d0 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
2029e88: 90 10 00 18 mov %i0, %o0
2029e8c: 13 00 81 78 sethi %hi(0x205e000), %o1
2029e90: 9f c6 40 00 call %i1
2029e94: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 205e3f8 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
2029e98: 90 10 00 18 mov %i0, %o0
2029e9c: 13 00 81 79 sethi %hi(0x205e400), %o1
2029ea0: 9f c6 40 00 call %i1
2029ea4: 92 12 60 48 or %o1, 0x48, %o1 ! 205e448 <_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 ;
2029ea8: 39 00 81 9f sethi %hi(0x2067c00), %i4
2029eac: b8 17 22 44 or %i4, 0x244, %i4 ! 2067e44 <_Rate_monotonic_Information>
2029eb0: fa 07 20 08 ld [ %i4 + 8 ], %i5
2029eb4: c2 07 20 0c ld [ %i4 + 0xc ], %g1
2029eb8: 80 a7 40 01 cmp %i5, %g1
2029ebc: 18 80 00 2e bgu 2029f74 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
2029ec0: 35 00 81 79 sethi %hi(0x205e400), %i2
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,
2029ec4: 27 00 81 79 sethi %hi(0x205e400), %l3
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,
2029ec8: 25 00 81 79 sethi %hi(0x205e400), %l2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
2029ecc: 37 00 81 7e sethi %hi(0x205f800), %i3
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2029ed0: b4 16 a0 98 or %i2, 0x98, %i2
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,
2029ed4: a6 14 e0 b0 or %l3, 0xb0, %l3
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,
2029ed8: a4 14 a0 d0 or %l2, 0xd0, %l2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
2029edc: 10 80 00 06 b 2029ef4 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8>
2029ee0: b6 16 e1 58 or %i3, 0x158, %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 ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
2029ee4: 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 ;
2029ee8: 80 a0 40 1d cmp %g1, %i5
2029eec: 0a 80 00 22 bcs 2029f74 <rtems_rate_monotonic_report_statistics_with_plugin+0x128>
2029ef0: 01 00 00 00 nop
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
2029ef4: 90 10 00 1d mov %i5, %o0
2029ef8: 40 00 37 59 call 2037c5c <rtems_rate_monotonic_get_statistics>
2029efc: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
2029f00: 80 a2 20 00 cmp %o0, 0
2029f04: 32 bf ff f8 bne,a 2029ee4 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
2029f08: c2 07 20 0c ld [ %i4 + 0xc ], %g1
#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 );
2029f0c: 92 07 bf b0 add %fp, -80, %o1
2029f10: 40 00 37 c5 call 2037e24 <rtems_rate_monotonic_get_status>
2029f14: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
2029f18: d0 07 bf b0 ld [ %fp + -80 ], %o0
2029f1c: 94 07 bf a0 add %fp, -96, %o2
2029f20: 7f ff 97 c1 call 200fe24 <rtems_object_get_name>
2029f24: 92 10 20 05 mov 5, %o1
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2029f28: d8 1f bf c8 ldd [ %fp + -56 ], %o4
2029f2c: 92 10 00 1a mov %i2, %o1
2029f30: 94 10 00 1d mov %i5, %o2
2029f34: 90 10 00 18 mov %i0, %o0
2029f38: 9f c6 40 00 call %i1
2029f3c: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
2029f40: c2 07 bf c8 ld [ %fp + -56 ], %g1
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 );
2029f44: 94 07 bf a8 add %fp, -88, %o2
2029f48: 90 07 bf e0 add %fp, -32, %o0
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
2029f4c: 80 a0 60 00 cmp %g1, 0
2029f50: 12 80 00 0b bne 2029f7c <rtems_rate_monotonic_report_statistics_with_plugin+0x130>
2029f54: 92 10 00 1b mov %i3, %o1
(*print)( context, "\n" );
2029f58: 9f c6 40 00 call %i1
2029f5c: 90 10 00 18 mov %i0, %o0
/*
* 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 ;
2029f60: c2 07 20 0c ld [ %i4 + 0xc ], %g1
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
2029f64: 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 ;
2029f68: 80 a0 40 1d cmp %g1, %i5
2029f6c: 1a bf ff e3 bcc 2029ef8 <rtems_rate_monotonic_report_statistics_with_plugin+0xac><== ALWAYS TAKEN
2029f70: 90 10 00 1d mov %i5, %o0
2029f74: 81 c7 e0 08 ret
2029f78: 81 e8 00 00 restore
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 );
2029f7c: 40 00 02 ee call 202ab34 <_Timespec_Divide_by_integer>
2029f80: 92 10 00 01 mov %g1, %o1
(*print)( context,
2029f84: d0 07 bf d4 ld [ %fp + -44 ], %o0
2029f88: 40 00 ac cb call 20552b4 <.div>
2029f8c: 92 10 23 e8 mov 0x3e8, %o1
2029f90: aa 10 00 08 mov %o0, %l5
2029f94: d0 07 bf dc ld [ %fp + -36 ], %o0
2029f98: 40 00 ac c7 call 20552b4 <.div>
2029f9c: 92 10 23 e8 mov 0x3e8, %o1
2029fa0: c2 07 bf a8 ld [ %fp + -88 ], %g1
2029fa4: a2 10 00 08 mov %o0, %l1
2029fa8: d0 07 bf ac ld [ %fp + -84 ], %o0
2029fac: e0 07 bf d0 ld [ %fp + -48 ], %l0
2029fb0: e8 07 bf d8 ld [ %fp + -40 ], %l4
2029fb4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2029fb8: 40 00 ac bf call 20552b4 <.div>
2029fbc: 92 10 23 e8 mov 0x3e8, %o1
2029fc0: 96 10 00 15 mov %l5, %o3
2029fc4: 98 10 00 14 mov %l4, %o4
2029fc8: 9a 10 00 11 mov %l1, %o5
2029fcc: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
2029fd0: 92 10 00 13 mov %l3, %o1
2029fd4: 94 10 00 10 mov %l0, %o2
2029fd8: 9f c6 40 00 call %i1
2029fdc: 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);
2029fe0: d2 07 bf c8 ld [ %fp + -56 ], %o1
2029fe4: 94 07 bf a8 add %fp, -88, %o2
2029fe8: 40 00 02 d3 call 202ab34 <_Timespec_Divide_by_integer>
2029fec: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
2029ff0: d0 07 bf ec ld [ %fp + -20 ], %o0
2029ff4: 40 00 ac b0 call 20552b4 <.div>
2029ff8: 92 10 23 e8 mov 0x3e8, %o1
2029ffc: a8 10 00 08 mov %o0, %l4
202a000: d0 07 bf f4 ld [ %fp + -12 ], %o0
202a004: 40 00 ac ac call 20552b4 <.div>
202a008: 92 10 23 e8 mov 0x3e8, %o1
202a00c: c2 07 bf a8 ld [ %fp + -88 ], %g1
202a010: a0 10 00 08 mov %o0, %l0
202a014: d0 07 bf ac ld [ %fp + -84 ], %o0
202a018: ea 07 bf e8 ld [ %fp + -24 ], %l5
202a01c: e2 07 bf f0 ld [ %fp + -16 ], %l1
202a020: 92 10 23 e8 mov 0x3e8, %o1
202a024: 40 00 ac a4 call 20552b4 <.div>
202a028: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
202a02c: 92 10 00 12 mov %l2, %o1
202a030: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
202a034: 94 10 00 15 mov %l5, %o2
202a038: 90 10 00 18 mov %i0, %o0
202a03c: 96 10 00 14 mov %l4, %o3
202a040: 98 10 00 11 mov %l1, %o4
202a044: 9f c6 40 00 call %i1
202a048: 9a 10 00 10 mov %l0, %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 ;
202a04c: 10 bf ff a6 b 2029ee4 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
202a050: c2 07 20 0c ld [ %i4 + 0xc ], %g1
0202a06c <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
202a06c: 9d e3 bf a0 save %sp, -96, %sp
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
202a070: 03 00 81 9c sethi %hi(0x2067000), %g1
202a074: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 2067360 <_Thread_Dispatch_disable_level>
++level;
202a078: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
202a07c: c4 20 63 60 st %g2, [ %g1 + 0x360 ]
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
202a080: 39 00 81 9f sethi %hi(0x2067c00), %i4
202a084: b8 17 22 44 or %i4, 0x244, %i4 ! 2067e44 <_Rate_monotonic_Information>
202a088: fa 07 20 08 ld [ %i4 + 8 ], %i5
202a08c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
202a090: 80 a7 40 01 cmp %i5, %g1
202a094: 18 80 00 09 bgu 202a0b8 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
202a098: 01 00 00 00 nop
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
202a09c: 40 00 00 09 call 202a0c0 <rtems_rate_monotonic_reset_statistics>
202a0a0: 90 10 00 1d mov %i5, %o0
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
202a0a4: c2 07 20 0c ld [ %i4 + 0xc ], %g1
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
202a0a8: ba 07 60 01 inc %i5
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
202a0ac: 80 a0 40 1d cmp %g1, %i5
202a0b0: 1a bf ff fb bcc 202a09c <rtems_rate_monotonic_reset_all_statistics+0x30>
202a0b4: 01 00 00 00 nop
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
202a0b8: 7f ff 80 df call 200a434 <_Thread_Enable_dispatch>
202a0bc: 81 e8 00 00 restore
02008e00 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
2008e00: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
2008e04: fa 06 20 30 ld [ %i0 + 0x30 ], %i5
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
2008e08: 90 10 00 19 mov %i1, %o0
2008e0c: 40 00 46 ab call 201a8b8 <.urem>
2008e10: 92 10 00 1d mov %i5, %o1
if (excess > 0) {
2008e14: 80 a2 20 00 cmp %o0, 0
2008e18: 02 80 00 26 be 2008eb0 <rtems_rbheap_allocate+0xb0> <== ALWAYS TAKEN
2008e1c: b6 10 00 19 mov %i1, %i3
value += alignment - excess;
2008e20: ba 06 40 1d add %i1, %i5, %i5 <== NOT EXECUTED
2008e24: b6 27 40 08 sub %i5, %o0, %i3 <== NOT EXECUTED
2008e28: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
2008e2c: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
2008e30: 80 88 60 ff btst 0xff, %g1
2008e34: 02 80 00 1d be 2008ea8 <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
2008e38: 80 a6 60 00 cmp %i1, 0
2008e3c: 02 80 00 1b be 2008ea8 <rtems_rbheap_allocate+0xa8>
2008e40: 82 06 20 04 add %i0, 4, %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2008e44: fa 06 00 00 ld [ %i0 ], %i5
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
2008e48: 80 a7 40 01 cmp %i5, %g1
2008e4c: 02 80 00 17 be 2008ea8 <rtems_rbheap_allocate+0xa8>
2008e50: 01 00 00 00 nop
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
2008e54: f8 07 60 1c ld [ %i5 + 0x1c ], %i4
2008e58: 80 a6 c0 1c cmp %i3, %i4
2008e5c: 38 80 00 10 bgu,a 2008e9c <rtems_rbheap_allocate+0x9c>
2008e60: fa 07 40 00 ld [ %i5 ], %i5
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
2008e64: 80 a7 60 00 cmp %i5, 0
2008e68: 02 80 00 10 be 2008ea8 <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
2008e6c: 80 a7 00 1b cmp %i4, %i3
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
2008e70: 18 80 00 12 bgu 2008eb8 <rtems_rbheap_allocate+0xb8>
2008e74: 01 00 00 00 nop
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2008e78: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
2008e7c: c2 07 60 04 ld [ %i5 + 4 ], %g1
ptr = (void *) new_chunk->begin;
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
2008e80: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
2008e84: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
2008e88: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008e8c: c0 27 60 04 clr [ %i5 + 4 ]
2008e90: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
2008e94: 81 c7 e0 08 ret
2008e98: 81 e8 00 00 restore
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
2008e9c: 80 a0 40 1d cmp %g1, %i5
2008ea0: 32 bf ff ee bne,a 2008e58 <rtems_rbheap_allocate+0x58> <== NEVER TAKEN
2008ea4: f8 07 60 1c ld [ %i5 + 0x1c ], %i4 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
2008ea8: 81 c7 e0 08 ret
2008eac: 91 e8 20 00 restore %g0, 0, %o0
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
2008eb0: 10 bf ff e0 b 2008e30 <rtems_rbheap_allocate+0x30>
2008eb4: 82 10 20 01 mov 1, %g1
if (free_chunk != NULL) {
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
rtems_rbheap_chunk *new_chunk = get_chunk(control);
2008eb8: 7f ff ff 46 call 2008bd0 <get_chunk>
2008ebc: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
2008ec0: b4 92 20 00 orcc %o0, 0, %i2
2008ec4: 02 bf ff f9 be 2008ea8 <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
2008ec8: b8 27 00 1b sub %i4, %i3, %i4
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
2008ecc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
2008ed0: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
2008ed4: f6 26 a0 1c st %i3, [ %i2 + 0x1c ]
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
2008ed8: b8 07 00 01 add %i4, %g1, %i4
2008edc: c0 26 a0 04 clr [ %i2 + 4 ]
2008ee0: f8 26 a0 18 st %i4, [ %i2 + 0x18 ]
2008ee4: c0 26 80 00 clr [ %i2 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
2008ee8: 90 06 20 18 add %i0, 0x18, %o0
2008eec: 40 00 07 1c call 200ab5c <_RBTree_Insert_unprotected>
2008ef0: 92 06 a0 08 add %i2, 8, %o1
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
2008ef4: f0 06 a0 18 ld [ %i2 + 0x18 ], %i0
2008ef8: 81 c7 e0 08 ret
2008efc: 81 e8 00 00 restore
02009044 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
2009044: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
2009048: 7f ff ec 47 call 2004164 <malloc> <== NOT EXECUTED
200904c: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
2009050: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2009054: 02 80 00 07 be 2009070 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
2009058: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200905c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
2009060: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2009064: c4 22 20 04 st %g2, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
2009068: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
200906c: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
2009070: 81 c7 e0 08 ret <== NOT EXECUTED
2009074: 81 e8 00 00 restore <== NOT EXECUTED
02008f00 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
2008f00: 9d e3 bf 80 save %sp, -128, %sp
2008f04: b4 10 00 18 mov %i0, %i2
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
2008f08: 80 a6 60 00 cmp %i1, 0
2008f0c: 02 80 00 2a be 2008fb4 <rtems_rbheap_free+0xb4>
2008f10: b0 10 20 00 clr %i0
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
2008f14: fa 06 a0 1c ld [ %i2 + 0x1c ], %i5
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
2008f18: c0 27 bf fc clr [ %fp + -4 ]
2008f1c: c0 27 bf e0 clr [ %fp + -32 ]
2008f20: c0 27 bf e4 clr [ %fp + -28 ]
2008f24: c0 27 bf e8 clr [ %fp + -24 ]
2008f28: c0 27 bf ec clr [ %fp + -20 ]
2008f2c: c0 27 bf f0 clr [ %fp + -16 ]
2008f30: c0 27 bf f4 clr [ %fp + -12 ]
2008f34: f2 27 bf f8 st %i1, [ %fp + -8 ]
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
2008f38: 80 a7 60 00 cmp %i5, 0
2008f3c: 02 80 00 3e be 2009034 <rtems_rbheap_free+0x134> <== NEVER TAKEN
2008f40: b8 06 a0 18 add %i2, 0x18, %i4
2008f44: b6 10 20 00 clr %i3
compare_result = the_rbtree->compare_function(the_node, iter_node);
2008f48: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
2008f4c: 92 10 00 1d mov %i5, %o1
2008f50: 9f c0 40 00 call %g1
2008f54: 90 07 bf e8 add %fp, -24, %o0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
2008f58: 83 3a 20 1f sra %o0, 0x1f, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
2008f5c: 80 a2 20 00 cmp %o0, 0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
2008f60: 82 20 40 08 sub %g1, %o0, %g1
2008f64: 83 30 60 1f srl %g1, 0x1f, %g1
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
2008f68: 83 28 60 02 sll %g1, 2, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
2008f6c: 12 80 00 06 bne 2008f84 <rtems_rbheap_free+0x84>
2008f70: 82 07 40 01 add %i5, %g1, %g1
found = iter_node;
if ( the_rbtree->is_unique )
2008f74: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
2008f78: 80 a0 a0 00 cmp %g2, 0
2008f7c: 12 80 00 10 bne 2008fbc <rtems_rbheap_free+0xbc> <== ALWAYS TAKEN
2008f80: b6 10 00 1d mov %i5, %i3
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
2008f84: fa 00 60 04 ld [ %g1 + 4 ], %i5
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
2008f88: 80 a7 60 00 cmp %i5, 0
2008f8c: 32 bf ff f0 bne,a 2008f4c <rtems_rbheap_free+0x4c>
2008f90: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
return rtems_rbheap_chunk_of_node(
2008f94: ba 06 ff f8 add %i3, -8, %i5
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
2008f98: 80 a7 7f f8 cmp %i5, -8
2008f9c: 02 80 00 06 be 2008fb4 <rtems_rbheap_free+0xb4>
2008fa0: 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);
2008fa4: c2 06 ff f8 ld [ %i3 + -8 ], %g1
2008fa8: 80 a0 60 00 cmp %g1, 0
2008fac: 02 80 00 06 be 2008fc4 <rtems_rbheap_free+0xc4>
2008fb0: b0 10 20 0e mov 0xe, %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
2008fb4: 81 c7 e0 08 ret
2008fb8: 81 e8 00 00 restore
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
return rtems_rbheap_chunk_of_node(
2008fbc: 10 bf ff f7 b 2008f98 <rtems_rbheap_free+0x98>
2008fc0: ba 06 ff f8 add %i3, -8, %i5
2008fc4: c2 06 ff fc ld [ %i3 + -4 ], %g1
2008fc8: 80 a0 60 00 cmp %g1, 0
2008fcc: 12 bf ff fa bne 2008fb4 <rtems_rbheap_free+0xb4> <== NEVER TAKEN
2008fd0: 92 10 20 00 clr %o1
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
2008fd4: 40 00 07 b1 call 200ae98 <_RBTree_Next_unprotected>
2008fd8: 90 10 00 1b mov %i3, %o0
2008fdc: 92 10 20 01 mov 1, %o1
2008fe0: b2 10 00 08 mov %o0, %i1
2008fe4: 40 00 07 ad call 200ae98 <_RBTree_Next_unprotected>
2008fe8: 90 10 00 1b mov %i3, %o0
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
2008fec: 92 10 00 1c mov %i4, %o1
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
2008ff0: 96 02 3f f8 add %o0, -8, %o3
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
2008ff4: 94 10 00 1d mov %i5, %o2
2008ff8: 7f ff ff 10 call 2008c38 <check_and_merge>
2008ffc: 90 10 00 1a mov %i2, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2009000: c2 06 80 00 ld [ %i2 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2009004: f4 26 ff fc st %i2, [ %i3 + -4 ]
before_node = after_node->next;
after_node->next = the_node;
2009008: fa 26 80 00 st %i5, [ %i2 ]
the_node->next = before_node;
200900c: c2 26 ff f8 st %g1, [ %i3 + -8 ]
before_node->previous = the_node;
2009010: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
2009014: 90 10 00 1a mov %i2, %o0
2009018: 92 10 00 1c mov %i4, %o1
200901c: 94 10 00 1d mov %i5, %o2
2009020: 96 06 7f f8 add %i1, -8, %o3
2009024: 7f ff ff 05 call 2008c38 <check_and_merge>
2009028: b0 10 20 00 clr %i0
200902c: 81 c7 e0 08 ret
2009030: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
2009034: 81 c7 e0 08 ret <== NOT EXECUTED
2009038: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
02008cd0 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
2008cd0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
2008cd4: 80 a6 e0 00 cmp %i3, 0
2008cd8: 12 80 00 04 bne 2008ce8 <rtems_rbheap_initialize+0x18>
2008cdc: 82 10 20 0a mov 0xa, %g1
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
2008ce0: 81 c7 e0 08 ret
2008ce4: 91 e8 00 01 restore %g0, %g1, %o0
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
2008ce8: 90 10 00 19 mov %i1, %o0
2008cec: 92 10 00 1b mov %i3, %o1
2008cf0: 40 00 46 f2 call 201a8b8 <.urem>
2008cf4: b4 06 40 1a add %i1, %i2, %i2
if (excess > 0) {
2008cf8: 80 a2 20 00 cmp %o0, 0
2008cfc: 32 80 00 09 bne,a 2008d20 <rtems_rbheap_initialize+0x50>
2008d00: a0 06 40 1b add %i1, %i3, %l0
2008d04: 82 10 20 01 mov 1, %g1
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
2008d08: 80 88 60 ff btst 0xff, %g1
2008d0c: 12 80 00 0b bne 2008d38 <rtems_rbheap_initialize+0x68> <== ALWAYS TAKEN
2008d10: a0 10 00 19 mov %i1, %l0
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
2008d14: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
2008d18: 81 c7 e0 08 ret
2008d1c: 91 e8 00 01 restore %g0, %g1, %o0
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
value += alignment - excess;
2008d20: a0 24 00 08 sub %l0, %o0, %l0
2008d24: 80 a4 00 19 cmp %l0, %i1
2008d28: 82 60 3f ff subx %g0, -1, %g1
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
2008d2c: 80 88 60 ff btst 0xff, %g1
2008d30: 02 bf ff fa be 2008d18 <rtems_rbheap_initialize+0x48>
2008d34: 82 10 20 09 mov 9, %g1
2008d38: 80 a6 40 1a cmp %i1, %i2
2008d3c: 1a bf ff f7 bcc 2008d18 <rtems_rbheap_initialize+0x48>
2008d40: 82 10 20 09 mov 9, %g1
return value;
}
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
2008d44: 90 10 00 1a mov %i2, %o0
2008d48: 40 00 46 dc call 201a8b8 <.urem>
2008d4c: 92 10 00 1b mov %i3, %o1
return value - excess;
2008d50: b4 26 80 08 sub %i2, %o0, %i2
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
2008d54: 80 a4 00 1a cmp %l0, %i2
2008d58: 1a bf ff e2 bcc 2008ce0 <rtems_rbheap_initialize+0x10>
2008d5c: 82 10 20 09 mov 9, %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 );
2008d60: 82 06 20 04 add %i0, 4, %g1
head->next = tail;
2008d64: c2 26 00 00 st %g1, [ %i0 ]
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 );
2008d68: 82 06 20 0c add %i0, 0xc, %g1
head->next = tail;
head->previous = NULL;
tail->previous = head;
2008d6c: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
the_rbtree->is_unique = is_unique;
2008d70: 82 10 20 01 mov 1, %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 );
2008d74: 84 06 20 10 add %i0, 0x10, %g2
2008d78: c2 2e 20 2c stb %g1, [ %i0 + 0x2c ]
{
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
2008d7c: 03 00 80 22 sethi %hi(0x2008800), %g1
2008d80: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 2008bc0 <chunk_compare>
head->next = tail;
head->previous = NULL;
2008d84: c0 26 20 04 clr [ %i0 + 4 ]
2008d88: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
tail->previous = head;
2008d8c: f0 26 20 08 st %i0, [ %i0 + 8 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
2008d90: c0 26 20 10 clr [ %i0 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2008d94: c4 26 20 0c st %g2, [ %i0 + 0xc ]
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
2008d98: c0 26 20 18 clr [ %i0 + 0x18 ]
the_rbtree->root = NULL;
2008d9c: c0 26 20 1c clr [ %i0 + 0x1c ]
the_rbtree->first[0] = NULL;
2008da0: c0 26 20 20 clr [ %i0 + 0x20 ]
the_rbtree->first[1] = NULL;
2008da4: c0 26 20 24 clr [ %i0 + 0x24 ]
rtems_rbheap_chunk *first = NULL;
rtems_chain_initialize_empty(free_chain);
rtems_chain_initialize_empty(&control->spare_descriptor_chain);
rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true);
control->alignment = alignment;
2008da8: f6 26 20 30 st %i3, [ %i0 + 0x30 ]
control->handler_arg = handler_arg;
2008dac: fa 26 20 38 st %i5, [ %i0 + 0x38 ]
control->extend_descriptors = extend_descriptors;
2008db0: f8 26 20 34 st %i4, [ %i0 + 0x34 ]
first = get_chunk(control);
2008db4: 7f ff ff 87 call 2008bd0 <get_chunk>
2008db8: 90 10 00 18 mov %i0, %o0
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
add_to_chain(free_chain, first);
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
2008dbc: 82 10 20 1a mov 0x1a, %g1
control->alignment = alignment;
control->handler_arg = handler_arg;
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
2008dc0: 80 a2 20 00 cmp %o0, 0
2008dc4: 02 bf ff c7 be 2008ce0 <rtems_rbheap_initialize+0x10>
2008dc8: 92 10 00 08 mov %o0, %o1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2008dcc: c2 06 00 00 ld [ %i0 ], %g1
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
2008dd0: b4 26 80 10 sub %i2, %l0, %i2
control->handler_arg = handler_arg;
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
first->begin = aligned_begin;
2008dd4: e0 22 20 18 st %l0, [ %o0 + 0x18 ]
first->size = aligned_end - aligned_begin;
2008dd8: f4 22 20 1c st %i2, [ %o0 + 0x1c ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008ddc: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
2008de0: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
2008de4: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
2008de8: d0 20 60 04 st %o0, [ %g1 + 4 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
2008dec: 92 02 60 08 add %o1, 8, %o1
2008df0: 40 00 07 5b call 200ab5c <_RBTree_Insert_unprotected>
2008df4: 90 06 20 18 add %i0, 0x18, %o0
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
2008df8: 10 bf ff ba b 2008ce0 <rtems_rbheap_initialize+0x10>
2008dfc: 82 10 20 00 clr %g1
0201ba6c <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
201ba6c: 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);
201ba70: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
201ba74: ba 10 00 18 mov %i0, %i5
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
201ba78: 7f ff fe 32 call 201b340 <rtems_rfs_bitmap_load_map>
201ba7c: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
201ba80: b0 92 20 00 orcc %o0, 0, %i0
201ba84: 24 80 00 04 ble,a 201ba94 <rtems_rfs_bitmap_create_search+0x28>
201ba88: de 07 60 14 ld [ %i5 + 0x14 ], %o7
bit++;
map++;
}
return 0;
}
201ba8c: 81 c7 e0 08 ret
201ba90: 81 e8 00 00 restore
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
201ba94: f8 07 60 0c ld [ %i5 + 0xc ], %i4
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
201ba98: c0 27 60 10 clr [ %i5 + 0x10 ]
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
201ba9c: 82 10 3f ff mov -1, %g1
201baa0: c2 23 c0 00 st %g1, [ %o7 ]
201baa4: f4 07 bf fc ld [ %fp + -4 ], %i2
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
201baa8: b2 10 20 00 clr %i1
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);
201baac: 98 10 20 20 mov 0x20, %o4
201bab0: 9a 10 3f ff mov -1, %o5
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
201bab4: 80 a7 20 00 cmp %i4, 0
201bab8: 02 80 00 20 be 201bb38 <rtems_rfs_bitmap_create_search+0xcc><== NEVER TAKEN
201babc: b6 10 20 01 mov 1, %i3
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
201bac0: 80 a7 20 1f cmp %i4, 0x1f
201bac4: 38 80 00 1f bgu,a 201bb40 <rtems_rfs_bitmap_create_search+0xd4>
201bac8: c6 06 80 00 ld [ %i2 ], %g3
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
201bacc: c2 06 80 00 ld [ %i2 ], %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);
201bad0: 86 23 00 1c sub %o4, %i4, %g3
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;
201bad4: 88 10 00 1c mov %i4, %g4
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);
201bad8: 87 33 40 03 srl %o5, %g3, %g3
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;
201badc: b0 10 00 1c mov %i4, %i0
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
201bae0: 86 08 c0 01 and %g3, %g1, %g3
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
201bae4: 80 a0 e0 00 cmp %g3, 0
201bae8: 02 80 00 0e be 201bb20 <rtems_rfs_bitmap_create_search+0xb4>
201baec: 80 a6 60 20 cmp %i1, 0x20
201baf0: 82 10 20 00 clr %g1
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
201baf4: 85 2e c0 01 sll %i3, %g1, %g2
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
201baf8: 80 88 80 03 btst %g2, %g3
201bafc: 02 80 00 05 be 201bb10 <rtems_rfs_bitmap_create_search+0xa4>
201bb00: 82 00 60 01 inc %g1
control->free++;
201bb04: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
201bb08: 84 00 a0 01 inc %g2
201bb0c: c4 27 60 10 st %g2, [ %i5 + 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++)
201bb10: 80 a1 00 01 cmp %g4, %g1
201bb14: 14 bf ff f9 bg 201baf8 <rtems_rfs_bitmap_create_search+0x8c>
201bb18: 85 2e c0 01 sll %i3, %g1, %g2
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
201bb1c: 80 a6 60 20 cmp %i1, 0x20
201bb20: 02 80 00 0b be 201bb4c <rtems_rfs_bitmap_create_search+0xe0>
201bb24: b8 27 00 18 sub %i4, %i0, %i4
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
201bb28: b2 06 60 01 inc %i1
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
201bb2c: 80 a7 20 00 cmp %i4, 0
201bb30: 12 bf ff e4 bne 201bac0 <rtems_rfs_bitmap_create_search+0x54>
201bb34: b4 06 a0 04 add %i2, 4, %i2
else
bit++;
map++;
}
return 0;
201bb38: 81 c7 e0 08 ret
201bb3c: 91 e8 20 00 restore %g0, 0, %o0
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
201bb40: b0 10 20 20 mov 0x20, %i0
available = rtems_rfs_bitmap_element_bits ();
201bb44: 10 bf ff e8 b 201bae4 <rtems_rfs_bitmap_create_search+0x78>
201bb48: 88 10 20 20 mov 0x20, %g4
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
201bb4c: 82 10 3f ff mov -1, %g1
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
201bb50: b2 10 20 00 clr %i1
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
201bb54: c2 23 e0 04 st %g1, [ %o7 + 4 ]
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
201bb58: 10 bf ff f5 b 201bb2c <rtems_rfs_bitmap_create_search+0xc0>
201bb5c: 9e 03 e0 04 add %o7, 4, %o7
0201b340 <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)
{
201b340: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
201b344: c2 06 00 00 ld [ %i0 ], %g1
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
201b348: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
201b34c: 80 a0 60 00 cmp %g1, 0
201b350: 02 80 00 0f be 201b38c <rtems_rfs_bitmap_load_map+0x4c>
201b354: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
201b358: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
201b35c: d4 07 60 08 ld [ %i5 + 8 ], %o2
201b360: d0 07 60 04 ld [ %i5 + 4 ], %o0
201b364: d2 07 40 00 ld [ %i5 ], %o1
201b368: 40 00 07 11 call 201cfac <rtems_rfs_buffer_handle_request>
201b36c: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
201b370: b0 92 20 00 orcc %o0, 0, %i0
201b374: 12 80 00 06 bne 201b38c <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
201b378: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
201b37c: c2 07 40 00 ld [ %i5 ], %g1
201b380: c2 00 60 08 ld [ %g1 + 8 ], %g1
201b384: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201b388: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
201b38c: 81 c7 e0 08 ret
201b390: 81 e8 00 00 restore
0201b984 <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)
{
201b984: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
201b988: c0 2e 80 00 clrb [ %i2 ]
* of bits from the original seed above then below. That is search from the
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
201b98c: ba 10 00 19 mov %i1, %i5
* 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))
201b990: 80 a7 60 00 cmp %i5, 0
201b994: 06 80 00 1f bl 201ba10 <rtems_rfs_bitmap_map_alloc+0x8c>
201b998: 80 a6 60 00 cmp %i1, 0
201b99c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
201b9a0: 80 a7 40 01 cmp %i5, %g1
201b9a4: 1a 80 00 1b bcc 201ba10 <rtems_rfs_bitmap_map_alloc+0x8c>
201b9a8: 80 a6 60 00 cmp %i1, 0
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
201b9ac: fa 26 c0 00 st %i5, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
201b9b0: 90 10 00 18 mov %i0, %o0
201b9b4: 92 10 00 1b mov %i3, %o1
201b9b8: 94 10 00 1a mov %i2, %o2
201b9bc: 7f ff fe 76 call 201b394 <rtems_rfs_search_map_for_clear_bit.constprop.1>
201b9c0: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
201b9c4: 80 a2 20 00 cmp %o0, 0
201b9c8: 14 80 00 27 bg 201ba64 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
201b9cc: 01 00 00 00 nop
201b9d0: c2 0e 80 00 ldub [ %i2 ], %g1
201b9d4: 80 a0 60 00 cmp %g1, 0
201b9d8: 12 80 00 23 bne 201ba64 <rtems_rfs_bitmap_map_alloc+0xe0>
201b9dc: 80 a6 60 00 cmp %i1, 0
break;
}
if (lower_seed >= 0)
201b9e0: 36 80 00 15 bge,a 201ba34 <rtems_rfs_bitmap_map_alloc+0xb0>
201b9e4: f2 26 c0 00 st %i1, [ %i3 ]
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
201b9e8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
201b9ec: 80 a0 40 1d cmp %g1, %i5
201b9f0: 38 80 00 02 bgu,a 201b9f8 <rtems_rfs_bitmap_map_alloc+0x74>
201b9f4: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
201b9f8: 80 a6 60 00 cmp %i1, 0
201b9fc: 06 bf ff e5 bl 201b990 <rtems_rfs_bitmap_map_alloc+0xc>
201ba00: 80 a7 60 00 cmp %i5, 0
* 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))
201ba04: 16 bf ff e6 bge 201b99c <rtems_rfs_bitmap_map_alloc+0x18> <== ALWAYS TAKEN
201ba08: b2 06 78 00 add %i1, -2048, %i1
|| ((lower_seed >= 0) && (lower_seed < control->size)))
201ba0c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
201ba10: 06 80 00 15 bl 201ba64 <rtems_rfs_bitmap_map_alloc+0xe0>
201ba14: 01 00 00 00 nop
201ba18: c2 06 20 0c ld [ %i0 + 0xc ], %g1
201ba1c: 80 a6 40 01 cmp %i1, %g1
201ba20: 1a 80 00 11 bcc 201ba64 <rtems_rfs_bitmap_map_alloc+0xe0>
201ba24: 80 a0 40 1d cmp %g1, %i5
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
201ba28: 38 bf ff e2 bgu,a 201b9b0 <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
201ba2c: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
break;
}
if (lower_seed >= 0)
{
*bit = lower_seed;
201ba30: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
201ba34: 90 10 00 18 mov %i0, %o0
201ba38: 92 10 00 1b mov %i3, %o1
201ba3c: 94 10 00 1a mov %i2, %o2
201ba40: 7f ff fe 55 call 201b394 <rtems_rfs_search_map_for_clear_bit.constprop.1>
201ba44: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
201ba48: 80 a2 20 00 cmp %o0, 0
201ba4c: 14 80 00 06 bg 201ba64 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
201ba50: 01 00 00 00 nop
201ba54: c2 0e 80 00 ldub [ %i2 ], %g1
201ba58: 80 a0 60 00 cmp %g1, 0
201ba5c: 22 bf ff e4 be,a 201b9ec <rtems_rfs_bitmap_map_alloc+0x68>
201ba60: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
201ba64: 81 c7 e0 08 ret
201ba68: 91 e8 20 00 restore %g0, 0, %o0
0201b66c <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
201b66c: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
201b670: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
201b674: 81 c3 e0 08 retl <== NOT EXECUTED
201b678: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
0201b67c <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
201b67c: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
rtems_rfs_bitmap_element mask = 0;
if (end > start)
201b680: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
201b684: 08 80 00 06 bleu 201b69c <rtems_rfs_bitmap_mask_section+0x20><== NOT EXECUTED
201b688: 90 10 20 00 clr %o0 <== 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);
201b68c: 92 20 40 09 sub %g1, %o1, %o1 <== NOT EXECUTED
201b690: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
201b694: 91 32 00 09 srl %o0, %o1, %o0 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
201b698: 91 2a 00 01 sll %o0, %g1, %o0 <== NOT EXECUTED
return mask;
}
201b69c: 81 c3 e0 08 retl <== NOT EXECUTED
0201bdbc <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)
{
201bdbc: 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);
201bdc0: 96 10 20 01 mov 1, %o3
201bdc4: 90 10 00 18 mov %i0, %o0
201bdc8: 92 10 00 19 mov %i1, %o1
201bdcc: 40 00 04 78 call 201cfac <rtems_rfs_buffer_handle_request>
201bdd0: 94 10 00 1a mov %i2, %o2
if (rc > 0)
201bdd4: 80 a2 20 00 cmp %o0, 0
201bdd8: 24 80 00 04 ble,a 201bde8 <rtems_rfs_block_find_indirect+0x2c><== ALWAYS TAKEN
201bddc: c4 06 60 08 ld [ %i1 + 8 ], %g2
*result = 0;
rc = EIO;
}
return 0;
}
201bde0: 81 c7 e0 08 ret
201bde4: 91 e8 00 08 restore %g0, %o0, %o0
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
201bde8: 83 2e e0 02 sll %i3, 2, %g1
201bdec: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
201bdf0: c8 06 20 04 ld [ %i0 + 4 ], %g4
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
201bdf4: fa 08 c0 01 ldub [ %g3 + %g1 ], %i5
201bdf8: 84 00 c0 01 add %g3, %g1, %g2
201bdfc: c2 08 a0 03 ldub [ %g2 + 3 ], %g1
201be00: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
201be04: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
201be08: bb 2f 60 18 sll %i5, 0x18, %i5
201be0c: 85 28 a0 08 sll %g2, 8, %g2
201be10: 87 28 e0 10 sll %g3, 0x10, %g3
201be14: 82 10 40 1d or %g1, %i5, %g1
201be18: 82 10 40 03 or %g1, %g3, %g1
201be1c: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
201be20: 84 38 00 01 xnor %g0, %g1, %g2
201be24: 80 a0 00 02 cmp %g0, %g2
201be28: 84 60 20 00 subx %g0, 0, %g2
201be2c: 82 08 40 02 and %g1, %g2, %g1
201be30: c2 27 00 00 st %g1, [ %i4 ]
if (*result >= rtems_rfs_fs_blocks (fs))
201be34: 80 a1 00 01 cmp %g4, %g1
201be38: 18 bf ff ea bgu 201bde0 <rtems_rfs_block_find_indirect+0x24><== ALWAYS TAKEN
201be3c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
201be40: 90 10 20 00 clr %o0 <== NOT EXECUTED
201be44: 7f ff e2 fc call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201be48: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
201be4c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201be50: 32 80 00 06 bne,a 201be68 <rtems_rfs_block_find_indirect+0xac><== NOT EXECUTED
201be54: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
201be58: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
201be5c: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
201be60: 81 c7 e0 08 ret <== NOT EXECUTED
201be64: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
printf ("rtems-rfs: block-find: invalid block in table:"
201be68: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201be6c: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201be70: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
201be74: 40 00 22 8e call 20248ac <printf> <== NOT EXECUTED
201be78: 90 12 21 58 or %o0, 0x158, %o0 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
201be7c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201be80: 10 bf ff f8 b 201be60 <rtems_rfs_block_find_indirect+0xa4><== NOT EXECUTED
201be84: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
0201bee8 <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)
{
201bee8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
201beec: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
201bef0: 02 80 00 11 be 201bf34 <rtems_rfs_block_get_block_size+0x4c><== NOT EXECUTED
201bef4: 94 10 20 00 clr %o2 <== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
201bef8: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
201befc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
201bf00: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
201bf04: 40 00 55 86 call 203151c <__udivdi3> <== NOT EXECUTED
201bf08: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201bf0c: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
201bf10: 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;
201bf14: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
201bf18: 94 10 20 00 clr %o2 <== NOT EXECUTED
201bf1c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201bf20: 40 00 56 53 call 203186c <__umoddi3> <== NOT EXECUTED
201bf24: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
201bf28: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
201bf2c: 81 c7 e0 08 ret <== NOT EXECUTED
201bf30: 81 e8 00 00 restore <== 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;
201bf34: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
201bf38: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
201bf3c: 81 c7 e0 08 ret <== NOT EXECUTED
201bf40: 81 e8 00 00 restore <== NOT EXECUTED
0201c120 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
201c120: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
201c124: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
201c128: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
201c12c: 80 a0 60 00 cmp %g1, 0
201c130: 02 80 00 0b be 201c15c <rtems_rfs_block_map_close+0x3c>
201c134: b0 10 20 00 clr %i0
201c138: d2 06 60 04 ld [ %i1 + 4 ], %o1
201c13c: 80 a2 60 00 cmp %o1, 0
201c140: 22 80 00 08 be,a 201c160 <rtems_rfs_block_map_close+0x40><== NEVER TAKEN
201c144: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
201c148: 7f ff db 67 call 2012ee4 <rtems_rfs_inode_load>
201c14c: 90 10 00 1d mov %i5, %o0
if (brc > 0)
201c150: b0 92 20 00 orcc %o0, 0, %i0
201c154: 04 80 00 11 ble 201c198 <rtems_rfs_block_map_close+0x78> <== ALWAYS TAKEN
201c158: b8 10 00 19 mov %i1, %i4
*/
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);
201c15c: 92 06 60 38 add %i1, 0x38, %o1
map->dirty = false;
}
}
map->inode = NULL;
201c160: c0 26 60 04 clr [ %i1 + 4 ]
201c164: 40 00 03 18 call 201cdc4 <rtems_rfs_buffer_handle_release>
201c168: 90 10 00 1d mov %i5, %o0
201c16c: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
201c170: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
201c174: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
201c178: 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);
201c17c: 40 00 03 12 call 201cdc4 <rtems_rfs_buffer_handle_release>
201c180: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
201c184: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
201c188: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
201c18c: 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;
}
201c190: 81 c7 e0 08 ret
201c194: 81 e8 00 00 restore
int brc;
if (map->dirty && map->inode)
{
brc = rtems_rfs_inode_load (fs, map->inode);
if (brc > 0)
201c198: 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);
201c19c: 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]);
201c1a0: c2 06 60 04 ld [ %i1 + 4 ], %g1
201c1a4: c4 07 20 24 ld [ %i4 + 0x24 ], %g2
* @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);
201c1a8: f6 00 60 0c ld [ %g1 + 0xc ], %i3
201c1ac: 86 01 20 06 add %g4, 6, %g3
201c1b0: 87 28 e0 02 sll %g3, 2, %g3
201c1b4: b6 06 c0 03 add %i3, %g3, %i3
201c1b8: b5 30 a0 18 srl %g2, 0x18, %i2
201c1bc: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
201c1c0: f6 00 60 0c ld [ %g1 + 0xc ], %i3
201c1c4: b5 30 a0 10 srl %g2, 0x10, %i2
201c1c8: b6 06 c0 03 add %i3, %g3, %i3
201c1cc: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
201c1d0: f6 00 60 0c ld [ %g1 + 0xc ], %i3
201c1d4: b5 30 a0 08 srl %g2, 8, %i2
201c1d8: b6 06 c0 03 add %i3, %g3, %i3
201c1dc: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
201c1e0: f6 00 60 0c ld [ %g1 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201c1e4: 88 01 20 01 inc %g4
201c1e8: 86 06 c0 03 add %i3, %g3, %g3
201c1ec: c4 28 e0 07 stb %g2, [ %g3 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201c1f0: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
201c1f4: b8 07 20 04 add %i4, 4, %i4
201c1f8: 80 a1 20 05 cmp %g4, 5
201c1fc: 12 bf ff e9 bne 201c1a0 <rtems_rfs_block_map_close+0x80>
201c200: 82 10 20 01 mov 1, %g1
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
201c204: c4 06 60 04 ld [ %i1 + 4 ], %g2
201c208: c6 06 60 08 ld [ %i1 + 8 ], %g3
* @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);
201c20c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
201c210: b9 30 e0 18 srl %g3, 0x18, %i4
201c214: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
201c218: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
201c21c: b9 30 e0 10 srl %g3, 0x10, %i4
201c220: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
201c224: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
201c228: b9 30 e0 08 srl %g3, 8, %i4
201c22c: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
201c230: c8 00 a0 0c ld [ %g2 + 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);
201c234: 90 10 00 1d mov %i5, %o0
201c238: c6 29 20 0f stb %g3, [ %g4 + 0xf ]
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);
201c23c: c8 06 60 04 ld [ %i1 + 4 ], %g4
*/
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);
201c240: f6 0e 60 0e ldub [ %i1 + 0xe ], %i3
201c244: f8 01 20 0c ld [ %g4 + 0xc ], %i4
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201c248: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*/
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);
201c24c: c6 06 60 0c ld [ %i1 + 0xc ], %g3
201c250: f6 2f 20 0a stb %i3, [ %i4 + 0xa ]
201c254: c4 01 20 0c ld [ %g4 + 0xc ], %g2
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
201c258: 94 10 20 01 mov 1, %o2
201c25c: c6 28 a0 0b stb %g3, [ %g2 + 0xb ]
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);
201c260: c6 06 60 04 ld [ %i1 + 4 ], %g3
201c264: 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);
201c268: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201c26c: c2 29 20 10 stb %g1, [ %g4 + 0x10 ]
* @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);
201c270: 89 30 a0 18 srl %g2, 0x18, %g4
201c274: c8 2f 20 30 stb %g4, [ %i4 + 0x30 ]
201c278: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
201c27c: b9 30 a0 10 srl %g2, 0x10, %i4
201c280: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
201c284: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
201c288: b9 30 a0 08 srl %g2, 8, %i4
201c28c: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
201c290: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
201c294: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
201c298: c4 06 60 04 ld [ %i1 + 4 ], %g2
201c29c: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
* @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);
201c2a0: f8 00 a0 0c ld [ %g2 + 0xc ], %i4
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201c2a4: c2 28 e0 10 stb %g1, [ %g3 + 0x10 ]
* @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);
201c2a8: 87 31 20 18 srl %g4, 0x18, %g3
201c2ac: c6 2f 20 34 stb %g3, [ %i4 + 0x34 ]
201c2b0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
201c2b4: b9 31 20 10 srl %g4, 0x10, %i4
201c2b8: f8 28 e0 35 stb %i4, [ %g3 + 0x35 ]
201c2bc: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
201c2c0: b9 31 20 08 srl %g4, 8, %i4
201c2c4: f8 28 e0 36 stb %i4, [ %g3 + 0x36 ]
201c2c8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
201c2cc: c8 28 e0 37 stb %g4, [ %g3 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
201c2d0: d2 06 60 04 ld [ %i1 + 4 ], %o1
201c2d4: 7f ff db 68 call 2013074 <rtems_rfs_inode_unload>
201c2d8: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
201c2dc: c0 2e 40 00 clrb [ %i1 ]
201c2e0: 82 38 00 08 xnor %g0, %o0, %g1
201c2e4: 83 38 60 1f sra %g1, 0x1f, %g1
201c2e8: 10 bf ff 9d b 201c15c <rtems_rfs_block_map_close+0x3c>
201c2ec: b0 0a 00 01 and %o0, %g1, %i0
0201c2f0 <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)
{
201c2f0: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
201c2f4: 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))
201c2f8: fa 06 80 00 ld [ %i2 ], %i5
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)
{
201c2fc: a0 10 00 18 mov %i0, %l0
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
201c300: 80 a7 60 00 cmp %i5, 0
201c304: 02 80 00 05 be 201c318 <rtems_rfs_block_map_find+0x28>
201c308: f8 06 60 08 ld [ %i1 + 8 ], %i4
201c30c: 80 a7 20 00 cmp %i4, 0
201c310: 02 80 00 4b be 201c43c <rtems_rfs_block_map_find+0x14c> <== NEVER TAKEN
201c314: b0 10 20 06 mov 6, %i0
201c318: 80 a7 40 1c cmp %i5, %i4
201c31c: 1a 80 00 48 bcc 201c43c <rtems_rfs_block_map_find+0x14c>
201c320: b0 10 20 06 mov 6, %i0
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))
201c324: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
201c328: 80 a7 40 01 cmp %i5, %g1
201c32c: 22 80 00 14 be,a 201c37c <rtems_rfs_block_map_find+0x8c>
201c330: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
/*
* 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)
201c334: 80 a7 20 05 cmp %i4, 5
201c338: 38 80 00 16 bgu,a 201c390 <rtems_rfs_block_map_find+0xa0>
201c33c: e2 04 20 34 ld [ %l0 + 0x34 ], %l1
{
*block = map->blocks[bpos->bno];
201c340: ba 07 60 08 add %i5, 8, %i5
201c344: bb 2f 60 02 sll %i5, 2, %i5
201c348: ba 06 40 1d add %i1, %i5, %i5
201c34c: c2 07 60 04 ld [ %i5 + 4 ], %g1
201c350: c2 26 c0 00 st %g1, [ %i3 ]
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
201c354: c6 06 a0 08 ld [ %i2 + 8 ], %g3
201c358: c2 06 a0 04 ld [ %i2 + 4 ], %g1
201c35c: c4 06 80 00 ld [ %i2 ], %g2
201c360: c6 26 60 18 st %g3, [ %i1 + 0x18 ]
201c364: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
201c368: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
map->bpos.block = *block;
201c36c: c2 06 c0 00 ld [ %i3 ], %g1
201c370: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
201c374: 81 c7 e0 08 ret
201c378: 91 e8 20 00 restore %g0, 0, %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))
201c37c: 80 a0 60 00 cmp %g1, 0
201c380: 02 bf ff ee be 201c338 <rtems_rfs_block_map_find+0x48>
201c384: 80 a7 20 05 cmp %i4, 5
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
{
*block = map->blocks[bpos->bno];
201c388: 10 bf ff f3 b 201c354 <rtems_rfs_block_map_find+0x64>
201c38c: 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;
201c390: 90 10 00 1d mov %i5, %o0
201c394: 40 00 51 a5 call 2030a28 <.urem>
201c398: 92 10 00 11 mov %l1, %o1
singly = bpos->bno / fs->blocks_per_block;
201c39c: 92 10 00 11 mov %l1, %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;
201c3a0: a6 10 00 08 mov %o0, %l3
singly = bpos->bno / fs->blocks_per_block;
201c3a4: 7f ff 98 bc call 2002694 <.udiv>
201c3a8: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
201c3ac: c2 04 20 38 ld [ %l0 + 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;
201c3b0: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
201c3b4: 80 a0 40 1c cmp %g1, %i4
201c3b8: 1a 80 00 23 bcc 201c444 <rtems_rfs_block_map_find+0x154> <== ALWAYS TAKEN
201c3bc: ba 10 00 08 mov %o0, %i5
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
201c3c0: 40 00 51 9a call 2030a28 <.urem> <== NOT EXECUTED
201c3c4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
201c3c8: c2 04 20 3c ld [ %l0 + 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;
201c3cc: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
201c3d0: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
201c3d4: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
201c3d8: 08 80 00 19 bleu 201c43c <rtems_rfs_block_map_find+0x14c> <== NOT EXECUTED
201c3dc: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
/*
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
201c3e0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
201c3e4: 7f ff 98 ac call 2002694 <.udiv> <== NOT EXECUTED
201c3e8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
singly %= fs->blocks_per_block;
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
201c3ec: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
201c3f0: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
201c3f4: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
201c3f8: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
201c3fc: 92 06 60 44 add %i1, 0x44, %o1 <== NOT EXECUTED
201c400: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201c404: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
201c408: 7f ff fe 6d call 201bdbc <rtems_rfs_block_find_indirect> <== NOT EXECUTED
201c40c: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
201c410: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201c414: 12 80 00 0a bne 201c43c <rtems_rfs_block_map_find+0x14c> <== NOT EXECUTED
201c418: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
201c41c: 90 10 00 10 mov %l0, %o0
201c420: 92 06 60 38 add %i1, 0x38, %o1
201c424: 96 10 00 13 mov %l3, %o3
201c428: 7f ff fe 65 call 201bdbc <rtems_rfs_block_find_indirect>
201c42c: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
201c430: b0 92 20 00 orcc %o0, 0, %i0
201c434: 22 bf ff c9 be,a 201c358 <rtems_rfs_block_map_find+0x68> <== ALWAYS TAKEN
201c438: c6 06 a0 08 ld [ %i2 + 8 ], %g3
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
201c43c: 81 c7 e0 08 ret
201c440: 81 e8 00 00 restore
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
201c444: 82 02 20 08 add %o0, 8, %g1
201c448: 83 28 60 02 sll %g1, 2, %g1
201c44c: 82 06 40 01 add %i1, %g1, %g1
201c450: 10 bf ff f3 b 201c41c <rtems_rfs_block_map_find+0x12c>
201c454: d4 00 60 04 ld [ %g1 + 4 ], %o2
0201c500 <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)
{
201c500: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
201c504: 90 10 20 00 clr %o0
201c508: 7f ff e1 4b call 2014a34 <rtems_rfs_trace>
201c50c: 13 00 00 08 sethi %hi(0x2000), %o1
201c510: 80 8a 20 ff btst 0xff, %o0
201c514: 32 80 00 cf bne,a 201c850 <rtems_rfs_block_map_grow+0x350><== NEVER TAKEN
201c518: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
201c51c: c4 06 60 08 ld [ %i1 + 8 ], %g2
201c520: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
201c524: 84 06 80 02 add %i2, %g2, %g2
201c528: 80 a0 80 01 cmp %g2, %g1
201c52c: 0a 80 00 04 bcs 201c53c <rtems_rfs_block_map_grow+0x3c> <== ALWAYS TAKEN
201c530: ba 10 20 1b mov 0x1b, %i5
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
201c534: 81 c7 e0 08 ret
201c538: 91 e8 00 1d restore %g0, %i5, %o0
/*
* 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++)
201c53c: 80 a6 a0 00 cmp %i2, 0
201c540: 02 80 00 de be 201c8b8 <rtems_rfs_block_map_grow+0x3b8> <== NEVER TAKEN
201c544: b8 10 20 00 clr %i4
201c548: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
201c54c: a2 10 20 01 mov 1, %l1
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
201c550: a6 06 60 44 add %i1, 0x44, %l3
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201c554: 10 80 00 11 b 201c598 <rtems_rfs_block_map_grow+0x98>
201c558: a4 06 60 38 add %i1, 0x38, %l2
false, &block);
if (rc > 0)
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
map->blocks[map->size.count] = block;
201c55c: 82 07 60 08 add %i5, 8, %g1
201c560: 83 28 60 02 sll %g1, 2, %g1
201c564: 82 06 40 01 add %i1, %g1, %g1
201c568: d2 20 60 04 st %o1, [ %g1 + 4 ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
201c56c: ba 07 60 01 inc %i5
map->size.offset = 0;
201c570: c0 26 60 0c clr [ %i1 + 0xc ]
if (b == 0)
201c574: 80 a7 20 00 cmp %i4, 0
201c578: 12 80 00 03 bne 201c584 <rtems_rfs_block_map_grow+0x84> <== NEVER TAKEN
201c57c: fa 26 60 08 st %i5, [ %i1 + 8 ]
*new_block = block;
201c580: d2 26 c0 00 st %o1, [ %i3 ]
map->last_data_block = block;
map->dirty = true;
201c584: e2 2e 40 00 stb %l1, [ %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++)
201c588: b8 07 20 01 inc %i4
201c58c: 80 a7 00 1a cmp %i4, %i2
201c590: 02 80 00 ca be 201c8b8 <rtems_rfs_block_map_grow+0x3b8> <== ALWAYS TAKEN
201c594: d2 26 60 20 st %o1, [ %i1 + 0x20 ]
/*
* 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,
201c598: 90 10 00 18 mov %i0, %o0
201c59c: 94 10 20 00 clr %o2
201c5a0: 7f ff d9 01 call 20129a4 <rtems_rfs_group_bitmap_alloc>
201c5a4: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
201c5a8: ba 92 20 00 orcc %o0, 0, %i5
201c5ac: 14 bf ff e2 bg 201c534 <rtems_rfs_block_map_grow+0x34>
201c5b0: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
201c5b4: fa 06 60 08 ld [ %i1 + 8 ], %i5
201c5b8: 80 a7 60 04 cmp %i5, 4
201c5bc: 08 bf ff e8 bleu 201c55c <rtems_rfs_block_map_grow+0x5c>
201c5c0: d2 07 bf f8 ld [ %fp + -8 ], %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;
201c5c4: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
201c5c8: 90 10 00 1d mov %i5, %o0
201c5cc: 40 00 51 17 call 2030a28 <.urem>
201c5d0: 92 10 00 10 mov %l0, %o1
singly = map->size.count / fs->blocks_per_block;
201c5d4: 92 10 00 10 mov %l0, %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;
201c5d8: a8 10 00 08 mov %o0, %l4
singly = map->size.count / fs->blocks_per_block;
201c5dc: 7f ff 98 2e call 2002694 <.udiv>
201c5e0: 90 10 00 1d mov %i5, %o0
if (map->size.count < fs->block_map_singly_blocks)
201c5e4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
201c5e8: 80 a7 40 01 cmp %i5, %g1
201c5ec: 1a 80 00 31 bcc 201c6b0 <rtems_rfs_block_map_grow+0x1b0> <== NEVER TAKEN
201c5f0: aa 10 00 08 mov %o0, %l5
* 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) ||
201c5f4: 80 a5 20 00 cmp %l4, 0
201c5f8: 02 80 00 06 be 201c610 <rtems_rfs_block_map_grow+0x110> <== NEVER TAKEN
201c5fc: 80 a5 20 05 cmp %l4, 5
201c600: 12 80 00 8a bne 201c828 <rtems_rfs_block_map_grow+0x328>
201c604: 80 a2 20 00 cmp %o0, 0
201c608: 12 80 00 89 bne 201c82c <rtems_rfs_block_map_grow+0x32c> <== NEVER TAKEN
201c60c: 82 05 60 08 add %l5, 8, %g1
{
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
201c610: ba 1f 60 05 xor %i5, 5, %i5
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c614: 80 a0 00 1d cmp %g0, %i5
&map->singly_buffer,
&map->blocks[singly],
201c618: 96 05 60 08 add %l5, 8, %o3
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c61c: 90 10 00 18 mov %i0, %o0
&map->singly_buffer,
&map->blocks[singly],
201c620: 97 2a e0 02 sll %o3, 2, %o3
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c624: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
201c628: 96 06 40 0b add %i1, %o3, %o3
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c62c: 94 10 00 12 mov %l2, %o2
201c630: 96 02 e0 04 add %o3, 4, %o3
201c634: 7f ff fd 8f call 201bc70 <rtems_rfs_block_map_indirect_alloc>
201c638: 98 60 3f ff subx %g0, -1, %o4
201c63c: ba 10 00 08 mov %o0, %i5
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)
201c640: 80 a7 60 00 cmp %i5, 0
201c644: 14 80 00 a1 bg 201c8c8 <rtems_rfs_block_map_grow+0x3c8> <== NEVER TAKEN
201c648: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
201c64c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201c650: c4 0f bf f8 ldub [ %fp + -8 ], %g2
201c654: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201c658: 91 2d 20 02 sll %l4, 2, %o0
201c65c: c4 28 40 08 stb %g2, [ %g1 + %o0 ]
201c660: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201c664: c4 17 bf f8 lduh [ %fp + -8 ], %g2
201c668: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201c66c: 82 00 40 08 add %g1, %o0, %g1
201c670: c4 28 60 01 stb %g2, [ %g1 + 1 ]
201c674: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201c678: c4 07 bf f8 ld [ %fp + -8 ], %g2
201c67c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201c680: 85 30 a0 08 srl %g2, 8, %g2
201c684: 82 00 40 08 add %g1, %o0, %g1
201c688: c4 28 60 02 stb %g2, [ %g1 + 2 ]
201c68c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201c690: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201c694: 90 00 40 08 add %g1, %o0, %o0
201c698: c2 07 bf f8 ld [ %fp + -8 ], %g1
201c69c: c2 2a 20 03 stb %g1, [ %o0 + 3 ]
201c6a0: e2 2e 60 38 stb %l1, [ %i1 + 0x38 ]
201c6a4: fa 06 60 08 ld [ %i1 + 8 ], %i5
201c6a8: 10 bf ff b1 b 201c56c <rtems_rfs_block_map_grow+0x6c>
201c6ac: d2 07 bf f8 ld [ %fp + -8 ], %o1
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
201c6b0: 7f ff 97 f9 call 2002694 <.udiv> <== NOT EXECUTED
201c6b4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
201c6b8: 92 10 00 10 mov %l0, %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;
201c6bc: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
singly %= fs->blocks_per_block;
201c6c0: 40 00 50 da call 2030a28 <.urem> <== NOT EXECUTED
201c6c4: 90 10 00 15 mov %l5, %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)
201c6c8: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
201c6cc: 12 80 00 38 bne 201c7ac <rtems_rfs_block_map_grow+0x2ac> <== NOT EXECUTED
201c6d0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c6d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c6d8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201c6dc: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
201c6e0: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
201c6e4: 7f ff fd 63 call 201bc70 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
201c6e8: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
201c6ec: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
201c6f0: 14 80 00 75 bg 201c8c4 <rtems_rfs_block_map_grow+0x3c4> <== NOT EXECUTED
201c6f4: 80 a4 20 00 cmp %l0, 0 <== 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) ||
201c6f8: 02 80 00 06 be 201c710 <rtems_rfs_block_map_grow+0x210> <== NOT EXECUTED
201c6fc: 80 a4 20 05 cmp %l0, 5 <== NOT EXECUTED
201c700: 12 80 00 5a bne 201c868 <rtems_rfs_block_map_grow+0x368> <== NOT EXECUTED
201c704: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
201c708: 12 80 00 59 bne 201c86c <rtems_rfs_block_map_grow+0x36c> <== NOT EXECUTED
201c70c: 82 05 a0 08 add %l6, 8, %g1 <== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
201c710: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
201c714: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
&map->doubly_buffer,
&map->blocks[doubly],
201c718: 96 05 a0 08 add %l6, 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;
201c71c: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c720: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
201c724: 97 2a e0 02 sll %o3, 2, %o3 <== NOT EXECUTED
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c728: 98 60 3f ff subx %g0, -1, %o4 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
201c72c: 96 06 40 0b add %i1, %o3, %o3 <== NOT EXECUTED
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201c730: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c734: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201c738: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
201c73c: 7f ff fd 4d call 201bc70 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
201c740: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
201c744: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
201c748: 14 80 00 54 bg 201c898 <rtems_rfs_block_map_grow+0x398> <== NOT EXECUTED
201c74c: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
201c750: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201c754: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
201c758: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201c75c: a1 2c 20 02 sll %l0, 2, %l0 <== NOT EXECUTED
201c760: c4 28 40 10 stb %g2, [ %g1 + %l0 ] <== NOT EXECUTED
201c764: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201c768: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
201c76c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201c770: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED
201c774: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
201c778: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201c77c: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
201c780: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201c784: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
201c788: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED
201c78c: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
201c790: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201c794: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201c798: a0 00 40 10 add %g1, %l0, %l0 <== NOT EXECUTED
201c79c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
201c7a0: c2 2c 20 03 stb %g1, [ %l0 + 3 ] <== NOT EXECUTED
201c7a4: 10 bf ff aa b 201c64c <rtems_rfs_block_map_grow+0x14c> <== NOT EXECUTED
201c7a8: e2 2e 60 44 stb %l1, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
201c7ac: ac 05 a0 08 add %l6, 8, %l6 <== NOT EXECUTED
201c7b0: ad 2d a0 02 sll %l6, 2, %l6 <== NOT EXECUTED
201c7b4: ac 06 40 16 add %i1, %l6, %l6 <== NOT EXECUTED
201c7b8: d4 05 a0 04 ld [ %l6 + 4 ], %o2 <== NOT EXECUTED
201c7bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c7c0: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
201c7c4: 40 00 01 fa call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201c7c8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
201c7cc: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
201c7d0: 14 80 00 3d bg 201c8c4 <rtems_rfs_block_map_grow+0x3c4> <== NOT EXECUTED
201c7d4: a1 2c 20 02 sll %l0, 2, %l0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
201c7d8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201c7dc: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201c7e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
201c7e4: c6 08 80 10 ldub [ %g2 + %l0 ], %g3 <== NOT EXECUTED
201c7e8: 82 00 80 10 add %g2, %l0, %g1 <== NOT EXECUTED
201c7ec: d4 08 60 03 ldub [ %g1 + 3 ], %o2 <== NOT EXECUTED
201c7f0: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201c7f4: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201c7f8: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
201c7fc: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201c800: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201c804: 94 12 80 03 or %o2, %g3, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201c808: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
201c80c: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201c810: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
201c814: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201c818: 40 00 01 e5 call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201c81c: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
201c820: 10 bf ff 88 b 201c640 <rtems_rfs_block_map_grow+0x140> <== NOT EXECUTED
201c824: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201c828: 82 05 60 08 add %l5, 8, %g1
201c82c: 83 28 60 02 sll %g1, 2, %g1
201c830: 82 06 40 01 add %i1, %g1, %g1
201c834: d4 00 60 04 ld [ %g1 + 4 ], %o2
201c838: 90 10 00 18 mov %i0, %o0
201c83c: 92 10 00 12 mov %l2, %o1
201c840: 40 00 01 db call 201cfac <rtems_rfs_buffer_handle_request>
201c844: 96 10 20 01 mov 1, %o3
201c848: 10 bf ff 7e b 201c640 <rtems_rfs_block_map_grow+0x140>
201c84c: ba 10 00 08 mov %o0, %i5
rtems_rfs_block_no* new_block)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
201c850: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201c854: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201c858: 40 00 20 15 call 20248ac <printf> <== NOT EXECUTED
201c85c: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2035da8 <CSWTCH.2+0x94> <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
201c860: 10 bf ff 30 b 201c520 <rtems_rfs_block_map_grow+0x20> <== NOT EXECUTED
201c864: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201c868: 82 05 a0 08 add %l6, 8, %g1 <== NOT EXECUTED
201c86c: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
201c870: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
201c874: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
201c878: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c87c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
201c880: 40 00 01 cb call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201c884: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
201c888: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
201c88c: 24 bf ff b2 ble,a 201c754 <rtems_rfs_block_map_grow+0x254><== NOT EXECUTED
201c890: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
201c894: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
201c898: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c89c: 7f ff d8 d1 call 2012be0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201c8a0: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
201c8a4: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
201c8a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c8ac: 7f ff d8 cd call 2012be0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201c8b0: 92 10 20 00 clr %o1 <== NOT EXECUTED
201c8b4: 30 bf ff 20 b,a 201c534 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
201c8b8: ba 10 20 00 clr %i5
}
201c8bc: 81 c7 e0 08 ret
201c8c0: 91 e8 00 1d restore %g0, %i5, %o0
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
201c8c4: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
201c8c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c8cc: 7f ff d8 c5 call 2012be0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201c8d0: 92 10 20 00 clr %o1 <== NOT EXECUTED
201c8d4: 30 bf ff 18 b,a 201c534 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
0201bc70 <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)
{
201bc70: 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);
201bc74: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201bc78: 94 10 20 00 clr %o2
201bc7c: 90 10 00 18 mov %i0, %o0
201bc80: 7f ff db 49 call 20129a4 <rtems_rfs_group_bitmap_alloc>
201bc84: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
201bc88: ba 92 20 00 orcc %o0, 0, %i5
201bc8c: 04 80 00 04 ble 201bc9c <rtems_rfs_block_map_indirect_alloc+0x2c><== ALWAYS TAKEN
201bc90: d4 07 bf fc ld [ %fp + -4 ], %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
201bc94: 81 c7 e0 08 ret
201bc98: 91 e8 00 1d restore %g0, %i5, %o0
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
if (rc > 0)
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
201bc9c: 90 10 00 18 mov %i0, %o0
201bca0: 92 10 00 1a mov %i2, %o1
201bca4: 40 00 04 c2 call 201cfac <rtems_rfs_buffer_handle_request>
201bca8: 96 10 20 00 clr %o3
if (rc > 0)
201bcac: ba 92 20 00 orcc %o0, 0, %i5
201bcb0: 04 80 00 08 ble 201bcd0 <rtems_rfs_block_map_indirect_alloc+0x60><== ALWAYS TAKEN
201bcb4: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
201bcb8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201bcbc: 92 10 20 00 clr %o1 <== NOT EXECUTED
201bcc0: 7f ff db c8 call 2012be0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201bcc4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
201bcc8: 81 c7 e0 08 ret <== NOT EXECUTED
201bccc: 81 e8 00 00 restore <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
return rc;
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
201bcd0: c2 06 a0 08 ld [ %i2 + 8 ], %g1
201bcd4: d4 06 20 08 ld [ %i0 + 8 ], %o2
201bcd8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201bcdc: 40 00 22 76 call 20246b4 <memset>
201bce0: 92 10 20 ff mov 0xff, %o1
if (upping)
201bce4: 80 a7 20 00 cmp %i4, 0
201bce8: 12 80 00 08 bne 201bd08 <rtems_rfs_block_map_indirect_alloc+0x98><== ALWAYS TAKEN
201bcec: c2 07 bf fc ld [ %fp + -4 ], %g1
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
201bcf0: 84 10 20 01 mov 1, %g2
201bcf4: c4 2e 80 00 stb %g2, [ %i2 ]
*block = new_block;
201bcf8: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
201bcfc: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
201bd00: 10 bf ff e5 b 201bc94 <rtems_rfs_block_map_indirect_alloc+0x24>
201bd04: ba 10 20 00 clr %i5
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
201bd08: 90 10 20 00 clr %o0
201bd0c: 7f ff e3 4a call 2014a34 <rtems_rfs_trace>
201bd10: 13 00 00 08 sethi %hi(0x2000), %o1
201bd14: 80 8a 20 ff btst 0xff, %o0
201bd18: 32 80 00 24 bne,a 201bda8 <rtems_rfs_block_map_indirect_alloc+0x138><== NEVER TAKEN
201bd1c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201bd20: 84 10 00 19 mov %i1, %g2
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)
{
201bd24: 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]);
201bd28: ba 10 20 01 mov 1, %i5
201bd2c: c6 06 a0 08 ld [ %i2 + 8 ], %g3
201bd30: c8 08 a0 24 ldub [ %g2 + 0x24 ], %g4
201bd34: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
201bd38: c8 28 c0 01 stb %g4, [ %g3 + %g1 ]
201bd3c: c6 06 a0 08 ld [ %i2 + 8 ], %g3
201bd40: c8 10 a0 24 lduh [ %g2 + 0x24 ], %g4
201bd44: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
201bd48: 86 00 c0 01 add %g3, %g1, %g3
201bd4c: c8 28 e0 01 stb %g4, [ %g3 + 1 ]
201bd50: c6 06 a0 08 ld [ %i2 + 8 ], %g3
201bd54: c8 00 a0 24 ld [ %g2 + 0x24 ], %g4
201bd58: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
201bd5c: 89 31 20 08 srl %g4, 8, %g4
201bd60: 86 00 c0 01 add %g3, %g1, %g3
201bd64: c8 28 e0 02 stb %g4, [ %g3 + 2 ]
201bd68: c6 06 a0 08 ld [ %i2 + 8 ], %g3
201bd6c: c8 00 a0 24 ld [ %g2 + 0x24 ], %g4
201bd70: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
201bd74: 84 00 a0 04 add %g2, 4, %g2
201bd78: 86 00 c0 01 add %g3, %g1, %g3
201bd7c: c8 28 e0 03 stb %g4, [ %g3 + 3 ]
201bd80: 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++)
201bd84: 80 a0 60 14 cmp %g1, 0x14
201bd88: 12 bf ff e9 bne 201bd2c <rtems_rfs_block_map_indirect_alloc+0xbc>
201bd8c: fa 2e 80 00 stb %i5, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
201bd90: 90 06 60 24 add %i1, 0x24, %o0
201bd94: 92 10 20 00 clr %o1
201bd98: 40 00 22 47 call 20246b4 <memset>
201bd9c: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
201bda0: 10 bf ff d4 b 201bcf0 <rtems_rfs_block_map_indirect_alloc+0x80>
201bda4: c2 07 bf fc ld [ %fp + -4 ], %g1
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
201bda8: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201bdac: 40 00 22 c0 call 20248ac <printf> <== NOT EXECUTED
201bdb0: 90 12 21 20 or %o0, 0x120, %o0 ! 2035d20 <CSWTCH.2+0xc> <== NOT EXECUTED
201bdb4: 10 bf ff dc b 201bd24 <rtems_rfs_block_map_indirect_alloc+0xb4><== NOT EXECUTED
201bdb8: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
0201bbbc <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)
{
201bbbc: 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) ||
201bbc0: 80 a7 20 00 cmp %i4, 0
201bbc4: 22 80 00 07 be,a 201bbe0 <rtems_rfs_block_map_indirect_shrink+0x24><== NEVER TAKEN
201bbc8: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
201bbcc: 80 a7 20 05 cmp %i4, 5
201bbd0: 02 80 00 11 be 201bc14 <rtems_rfs_block_map_indirect_shrink+0x58>
201bbd4: 80 a6 e0 00 cmp %i3, 0
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
int rc = 0;
201bbd8: 81 c7 e0 08 ret
201bbdc: 91 e8 20 00 restore %g0, 0, %o0
* 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];
201bbe0: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
201bbe4: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
201bbe8: f4 06 e0 04 ld [ %i3 + 4 ], %i2 <== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
201bbec: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
201bbf0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201bbf4: 92 10 20 00 clr %o1
201bbf8: 7f ff db fa call 2012be0 <rtems_rfs_group_bitmap_free>
201bbfc: 94 10 00 1a mov %i2, %o2
if (rc > 0)
201bc00: b0 92 20 00 orcc %o0, 0, %i0
201bc04: 24 80 00 02 ble,a 201bc0c <rtems_rfs_block_map_indirect_shrink+0x50><== ALWAYS TAKEN
201bc08: f4 26 60 1c st %i2, [ %i1 + 0x1c ]
map->last_map_block = block_to_free;
}
return rc;
}
201bc0c: 81 c7 e0 08 ret
201bc10: 81 e8 00 00 restore
* 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) ||
201bc14: 12 bf ff f1 bne 201bbd8 <rtems_rfs_block_map_indirect_shrink+0x1c><== NEVER TAKEN
201bc18: 84 10 20 00 clr %g2
201bc1c: c2 06 a0 08 ld [ %i2 + 8 ], %g1
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
201bc20: f4 06 60 24 ld [ %i1 + 0x24 ], %i2
201bc24: 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);
201bc28: c8 08 40 00 ldub [ %g1 ], %g4
201bc2c: f6 08 60 01 ldub [ %g1 + 1 ], %i3
201bc30: f8 08 60 03 ldub [ %g1 + 3 ], %i4
201bc34: fa 08 60 02 ldub [ %g1 + 2 ], %i5
* @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,
201bc38: 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);
201bc3c: 89 29 20 18 sll %g4, 0x18, %g4
201bc40: b7 2e e0 10 sll %i3, 0x10, %i3
201bc44: bb 2f 60 08 sll %i5, 8, %i5
201bc48: 88 11 00 1b or %g4, %i3, %g4
201bc4c: 88 11 00 1c or %g4, %i4, %g4
201bc50: 88 11 00 1d or %g4, %i5, %g4
201bc54: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
201bc58: 84 00 a0 04 add %g2, 4, %g2
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201bc5c: 80 a0 a0 14 cmp %g2, 0x14
201bc60: 12 bf ff f2 bne 201bc28 <rtems_rfs_block_map_indirect_shrink+0x6c>
201bc64: 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);
201bc68: 10 bf ff e3 b 201bbf4 <rtems_rfs_block_map_indirect_shrink+0x38>
201bc6c: 90 10 00 18 mov %i0, %o0
0201bf9c <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)
{
201bf9c: 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;
201bfa0: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
201bfa4: 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;
201bfa8: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
201bfac: 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;
201bfb0: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
201bfb4: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
201bfb8: 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;
201bfbc: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
201bfc0: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
201bfc4: 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;
201bfc8: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
201bfcc: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
201bfd0: 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);
201bfd4: 90 10 00 18 mov %i0, %o0
201bfd8: 92 10 00 19 mov %i1, %o1
201bfdc: 7f ff db c2 call 2012ee4 <rtems_rfs_inode_load>
201bfe0: ba 10 00 1a mov %i2, %i5
if (rc > 0)
201bfe4: b8 92 20 00 orcc %o0, 0, %i4
201bfe8: 14 80 00 3f bg 201c0e4 <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
201bfec: 88 10 00 1a mov %i2, %g4
201bff0: c6 06 60 0c ld [ %i1 + 0xc ], %g3
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
201bff4: f2 26 a0 04 st %i1, [ %i2 + 4 ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201bff8: 82 10 20 00 clr %g1
* @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]);
201bffc: b8 00 60 06 add %g1, 6, %i4
201c000: b9 2f 20 02 sll %i4, 2, %i4
201c004: b8 00 c0 1c add %g3, %i4, %i4
201c008: de 0f 20 04 ldub [ %i4 + 4 ], %o7
201c00c: f4 0f 20 05 ldub [ %i4 + 5 ], %i2
201c010: f6 0f 20 07 ldub [ %i4 + 7 ], %i3
201c014: f8 0f 20 06 ldub [ %i4 + 6 ], %i4
201c018: 85 2b e0 18 sll %o7, 0x18, %g2
201c01c: b5 2e a0 10 sll %i2, 0x10, %i2
201c020: b9 2f 20 08 sll %i4, 8, %i4
201c024: 84 10 80 1a or %g2, %i2, %g2
201c028: 84 10 80 1b or %g2, %i3, %g2
201c02c: 84 10 80 1c or %g2, %i4, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
201c030: c4 21 20 24 st %g2, [ %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++)
201c034: 82 00 60 01 inc %g1
201c038: 80 a0 60 05 cmp %g1, 5
201c03c: 12 bf ff f0 bne 201bffc <rtems_rfs_block_map_open+0x60>
201c040: 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);
201c044: c8 08 e0 0f ldub [ %g3 + 0xf ], %g4
201c048: c2 08 e0 0c ldub [ %g3 + 0xc ], %g1
201c04c: f8 08 e0 0d ldub [ %g3 + 0xd ], %i4
201c050: c4 08 e0 0e ldub [ %g3 + 0xe ], %g2
201c054: b9 2f 20 10 sll %i4, 0x10, %i4
201c058: 85 28 a0 08 sll %g2, 8, %g2
201c05c: 83 28 60 18 sll %g1, 0x18, %g1
201c060: 82 10 40 1c or %g1, %i4, %g1
201c064: 82 10 40 04 or %g1, %g4, %g1
201c068: 82 10 40 02 or %g1, %g2, %g1
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
201c06c: c2 27 60 08 st %g1, [ %i5 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
201c070: c4 08 e0 0b ldub [ %g3 + 0xb ], %g2
* @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);
201c074: c2 08 e0 0a ldub [ %g3 + 0xa ], %g1
201c078: 83 28 60 08 sll %g1, 8, %g1
201c07c: 82 10 80 01 or %g2, %g1, %g1
201c080: c2 27 60 0c st %g1, [ %i5 + 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);
201c084: c8 08 e0 33 ldub [ %g3 + 0x33 ], %g4
201c088: c2 08 e0 30 ldub [ %g3 + 0x30 ], %g1
201c08c: f8 08 e0 31 ldub [ %g3 + 0x31 ], %i4
201c090: c4 08 e0 32 ldub [ %g3 + 0x32 ], %g2
201c094: b9 2f 20 10 sll %i4, 0x10, %i4
201c098: 85 28 a0 08 sll %g2, 8, %g2
201c09c: 83 28 60 18 sll %g1, 0x18, %g1
201c0a0: 82 10 40 1c or %g1, %i4, %g1
201c0a4: 82 10 40 04 or %g1, %g4, %g1
201c0a8: 82 10 40 02 or %g1, %g2, %g1
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
201c0ac: c2 27 60 1c st %g1, [ %i5 + 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);
201c0b0: c2 08 e0 34 ldub [ %g3 + 0x34 ], %g1
201c0b4: c8 08 e0 37 ldub [ %g3 + 0x37 ], %g4
201c0b8: c4 08 e0 36 ldub [ %g3 + 0x36 ], %g2
201c0bc: f8 08 e0 35 ldub [ %g3 + 0x35 ], %i4
201c0c0: 83 28 60 18 sll %g1, 0x18, %g1
201c0c4: 87 2f 20 10 sll %i4, 0x10, %g3
201c0c8: 85 28 a0 08 sll %g2, 8, %g2
201c0cc: 82 10 40 03 or %g1, %g3, %g1
201c0d0: 82 10 40 04 or %g1, %g4, %g1
201c0d4: 82 10 40 02 or %g1, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
201c0d8: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
201c0dc: 7f ff db e6 call 2013074 <rtems_rfs_inode_unload>
201c0e0: 95 e8 20 00 restore %g0, 0, %o2
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
201c0e4: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
201c0e8: 40 00 03 37 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201c0ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c0f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
201c0f4: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
201c0f8: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
201c0fc: 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);
201c100: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
201c104: 40 00 03 30 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201c108: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
handle->dirty = false;
201c10c: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
201c110: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
201c114: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
201c118: 81 c7 e0 08 ret <== NOT EXECUTED
201c11c: 81 e8 00 00 restore <== NOT EXECUTED
0201c8d8 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
201c8d8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
201c8dc: 90 10 20 00 clr %o0
201c8e0: 13 00 00 10 sethi %hi(0x4000), %o1
201c8e4: 7f ff e0 54 call 2014a34 <rtems_rfs_trace>
201c8e8: b6 10 00 18 mov %i0, %i3
201c8ec: 80 8a 20 ff btst 0xff, %o0
201c8f0: 32 80 00 b0 bne,a 201cbb0 <rtems_rfs_block_map_shrink+0x2d8><== NEVER TAKEN
201c8f4: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
201c8f8: f8 06 60 08 ld [ %i1 + 8 ], %i4
201c8fc: 80 a7 20 00 cmp %i4, 0
201c900: 02 80 00 a9 be 201cba4 <rtems_rfs_block_map_shrink+0x2cc>
201c904: 80 a6 80 1c cmp %i2, %i4
201c908: 38 80 00 02 bgu,a 201c910 <rtems_rfs_block_map_shrink+0x38><== NEVER TAKEN
201c90c: b4 10 00 1c mov %i4, %i2 <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
201c910: 80 a6 a0 00 cmp %i2, 0
201c914: 02 80 00 98 be 201cb74 <rtems_rfs_block_map_shrink+0x29c> <== NEVER TAKEN
201c918: a6 06 60 44 add %i1, 0x44, %l3
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201c91c: a4 06 60 38 add %i1, 0x38, %l2
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
201c920: 10 80 00 14 b 201c970 <rtems_rfs_block_map_shrink+0x98>
201c924: a2 10 20 01 mov 1, %l1
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
201c928: b9 2f 20 02 sll %i4, 2, %i4
201c92c: b8 06 40 1c add %i1, %i4, %i4
201c930: fa 07 20 04 ld [ %i4 + 4 ], %i5
map->blocks[block] = 0;
201c934: c0 27 20 04 clr [ %i4 + 4 ]
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
201c938: 90 10 00 1b mov %i3, %o0
201c93c: 92 10 20 00 clr %o1
201c940: 7f ff d8 a8 call 2012be0 <rtems_rfs_group_bitmap_free>
201c944: 94 10 00 1d mov %i5, %o2
if (rc > 0)
201c948: 80 a2 20 00 cmp %o0, 0
201c94c: 14 80 00 63 bg 201cad8 <rtems_rfs_block_map_shrink+0x200> <== NEVER TAKEN
201c950: b4 86 bf ff addcc %i2, -1, %i2
return rc;
map->size.count--;
201c954: f8 06 60 08 ld [ %i1 + 8 ], %i4
map->size.offset = 0;
201c958: 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--;
201c95c: b8 07 3f ff add %i4, -1, %i4
map->size.offset = 0;
map->last_data_block = block_to_free;
201c960: fa 26 60 20 st %i5, [ %i1 + 0x20 ]
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
201c964: f8 26 60 08 st %i4, [ %i1 + 8 ]
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
201c968: 02 80 00 80 be 201cb68 <rtems_rfs_block_map_shrink+0x290>
201c96c: e2 2e 40 00 stb %l1, [ %i1 ]
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
201c970: ba 07 3f ff add %i4, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
201c974: 80 a7 60 04 cmp %i5, 4
201c978: 28 bf ff ec bleu,a 201c928 <rtems_rfs_block_map_shrink+0x50>
201c97c: b8 07 20 07 add %i4, 7, %i4
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
201c980: f0 06 e0 34 ld [ %i3 + 0x34 ], %i0
201c984: 90 10 00 1d mov %i5, %o0
201c988: 40 00 50 28 call 2030a28 <.urem>
201c98c: 92 10 00 18 mov %i0, %o1
singly = block / fs->blocks_per_block;
201c990: 92 10 00 18 mov %i0, %o1
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
201c994: a0 10 00 08 mov %o0, %l0
singly = block / fs->blocks_per_block;
201c998: 7f ff 97 3f call 2002694 <.udiv>
201c99c: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
201c9a0: c2 06 e0 38 ld [ %i3 + 0x38 ], %g1
201c9a4: 80 a7 40 01 cmp %i5, %g1
201c9a8: 0a 80 00 4e bcs 201cae0 <rtems_rfs_block_map_shrink+0x208><== ALWAYS TAKEN
201c9ac: a8 10 00 08 mov %o0, %l4
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)
201c9b0: c2 06 e0 3c ld [ %i3 + 0x3c ], %g1 <== NOT EXECUTED
201c9b4: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
201c9b8: 1a 80 00 6d bcc 201cb6c <rtems_rfs_block_map_shrink+0x294><== NOT EXECUTED
201c9bc: 80 a7 20 00 cmp %i4, 0 <== 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;
201c9c0: 7f ff 97 35 call 2002694 <.udiv> <== NOT EXECUTED
201c9c4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
201c9c8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
201c9cc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
201c9d0: 40 00 50 16 call 2030a28 <.urem> <== NOT EXECUTED
201c9d4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201c9d8: 82 07 20 08 add %i4, 8, %g1 <== NOT EXECUTED
201c9dc: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
201c9e0: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
201c9e4: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
201c9e8: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201c9ec: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
201c9f0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201c9f4: 40 00 01 6e call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201c9f8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
201c9fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201ca00: 14 80 00 36 bg 201cad8 <rtems_rfs_block_map_shrink+0x200> <== NOT EXECUTED
201ca04: 85 2d 20 02 sll %l4, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
201ca08: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201ca0c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ca10: 90 10 00 1b mov %i3, %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,
201ca14: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
201ca18: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3 <== NOT EXECUTED
201ca1c: ea 08 60 03 ldub [ %g1 + 3 ], %l5 <== NOT EXECUTED
201ca20: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201ca24: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201ca28: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
201ca2c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201ca30: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201ca34: aa 15 40 03 or %l5, %g3, %l5 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ca38: 92 10 00 12 mov %l2, %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,
201ca3c: aa 15 40 02 or %l5, %g2, %l5 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ca40: 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,
201ca44: aa 15 40 01 or %l5, %g1, %l5 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ca48: 40 00 01 59 call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201ca4c: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
201ca50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201ca54: 14 80 00 21 bg 201cad8 <rtems_rfs_block_map_shrink+0x200> <== NOT EXECUTED
201ca58: 85 2c 20 02 sll %l0, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201ca5c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
201ca60: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
201ca64: 80 a4 20 00 cmp %l0, 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,
201ca68: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
201ca6c: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3 <== NOT EXECUTED
201ca70: fa 08 60 03 ldub [ %g1 + 3 ], %i5 <== NOT EXECUTED
201ca74: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201ca78: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201ca7c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
201ca80: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201ca84: ba 17 40 03 or %i5, %g3, %i5 <== NOT EXECUTED
201ca88: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201ca8c: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
201ca90: 12 bf ff aa bne 201c938 <rtems_rfs_block_map_shrink+0x60> <== NOT EXECUTED
201ca94: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
201ca98: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201ca9c: 92 10 20 00 clr %o1 <== NOT EXECUTED
201caa0: 7f ff d8 50 call 2012be0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201caa4: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
if (rc > 0)
201caa8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201caac: 14 80 00 0b bg 201cad8 <rtems_rfs_block_map_shrink+0x200> <== NOT EXECUTED
201cab0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
201cab4: ea 26 60 1c st %l5, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
201cab8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201cabc: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
201cac0: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
201cac4: 7f ff fc 3e call 201bbbc <rtems_rfs_block_map_indirect_shrink><== NOT EXECUTED
201cac8: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
201cacc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201cad0: 22 bf ff 9b be,a 201c93c <rtems_rfs_block_map_shrink+0x64><== NOT EXECUTED
201cad4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
201cad8: 81 c7 e0 08 ret <== NOT EXECUTED
201cadc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201cae0: 82 02 20 08 add %o0, 8, %g1
201cae4: 83 28 60 02 sll %g1, 2, %g1
201cae8: 82 06 40 01 add %i1, %g1, %g1
201caec: d4 00 60 04 ld [ %g1 + 4 ], %o2
201caf0: 90 10 00 1b mov %i3, %o0
201caf4: 92 10 00 12 mov %l2, %o1
201caf8: 40 00 01 2d call 201cfac <rtems_rfs_buffer_handle_request>
201cafc: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
201cb00: 80 a2 20 00 cmp %o0, 0
201cb04: 14 bf ff f5 bg 201cad8 <rtems_rfs_block_map_shrink+0x200> <== NEVER TAKEN
201cb08: 85 2c 20 02 sll %l0, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201cb0c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201cb10: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201cb14: 90 10 00 1b mov %i3, %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,
201cb18: 82 00 c0 02 add %g3, %g2, %g1
201cb1c: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3
201cb20: fa 08 60 03 ldub [ %g1 + 3 ], %i5
201cb24: c4 08 60 01 ldub [ %g1 + 1 ], %g2
201cb28: c2 08 60 02 ldub [ %g1 + 2 ], %g1
201cb2c: 87 28 e0 18 sll %g3, 0x18, %g3
201cb30: 85 28 a0 10 sll %g2, 0x10, %g2
201cb34: 83 28 60 08 sll %g1, 8, %g1
201cb38: ba 17 40 03 or %i5, %g3, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201cb3c: 92 10 00 19 mov %i1, %o1
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201cb40: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201cb44: 94 10 00 12 mov %l2, %o2
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,
201cb48: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201cb4c: 96 10 00 14 mov %l4, %o3
201cb50: 7f ff fc 1b call 201bbbc <rtems_rfs_block_map_indirect_shrink>
201cb54: 98 10 00 10 mov %l0, %o4
singly, direct);
if (rc)
201cb58: 80 a2 20 00 cmp %o0, 0
201cb5c: 22 bf ff 78 be,a 201c93c <rtems_rfs_block_map_shrink+0x64><== ALWAYS TAKEN
201cb60: 90 10 00 1b mov %i3, %o0
201cb64: 30 bf ff dd b,a 201cad8 <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
201cb68: 80 a7 20 00 cmp %i4, 0
201cb6c: 22 80 00 17 be,a 201cbc8 <rtems_rfs_block_map_shrink+0x2f0>
201cb70: c0 26 60 1c clr [ %i1 + 0x1c ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
201cb74: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
201cb78: 80 a0 80 1c cmp %g2, %i4
201cb7c: 1a 80 00 14 bcc 201cbcc <rtems_rfs_block_map_shrink+0x2f4><== NEVER TAKEN
201cb80: 82 07 3f ff add %i4, -1, %g1
201cb84: 80 a0 40 02 cmp %g1, %g2
201cb88: 12 80 00 08 bne 201cba8 <rtems_rfs_block_map_shrink+0x2d0><== NEVER TAKEN
201cb8c: 90 10 20 00 clr %o0
201cb90: c2 06 60 0c ld [ %i1 + 0xc ], %g1
201cb94: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
201cb98: 80 a0 80 01 cmp %g2, %g1
201cb9c: 38 80 00 0e bgu,a 201cbd4 <rtems_rfs_block_map_shrink+0x2fc><== ALWAYS TAKEN
201cba0: f8 26 60 10 st %i4, [ %i1 + 0x10 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
return 0;
201cba4: 90 10 20 00 clr %o0
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
201cba8: 81 c7 e0 08 ret
201cbac: 91 e8 00 08 restore %g0, %o0, %o0
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
201cbb0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201cbb4: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201cbb8: 40 00 1f 3d call 20248ac <printf> <== NOT EXECUTED
201cbbc: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 2035de0 <CSWTCH.2+0xcc> <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
201cbc0: 10 bf ff 4f b 201c8fc <rtems_rfs_block_map_shrink+0x24> <== NOT EXECUTED
201cbc4: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
}
if (map->size.count == 0)
{
map->last_map_block = 0;
map->last_data_block = 0;
201cbc8: c0 26 60 20 clr [ %i1 + 0x20 ]
201cbcc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
201cbd0: f8 26 60 10 st %i4, [ %i1 + 0x10 ]
201cbd4: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
201cbd8: 80 a0 60 00 cmp %g1, 0
201cbdc: 02 bf ff f2 be 201cba4 <rtems_rfs_block_map_shrink+0x2cc> <== ALWAYS TAKEN
201cbe0: c0 26 60 18 clr [ %i1 + 0x18 ]
201cbe4: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
return 0;
201cbe8: 90 10 20 00 clr %o0 <== NOT EXECUTED
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
201cbec: f8 26 60 10 st %i4, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
}
201cbf0: 81 c7 e0 08 ret <== NOT EXECUTED
201cbf4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02022df4 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
2022df4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
2022df8: 90 10 20 00 clr %o0
2022dfc: 7f ff c7 0e call 2014a34 <rtems_rfs_trace>
2022e00: 92 10 20 40 mov 0x40, %o1
2022e04: 80 8a 20 ff btst 0xff, %o0
2022e08: 02 80 00 0b be 2022e34 <rtems_rfs_buffer_bdbuf_release+0x40><== ALWAYS TAKEN
2022e0c: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
2022e10: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
2022e14: 12 80 00 18 bne 2022e74 <rtems_rfs_buffer_bdbuf_release+0x80><== NOT EXECUTED
2022e18: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
2022e1c: 17 00 80 cc sethi %hi(0x2033000), %o3 <== NOT EXECUTED
2022e20: 96 12 e3 d0 or %o3, 0x3d0, %o3 ! 20333d0 <__FUNCTION__.7127+0x438><== NOT EXECUTED
2022e24: 11 00 80 dd sethi %hi(0x2037400), %o0 <== NOT EXECUTED
2022e28: 40 00 06 a1 call 20248ac <printf> <== NOT EXECUTED
2022e2c: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 20375f0 <rtems_termios_baud_table+0x110><== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
2022e30: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2022e34: 02 80 00 09 be 2022e58 <rtems_rfs_buffer_bdbuf_release+0x64>
2022e38: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
2022e3c: 7f ff d0 be call 2017134 <rtems_bdbuf_release_modified>
2022e40: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
2022e44: 80 a0 00 08 cmp %g0, %o0
2022e48: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
2022e4c: b0 0e 20 05 and %i0, 5, %i0
2022e50: 81 c7 e0 08 ret
2022e54: 81 e8 00 00 restore
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
2022e58: 7f ff d0 7f call 2017054 <rtems_bdbuf_release>
2022e5c: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
2022e60: 80 a0 00 08 cmp %g0, %o0
2022e64: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
2022e68: b0 0e 20 05 and %i0, 5, %i0
2022e6c: 81 c7 e0 08 ret
2022e70: 81 e8 00 00 restore
{
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
2022e74: 17 00 80 dd sethi %hi(0x2037400), %o3 <== NOT EXECUTED
2022e78: 10 bf ff eb b 2022e24 <rtems_rfs_buffer_bdbuf_release+0x30><== NOT EXECUTED
2022e7c: 96 12 e1 e0 or %o3, 0x1e0, %o3 ! 20375e0 <rtems_termios_baud_table+0x100><== NOT EXECUTED
0201d67c <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
201d67c: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201d680: 90 10 20 00 clr %o0
201d684: 92 10 20 10 mov 0x10, %o1
201d688: 7f ff dc eb call 2014a34 <rtems_rfs_trace>
201d68c: ba 10 00 18 mov %i0, %i5
201d690: 80 8a 20 ff btst 0xff, %o0
201d694: 12 80 00 15 bne 201d6e8 <rtems_rfs_buffer_close+0x6c> <== NEVER TAKEN
201d698: 11 00 80 d8 sethi %hi(0x2036000), %o0
/*
* 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));
201d69c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
201d6a0: 90 10 00 1d mov %i5, %o0
201d6a4: 7f ff ff ad call 201d558 <rtems_rfs_buffer_setblksize>
201d6a8: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201d6ac: b0 92 20 00 orcc %o0, 0, %i0
201d6b0: 04 80 00 07 ble 201d6cc <rtems_rfs_buffer_close+0x50> <== ALWAYS TAKEN
201d6b4: 90 10 20 00 clr %o0
201d6b8: 7f ff dc df call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d6bc: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
201d6c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d6c4: 12 80 00 1f bne 201d740 <rtems_rfs_buffer_close+0xc4> <== NOT EXECUTED
201d6c8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
if (close (fs->device) < 0)
201d6cc: 7f ff ab 92 call 2008514 <close>
201d6d0: d0 07 60 0c ld [ %i5 + 0xc ], %o0
201d6d4: 80 a2 20 00 cmp %o0, 0
201d6d8: 06 80 00 08 bl 201d6f8 <rtems_rfs_buffer_close+0x7c> <== NEVER TAKEN
201d6dc: 01 00 00 00 nop
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
rc, strerror (rc));
}
return rc;
}
201d6e0: 81 c7 e0 08 ret
201d6e4: 81 e8 00 00 restore
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: closing\n");
201d6e8: 40 00 1d 09 call 2024b0c <puts> <== NOT EXECUTED
201d6ec: 90 12 22 b8 or %o0, 0x2b8, %o0 <== 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));
201d6f0: 10 bf ff ec b 201d6a0 <rtems_rfs_buffer_close+0x24> <== NOT EXECUTED
201d6f4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== 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;
201d6f8: 40 00 16 dc call 2023268 <__errno> <== NOT EXECUTED
201d6fc: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201d700: 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;
201d704: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201d708: 7f ff dc cb call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d70c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201d710: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d714: 02 80 00 09 be 201d738 <rtems_rfs_buffer_close+0xbc> <== NOT EXECUTED
201d718: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
201d71c: 40 00 20 ae call 20259d4 <strerror> <== NOT EXECUTED
201d720: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201d724: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201d728: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201d72c: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d730: 40 00 1c 5f call 20248ac <printf> <== NOT EXECUTED
201d734: 90 12 23 20 or %o0, 0x320, %o0 ! 2036320 <CSWTCH.2+0x60c> <== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
201d738: 81 c7 e0 08 ret <== NOT EXECUTED
201d73c: 81 e8 00 00 restore <== NOT EXECUTED
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
201d740: 40 00 20 a5 call 20259d4 <strerror> <== NOT EXECUTED
201d744: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201d748: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201d74c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201d750: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d754: 40 00 1c 56 call 20248ac <printf> <== NOT EXECUTED
201d758: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 20362e0 <CSWTCH.2+0x5cc> <== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
201d75c: 7f ff ab 6e call 2008514 <close> <== NOT EXECUTED
201d760: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
201d764: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201d768: 16 bf ff f4 bge 201d738 <rtems_rfs_buffer_close+0xbc> <== NOT EXECUTED
201d76c: 01 00 00 00 nop <== NOT EXECUTED
201d770: 30 bf ff e2 b,a 201d6f8 <rtems_rfs_buffer_close+0x7c> <== NOT EXECUTED
0201cdc4 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
201cdc4: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
201cdc8: c2 06 60 08 ld [ %i1 + 8 ], %g1
201cdcc: 80 a0 60 00 cmp %g1, 0
201cdd0: 02 80 00 13 be 201ce1c <rtems_rfs_buffer_handle_release+0x58>
201cdd4: b8 10 20 00 clr %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
201cdd8: 90 10 20 00 clr %o0
201cddc: 7f ff df 16 call 2014a34 <rtems_rfs_trace>
201cde0: 92 10 22 00 mov 0x200, %o1
201cde4: 80 8a 20 ff btst 0xff, %o0
201cde8: 32 80 00 0f bne,a 201ce24 <rtems_rfs_buffer_handle_release+0x60><== NEVER TAKEN
201cdec: c2 0e 40 00 ldub [ %i1 ], %g1 <== 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)
201cdf0: d0 06 60 08 ld [ %i1 + 8 ], %o0
201cdf4: fa 02 20 30 ld [ %o0 + 0x30 ], %i5
201cdf8: 80 a7 60 00 cmp %i5, 0
201cdfc: 04 80 00 05 ble 201ce10 <rtems_rfs_buffer_handle_release+0x4c><== NEVER TAKEN
201ce00: 01 00 00 00 nop
rtems_rfs_buffer_refs_down (handle);
201ce04: ba 07 7f ff add %i5, -1, %i5
201ce08: fa 22 20 30 st %i5, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
201ce0c: 80 a7 60 00 cmp %i5, 0
201ce10: 02 80 00 15 be 201ce64 <rtems_rfs_buffer_handle_release+0xa0>
201ce14: b8 10 20 00 clr %i4
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
201ce18: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
201ce1c: 81 c7 e0 08 ret
201ce20: 91 e8 00 1c restore %g0, %i4, %o0
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",
201ce24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201ce28: 12 80 00 28 bne 201cec8 <rtems_rfs_buffer_handle_release+0x104><== NOT EXECUTED
201ce2c: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== 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" : "");
201ce30: 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",
201ce34: 15 00 80 cc sethi %hi(0x2033000), %o2 <== 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" : "");
201ce38: 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",
201ce3c: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
201ce40: 12 80 00 28 bne 201cee0 <rtems_rfs_buffer_handle_release+0x11c><== NOT EXECUTED
201ce44: 94 12 a3 d0 or %o2, 0x3d0, %o2 <== NOT EXECUTED
201ce48: 19 00 80 d7 sethi %hi(0x2035c00), %o4 <== NOT EXECUTED
201ce4c: 98 13 22 b0 or %o4, 0x2b0, %o4 ! 2035eb0 <CSWTCH.2+0x19c> <== NOT EXECUTED
201ce50: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201ce54: 40 00 1e 96 call 20248ac <printf> <== NOT EXECUTED
201ce58: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 2035ec0 <CSWTCH.2+0x1ac> <== 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)
201ce5c: 10 bf ff e6 b 201cdf4 <rtems_rfs_buffer_handle_release+0x30><== NOT EXECUTED
201ce60: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
201ce64: 7f ff f3 4a call 2019b8c <_Chain_Extract>
201ce68: 01 00 00 00 nop
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
201ce6c: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
if (rtems_rfs_fs_no_local_cache (fs))
201ce70: c2 06 00 00 ld [ %i0 ], %g1
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
201ce74: 84 00 bf ff add %g2, -1, %g2
if (rtems_rfs_fs_no_local_cache (fs))
201ce78: 80 88 60 02 btst 2, %g1
201ce7c: 12 80 00 1c bne 201ceec <rtems_rfs_buffer_handle_release+0x128>
201ce80: c4 26 20 50 st %g2, [ %i0 + 0x50 ]
* 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 +
201ce84: c6 06 20 70 ld [ %i0 + 0x70 ], %g3
201ce88: c4 06 20 60 ld [ %i0 + 0x60 ], %g2
201ce8c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
201ce90: 84 00 c0 02 add %g3, %g2, %g2
201ce94: 80 a0 80 01 cmp %g2, %g1
201ce98: 1a 80 00 21 bcc 201cf1c <rtems_rfs_buffer_handle_release+0x158>
201ce9c: b8 10 00 1d mov %i5, %i4
}
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
}
if (rtems_rfs_buffer_dirty (handle))
201cea0: c2 0e 40 00 ldub [ %i1 ], %g1
201cea4: 80 a0 60 00 cmp %g1, 0
201cea8: 02 80 00 17 be 201cf04 <rtems_rfs_buffer_handle_release+0x140>
201ceac: 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 );
201ceb0: 7f ff c4 d2 call 200e1f8 <_Chain_Append>
201ceb4: 90 06 20 64 add %i0, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
201ceb8: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
201cebc: 82 00 60 01 inc %g1
201cec0: 10 bf ff d6 b 201ce18 <rtems_rfs_buffer_handle_release+0x54>
201cec4: c2 26 20 70 st %g1, [ %i0 + 0x70 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
201cec8: 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",
201cecc: 15 00 80 d7 sethi %hi(0x2035c00), %o2 <== 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" : "");
201ced0: 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",
201ced4: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
201ced8: 02 bf ff dc be 201ce48 <rtems_rfs_buffer_handle_release+0x84><== NOT EXECUTED
201cedc: 94 12 a2 a8 or %o2, 0x2a8, %o2 <== NOT EXECUTED
201cee0: 19 00 80 cc sethi %hi(0x2033000), %o4 <== NOT EXECUTED
201cee4: 10 bf ff db b 201ce50 <rtems_rfs_buffer_handle_release+0x8c><== NOT EXECUTED
201cee8: 98 13 23 d0 or %o4, 0x3d0, %o4 ! 20333d0 <__FUNCTION__.7127+0x438><== NOT EXECUTED
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
201ceec: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
201cef0: d2 0e 40 00 ldub [ %i1 ], %o1
201cef4: 40 00 17 c0 call 2022df4 <rtems_rfs_buffer_bdbuf_release>
201cef8: c0 22 20 34 clr [ %o0 + 0x34 ]
201cefc: 10 bf ff c7 b 201ce18 <rtems_rfs_buffer_handle_release+0x54>
201cf00: b8 10 00 08 mov %o0, %i4
201cf04: 7f ff c4 bd call 200e1f8 <_Chain_Append>
201cf08: 90 06 20 54 add %i0, 0x54, %o0
fs->release_modified_count++;
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
201cf0c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
201cf10: 82 00 60 01 inc %g1
201cf14: 10 bf ff c1 b 201ce18 <rtems_rfs_buffer_handle_release+0x54>
201cf18: c2 26 20 60 st %g1, [ %i0 + 0x60 ]
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
201cf1c: 90 10 20 00 clr %o0
201cf20: 7f ff de c5 call 2014a34 <rtems_rfs_trace>
201cf24: 92 10 22 00 mov 0x200, %o1
201cf28: 80 8a 20 ff btst 0xff, %o0
201cf2c: 32 80 00 19 bne,a 201cf90 <rtems_rfs_buffer_handle_release+0x1cc><== NEVER TAKEN
201cf30: d2 06 20 70 ld [ %i0 + 0x70 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: buffer-release: local cache overflow:"
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
201cf34: c4 06 20 60 ld [ %i0 + 0x60 ], %g2
201cf38: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
201cf3c: 80 a0 80 01 cmp %g2, %g1
201cf40: 08 80 00 0d bleu 201cf74 <rtems_rfs_buffer_handle_release+0x1b0>
201cf44: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
201cf48: 7f ff c4 b7 call 200e224 <_Chain_Get>
201cf4c: 90 06 20 54 add %i0, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
201cf50: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
modified = false;
201cf54: 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--;
201cf58: 82 00 7f ff add %g1, -1, %g1
201cf5c: c2 26 20 60 st %g1, [ %i0 + 0x60 ]
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
201cf60: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
201cf64: 40 00 17 a4 call 2022df4 <rtems_rfs_buffer_bdbuf_release>
201cf68: 92 0a 60 01 and %o1, 1, %o1
201cf6c: 10 bf ff cd b 201cea0 <rtems_rfs_buffer_handle_release+0xdc>
201cf70: b8 10 00 08 mov %o0, %i4
201cf74: 7f ff c4 ac call 200e224 <_Chain_Get>
201cf78: 90 06 20 64 add %i0, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
201cf7c: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
modified = true;
201cf80: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
201cf84: 82 00 7f ff add %g1, -1, %g1
201cf88: 10 bf ff f6 b 201cf60 <rtems_rfs_buffer_handle_release+0x19c>
201cf8c: c2 26 20 70 st %g1, [ %i0 + 0x70 ]
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: local cache overflow:"
201cf90: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 <== NOT EXECUTED
201cf94: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201cf98: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
201cf9c: 40 00 1e 44 call 20248ac <printf> <== NOT EXECUTED
201cfa0: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
201cfa4: 10 bf ff e5 b 201cf38 <rtems_rfs_buffer_handle_release+0x174><== NOT EXECUTED
201cfa8: c4 06 20 60 ld [ %i0 + 0x60 ], %g2 <== NOT EXECUTED
0201cfac <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)
{
201cfac: 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))
201cfb0: c2 06 60 08 ld [ %i1 + 8 ], %g1
201cfb4: 80 a0 60 00 cmp %g1, 0
201cfb8: 02 80 00 17 be 201d014 <rtems_rfs_buffer_handle_request+0x68>
201cfbc: 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))
201cfc0: 80 a6 a0 00 cmp %i2, 0
201cfc4: 02 80 00 06 be 201cfdc <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
201cfc8: 90 10 20 00 clr %o0
201cfcc: c2 06 60 04 ld [ %i1 + 4 ], %g1
201cfd0: 80 a0 40 1a cmp %g1, %i2
201cfd4: 02 80 00 40 be 201d0d4 <rtems_rfs_buffer_handle_request+0x128>
201cfd8: 01 00 00 00 nop
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201cfdc: 7f ff de 96 call 2014a34 <rtems_rfs_trace>
201cfe0: 92 10 21 00 mov 0x100, %o1 ! 100 <PROM_START+0x100>
201cfe4: 80 8a 20 ff btst 0xff, %o0
201cfe8: 32 80 00 3d bne,a 201d0dc <rtems_rfs_buffer_handle_request+0x130><== NEVER TAKEN
201cfec: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
201cff0: 90 10 00 1d mov %i5, %o0
201cff4: 7f ff ff 74 call 201cdc4 <rtems_rfs_buffer_handle_release>
201cff8: 92 10 00 19 mov %i1, %o1
if (rc > 0)
201cffc: b0 92 20 00 orcc %o0, 0, %i0
201d000: 24 80 00 04 ble,a 201d010 <rtems_rfs_buffer_handle_request+0x64><== ALWAYS TAKEN
201d004: c0 2e 40 00 clrb [ %i1 ]
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;
}
201d008: 81 c7 e0 08 ret <== NOT EXECUTED
201d00c: 81 e8 00 00 restore <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, handle);
if (rc > 0)
return rc;
handle->dirty = false;
handle->bnum = 0;
201d010: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201d014: 90 10 20 00 clr %o0
201d018: 7f ff de 87 call 2014a34 <rtems_rfs_trace>
201d01c: 92 10 21 00 mov 0x100, %o1
201d020: 80 8a 20 ff btst 0xff, %o0
201d024: 32 80 00 5b bne,a 201d190 <rtems_rfs_buffer_handle_request+0x1e4><== NEVER TAKEN
201d028: 92 10 00 1a mov %i2, %o1 <== 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)
201d02c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
201d030: 80 a0 60 00 cmp %g1, 0
201d034: 12 80 00 44 bne 201d144 <rtems_rfs_buffer_handle_request+0x198>
201d038: 90 07 60 44 add %i5, 0x44, %o0
201d03c: c2 06 60 08 ld [ %i1 + 8 ], %g1
/*
* 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) &&
201d040: c4 07 40 00 ld [ %i5 ], %g2
201d044: 80 88 a0 02 btst 2, %g2
201d048: 02 80 00 2a be 201d0f0 <rtems_rfs_buffer_handle_request+0x144>
201d04c: 80 a0 60 00 cmp %g1, 0
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
201d050: 02 80 00 65 be 201d1e4 <rtems_rfs_buffer_handle_request+0x238><== ALWAYS TAKEN
201d054: 90 10 00 1d mov %i5, %o0
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
201d058: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
201d05c: 92 10 00 01 mov %g1, %o1
201d060: 84 00 a0 01 inc %g2
201d064: 90 07 60 44 add %i5, 0x44, %o0
201d068: 7f ff c4 64 call 200e1f8 <_Chain_Append>
201d06c: c4 20 60 30 st %g2, [ %g1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
201d070: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
handle->buffer->user = (void*) ((intptr_t) block);
201d074: c2 06 60 08 ld [ %i1 + 8 ], %g1
/*
* 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++;
201d078: 84 00 a0 01 inc %g2
201d07c: c4 27 60 50 st %g2, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
201d080: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
201d084: f4 26 60 04 st %i2, [ %i1 + 4 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201d088: 90 10 20 00 clr %o0
201d08c: 7f ff de 6a call 2014a34 <rtems_rfs_trace>
201d090: 92 10 21 00 mov 0x100, %o1
201d094: 80 8a 20 ff btst 0xff, %o0
201d098: 02 80 00 0f be 201d0d4 <rtems_rfs_buffer_handle_request+0x128><== ALWAYS TAKEN
201d09c: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
201d0a0: 02 80 00 41 be 201d1a4 <rtems_rfs_buffer_handle_request+0x1f8><== NOT EXECUTED
201d0a4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
201d0a8: b0 10 20 00 clr %i0 <== 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",
201d0ac: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
201d0b0: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
201d0b4: 15 00 80 d6 sethi %hi(0x2035800), %o2 <== NOT EXECUTED
201d0b8: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d0bc: 94 12 a0 e0 or %o2, 0xe0, %o2 <== NOT EXECUTED
201d0c0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201d0c4: 40 00 1d fa call 20248ac <printf> <== NOT EXECUTED
201d0c8: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
201d0cc: 81 c7 e0 08 ret <== NOT EXECUTED
201d0d0: 81 e8 00 00 restore <== NOT EXECUTED
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
return 0;
201d0d4: 81 c7 e0 08 ret
201d0d8: 91 e8 20 00 restore %g0, 0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
201d0dc: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201d0e0: 40 00 1d f3 call 20248ac <printf> <== NOT EXECUTED
201d0e4: 90 12 23 38 or %o0, 0x338, %o0 ! 2035f38 <CSWTCH.2+0x224> <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
201d0e8: 10 bf ff c3 b 201cff4 <rtems_rfs_buffer_handle_request+0x48><== NOT EXECUTED
201d0ec: 90 10 00 1d mov %i5, %o0 <== 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) &&
201d0f0: 32 bf ff db bne,a 201d05c <rtems_rfs_buffer_handle_request+0xb0>
201d0f4: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
201d0f8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
201d0fc: 80 a0 60 00 cmp %g1, 0
201d100: 12 80 00 5a bne 201d268 <rtems_rfs_buffer_handle_request+0x2bc>
201d104: 90 07 60 54 add %i5, 0x54, %o0
handle->buffer = rtems_rfs_scan_chain (&fs->release,
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
201d108: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
201d10c: 80 a0 60 00 cmp %g1, 0
201d110: 02 80 00 35 be 201d1e4 <rtems_rfs_buffer_handle_request+0x238>
201d114: 90 10 00 1d mov %i5, %o0
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
201d118: 90 07 60 64 add %i5, 0x64, %o0
201d11c: 92 07 60 70 add %i5, 0x70, %o1
201d120: 7f ff fe e1 call 201cca4 <rtems_rfs_scan_chain>
201d124: 94 10 00 1a mov %i2, %o2
201d128: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
201d12c: 80 a2 20 00 cmp %o0, 0
201d130: 02 80 00 2c be 201d1e0 <rtems_rfs_buffer_handle_request+0x234>
201d134: 82 10 00 08 mov %o0, %g1
rtems_rfs_buffer_mark_dirty (handle);
201d138: 84 10 20 01 mov 1, %g2
201d13c: 10 bf ff c7 b 201d058 <rtems_rfs_buffer_handle_request+0xac>
201d140: c4 2e 40 00 stb %g2, [ %i1 ]
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
201d144: 92 07 60 50 add %i5, 0x50, %o1
201d148: 7f ff fe d7 call 201cca4 <rtems_rfs_scan_chain>
201d14c: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
201d150: 80 a2 20 00 cmp %o0, 0
201d154: 02 80 00 1f be 201d1d0 <rtems_rfs_buffer_handle_request+0x224>
201d158: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201d15c: 90 10 20 00 clr %o0
201d160: 7f ff de 35 call 2014a34 <rtems_rfs_trace>
201d164: 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) &&
201d168: 80 8a 20 ff btst 0xff, %o0
201d16c: 02 bf ff b5 be 201d040 <rtems_rfs_buffer_handle_request+0x94><== ALWAYS TAKEN
201d170: c2 06 60 08 ld [ %i1 + 8 ], %g1
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
201d174: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
201d178: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201d17c: 92 02 60 01 inc %o1 <== NOT EXECUTED
201d180: 40 00 1d cb call 20248ac <printf> <== NOT EXECUTED
201d184: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
201d188: 10 bf ff ae b 201d040 <rtems_rfs_buffer_handle_request+0x94><== NOT EXECUTED
201d18c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
201d190: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201d194: 40 00 1d c6 call 20248ac <printf> <== NOT EXECUTED
201d198: 90 12 23 70 or %o0, 0x370, %o0 ! 2035f70 <CSWTCH.2+0x25c> <== 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)
201d19c: 10 bf ff a5 b 201d030 <rtems_rfs_buffer_handle_request+0x84><== NOT EXECUTED
201d1a0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
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;
201d1a4: b0 10 20 00 clr %i0 <== 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",
201d1a8: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
201d1ac: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
201d1b0: 15 00 80 d7 sethi %hi(0x2035c00), %o2 <== NOT EXECUTED
201d1b4: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d1b8: 94 12 a3 30 or %o2, 0x330, %o2 <== NOT EXECUTED
201d1bc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201d1c0: 40 00 1d bb call 20248ac <printf> <== NOT EXECUTED
201d1c4: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
201d1c8: 81 c7 e0 08 ret <== NOT EXECUTED
201d1cc: 81 e8 00 00 restore <== 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) &&
201d1d0: c2 07 40 00 ld [ %i5 ], %g1
201d1d4: 80 88 60 02 btst 2, %g1
201d1d8: 22 bf ff c9 be,a 201d0fc <rtems_rfs_buffer_handle_request+0x150>
201d1dc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
201d1e0: 90 10 00 1d mov %i5, %o0
201d1e4: 92 10 00 1a mov %i2, %o1
201d1e8: 94 10 00 1b mov %i3, %o2
201d1ec: 40 00 16 ee call 2022da4 <rtems_rfs_buffer_bdbuf_request>
201d1f0: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
201d1f4: b0 92 20 00 orcc %o0, 0, %i0
201d1f8: 04 80 00 16 ble 201d250 <rtems_rfs_buffer_handle_request+0x2a4><== ALWAYS TAKEN
201d1fc: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201d200: 7f ff de 0d call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d204: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
201d208: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d20c: 02 bf ff 7f be 201d008 <rtems_rfs_buffer_handle_request+0x5c><== NOT EXECUTED
201d210: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
201d214: 02 80 00 13 be 201d260 <rtems_rfs_buffer_handle_request+0x2b4><== NOT EXECUTED
201d218: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
201d21c: 3b 00 80 d6 sethi %hi(0x2035800), %i5 <== NOT EXECUTED
201d220: ba 17 60 e0 or %i5, 0xe0, %i5 ! 20358e0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201d224: 40 00 21 ec call 20259d4 <strerror> <== NOT EXECUTED
201d228: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201d22c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201d230: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201d234: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201d238: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201d23c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
201d240: 40 00 1d 9b call 20248ac <printf> <== NOT EXECUTED
201d244: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
201d248: 81 c7 e0 08 ret <== NOT EXECUTED
201d24c: 81 e8 00 00 restore <== NOT EXECUTED
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
201d250: c2 06 60 08 ld [ %i1 + 8 ], %g1
201d254: c0 20 60 04 clr [ %g1 + 4 ]
201d258: 10 bf ff 80 b 201d058 <rtems_rfs_buffer_handle_request+0xac>
201d25c: c0 20 40 00 clr [ %g1 ]
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
201d260: 10 bf ff f1 b 201d224 <rtems_rfs_buffer_handle_request+0x278><== NOT EXECUTED
201d264: ba 17 63 30 or %i5, 0x330, %i5 <== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
201d268: 92 07 60 60 add %i5, 0x60, %o1
201d26c: 7f ff fe 8e call 201cca4 <rtems_rfs_scan_chain>
201d270: 94 10 00 1a mov %i2, %o2
201d274: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
201d278: 80 a2 20 00 cmp %o0, 0
201d27c: 12 bf ff 77 bne 201d058 <rtems_rfs_buffer_handle_request+0xac>
201d280: 82 10 00 08 mov %o0, %g1
201d284: 10 bf ff a2 b 201d10c <rtems_rfs_buffer_handle_request+0x160>
201d288: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
0201d28c <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
201d28c: 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))
201d290: 90 10 20 00 clr %o0
201d294: 92 10 20 20 mov 0x20, %o1
201d298: 7f ff dd e7 call 2014a34 <rtems_rfs_trace>
201d29c: ba 10 00 18 mov %i0, %i5
201d2a0: 80 8a 20 ff btst 0xff, %o0
201d2a4: 12 80 00 1b bne 201d310 <rtems_rfs_buffer_open+0x84> <== NEVER TAKEN
201d2a8: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
fs->device = open (name, O_RDWR);
201d2ac: 90 10 00 1d mov %i5, %o0
201d2b0: 7f ff b1 3c call 20097a0 <open>
201d2b4: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
201d2b8: 80 a2 20 00 cmp %o0, 0
201d2bc: 06 80 00 1e bl 201d334 <rtems_rfs_buffer_open+0xa8> <== NEVER TAKEN
201d2c0: d0 26 60 0c st %o0, [ %i1 + 0xc ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
201d2c4: 7f ff ad 7a call 20088ac <fstat>
201d2c8: 92 07 bf b8 add %fp, -72, %o1
201d2cc: 80 a2 20 00 cmp %o0, 0
201d2d0: 06 80 00 3b bl 201d3bc <rtems_rfs_buffer_open+0x130> <== NEVER TAKEN
201d2d4: c4 07 bf c4 ld [ %fp + -60 ], %g2
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
201d2d8: 03 00 00 3c sethi %hi(0xf000), %g1
201d2dc: 84 08 80 01 and %g2, %g1, %g2
201d2e0: 03 00 00 18 sethi %hi(0x6000), %g1
201d2e4: 80 a0 80 01 cmp %g2, %g1
201d2e8: 22 80 00 1e be,a 201d360 <rtems_rfs_buffer_open+0xd4> <== ALWAYS TAKEN
201d2ec: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201d2f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201d2f4: 7f ff dd d0 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d2f8: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201d2fc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d300: 32 80 00 29 bne,a 201d3a4 <rtems_rfs_buffer_open+0x118> <== NOT EXECUTED
201d304: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
201d308: 81 c7 e0 08 ret <== NOT EXECUTED
201d30c: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
int rv;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
201d310: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d314: 40 00 1d 66 call 20248ac <printf> <== NOT EXECUTED
201d318: 90 12 20 48 or %o0, 0x48, %o0 ! 2036048 <CSWTCH.2+0x334> <== NOT EXECUTED
fs->device = open (name, O_RDWR);
201d31c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201d320: 7f ff b1 20 call 20097a0 <open> <== NOT EXECUTED
201d324: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
if (fs->device < 0)
201d328: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201d32c: 16 bf ff e6 bge 201d2c4 <rtems_rfs_buffer_open+0x38> <== NOT EXECUTED
201d330: d0 26 60 0c st %o0, [ %i1 + 0xc ] <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201d334: 90 10 20 00 clr %o0 <== NOT EXECUTED
201d338: 7f ff dd bf call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d33c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201d340: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d344: 02 bf ff f1 be 201d308 <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
201d348: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
201d34c: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
201d350: 40 00 1d ef call 2024b0c <puts> <== NOT EXECUTED
201d354: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
201d358: 81 c7 e0 08 ret <== NOT EXECUTED
201d35c: 81 e8 00 00 restore <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
201d360: 94 06 60 10 add %i1, 0x10, %o2
201d364: 13 10 01 10 sethi %hi(0x40044000), %o1
201d368: 7f ff ad a7 call 2008a04 <ioctl>
201d36c: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <RAM_END+0x3dc44209>
/*
* 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)
201d370: 80 a2 20 00 cmp %o0, 0
201d374: 02 80 00 23 be 201d400 <rtems_rfs_buffer_open+0x174> <== ALWAYS TAKEN
201d378: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201d37c: 7f ff dd ae call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d380: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201d384: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d388: 02 bf ff e0 be 201d308 <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
201d38c: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return ENXIO;
201d390: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
*/
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
if (rv != 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
201d394: 40 00 1d de call 2024b0c <puts> <== NOT EXECUTED
201d398: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
201d39c: 81 c7 e0 08 ret <== NOT EXECUTED
201d3a0: 81 e8 00 00 restore <== NOT EXECUTED
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
201d3a4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d3a8: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d3ac: 40 00 1d 40 call 20248ac <printf> <== NOT EXECUTED
201d3b0: 90 12 20 d0 or %o0, 0xd0, %o0 ! 20360d0 <CSWTCH.2+0x3bc> <== NOT EXECUTED
201d3b4: 81 c7 e0 08 ret <== NOT EXECUTED
201d3b8: 81 e8 00 00 restore <== NOT EXECUTED
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201d3bc: 90 10 20 00 clr %o0 <== NOT EXECUTED
201d3c0: 7f ff dd 9d call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d3c4: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201d3c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d3cc: 02 bf ff cf be 201d308 <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
201d3d0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
201d3d4: 40 00 17 a5 call 2023268 <__errno> <== NOT EXECUTED
201d3d8: b0 10 20 06 mov 6, %i0 ! 6 <PROM_START+0x6> <== 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",
201d3dc: 40 00 21 7e call 20259d4 <strerror> <== NOT EXECUTED
201d3e0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
201d3e4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d3e8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201d3ec: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d3f0: 40 00 1d 2f call 20248ac <printf> <== NOT EXECUTED
201d3f4: 90 12 20 a0 or %o0, 0xa0, %o0 ! 20360a0 <CSWTCH.2+0x38c> <== NOT EXECUTED
201d3f8: 81 c7 e0 08 ret <== NOT EXECUTED
201d3fc: 81 e8 00 00 restore <== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
201d400: 92 10 20 20 mov 0x20, %o1
201d404: 7f ff dd 8c call 2014a34 <rtems_rfs_trace>
201d408: b0 10 20 00 clr %i0
201d40c: 80 8a 20 ff btst 0xff, %o0
201d410: 32 80 00 04 bne,a 201d420 <rtems_rfs_buffer_open+0x194> <== NEVER TAKEN
201d414: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== 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;
}
201d418: 81 c7 e0 08 ret
201d41c: 81 e8 00 00 restore
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",
201d420: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d424: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
201d428: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
201d42c: 40 00 1d 20 call 20248ac <printf> <== NOT EXECUTED
201d430: 90 12 21 38 or %o0, 0x138, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
201d434: 81 c7 e0 08 ret <== NOT EXECUTED
201d438: 81 e8 00 00 restore <== NOT EXECUTED
0201d558 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
201d558: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201d55c: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
201d560: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201d564: 7f ff dd 34 call 2014a34 <rtems_rfs_trace>
201d568: 92 10 24 00 mov 0x400, %o1
201d56c: 80 8a 20 ff btst 0xff, %o0
201d570: 12 80 00 21 bne 201d5f4 <rtems_rfs_buffer_setblksize+0x9c><== NEVER TAKEN
201d574: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
201d578: 7f ff ff d7 call 201d4d4 <rtems_rfs_buffers_release>
201d57c: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201d580: ba 92 20 00 orcc %o0, 0, %i5
201d584: 04 80 00 07 ble 201d5a0 <rtems_rfs_buffer_setblksize+0x48><== ALWAYS TAKEN
201d588: 90 10 20 00 clr %o0
201d58c: 7f ff dd 2a call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d590: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
201d594: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d598: 12 80 00 20 bne 201d618 <rtems_rfs_buffer_setblksize+0xc0><== NOT EXECUTED
201d59c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
201d5a0: 7f ff ff a7 call 201d43c <rtems_rfs_buffer_sync>
201d5a4: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201d5a8: ba 92 20 00 orcc %o0, 0, %i5
201d5ac: 04 80 00 07 ble 201d5c8 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
201d5b0: 90 10 20 00 clr %o0
201d5b4: 7f ff dd 20 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d5b8: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
201d5bc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d5c0: 12 80 00 1e bne 201d638 <rtems_rfs_buffer_setblksize+0xe0><== NOT EXECUTED
201d5c4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
201d5c8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
201d5cc: 13 20 01 10 sethi %hi(0x80044000), %o1
201d5d0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
201d5d4: 92 12 62 04 or %o1, 0x204, %o1
201d5d8: 9f c0 40 00 call %g1
201d5dc: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
201d5e0: b0 92 20 00 orcc %o0, 0, %i0
201d5e4: 06 80 00 08 bl 201d604 <rtems_rfs_buffer_setblksize+0xac> <== NEVER TAKEN
201d5e8: 01 00 00 00 nop
rc = errno;
#endif
return rc;
}
201d5ec: 81 c7 e0 08 ret
201d5f0: 81 e8 00 00 restore
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
201d5f4: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d5f8: 40 00 1c ad call 20248ac <printf> <== NOT EXECUTED
201d5fc: 90 12 22 08 or %o0, 0x208, %o0 ! 2036208 <CSWTCH.2+0x4f4> <== NOT EXECUTED
201d600: 30 bf ff de b,a 201d578 <rtems_rfs_buffer_setblksize+0x20><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
if (rc < 0)
rc = errno;
201d604: 40 00 17 19 call 2023268 <__errno> <== NOT EXECUTED
201d608: 01 00 00 00 nop <== NOT EXECUTED
201d60c: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
201d610: 81 c7 e0 08 ret <== NOT EXECUTED
201d614: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
201d618: 40 00 20 ef call 20259d4 <strerror> <== NOT EXECUTED
201d61c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201d620: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d624: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201d628: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d62c: 40 00 1c a0 call 20248ac <printf> <== NOT EXECUTED
201d630: 90 12 22 38 or %o0, 0x238, %o0 ! 2036238 <CSWTCH.2+0x524> <== NOT EXECUTED
201d634: 30 bf ff db b,a 201d5a0 <rtems_rfs_buffer_setblksize+0x48><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
201d638: 40 00 20 e7 call 20259d4 <strerror> <== NOT EXECUTED
201d63c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201d640: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d644: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201d648: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d64c: 40 00 1c 98 call 20248ac <printf> <== NOT EXECUTED
201d650: 90 12 22 78 or %o0, 0x278, %o0 ! 2036278 <CSWTCH.2+0x564> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
201d654: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
201d658: 13 20 01 10 sethi %hi(0x80044000), %o1 <== NOT EXECUTED
201d65c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED
201d660: 92 12 62 04 or %o1, 0x204, %o1 <== NOT EXECUTED
201d664: 9f c0 40 00 call %g1 <== NOT EXECUTED
201d668: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED
if (rc < 0)
201d66c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201d670: 16 bf ff e8 bge 201d610 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
201d674: 01 00 00 00 nop <== NOT EXECUTED
201d678: 30 bf ff e3 b,a 201d604 <rtems_rfs_buffer_setblksize+0xac><== NOT EXECUTED
0201d43c <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
201d43c: 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))
201d440: 90 10 20 00 clr %o0
201d444: 92 10 20 20 mov 0x20, %o1
201d448: 7f ff dd 7b call 2014a34 <rtems_rfs_trace>
201d44c: ba 10 00 18 mov %i0, %i5
201d450: 80 8a 20 ff btst 0xff, %o0
201d454: 12 80 00 1c bne 201d4c4 <rtems_rfs_buffer_sync+0x88> <== NEVER TAKEN
201d458: 11 00 80 d8 sethi %hi(0x2036000), %o0
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
201d45c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
201d460: 7f ff e7 a7 call 20172fc <rtems_bdbuf_syncdev>
201d464: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
201d468: b8 92 20 00 orcc %o0, 0, %i4
201d46c: 12 80 00 06 bne 201d484 <rtems_rfs_buffer_sync+0x48> <== NEVER TAKEN
201d470: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
201d474: 7f ff 9d 53 call 20049c0 <rtems_disk_release>
201d478: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
201d47c: 81 c7 e0 08 ret
201d480: 81 e8 00 00 restore
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
201d484: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
201d488: 7f ff dd 6b call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d48c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201d490: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d494: 02 bf ff f8 be 201d474 <rtems_rfs_buffer_sync+0x38> <== NOT EXECUTED
201d498: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
201d49c: 7f ff ac 40 call 200859c <rtems_status_text> <== NOT EXECUTED
201d4a0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201d4a4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201d4a8: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d4ac: 40 00 1d 00 call 20248ac <printf> <== NOT EXECUTED
201d4b0: 90 12 21 88 or %o0, 0x188, %o0 ! 2036188 <CSWTCH.2+0x474> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
201d4b4: 7f ff 9d 43 call 20049c0 <rtems_disk_release> <== NOT EXECUTED
201d4b8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
201d4bc: 81 c7 e0 08 ret <== NOT EXECUTED
201d4c0: 81 e8 00 00 restore <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: syncing\n");
201d4c4: 40 00 1d 92 call 2024b0c <puts> <== NOT EXECUTED
201d4c8: 90 12 21 68 or %o0, 0x168, %o0 <== 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));
201d4cc: 10 bf ff e5 b 201d460 <rtems_rfs_buffer_sync+0x24> <== NOT EXECUTED
201d4d0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
0201d4d4 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
201d4d4: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
201d4d8: 90 10 20 00 clr %o0
201d4dc: 7f ff dd 56 call 2014a34 <rtems_rfs_trace>
201d4e0: 92 10 20 40 mov 0x40, %o1
201d4e4: 80 8a 20 ff btst 0xff, %o0
201d4e8: 32 80 00 15 bne,a 201d53c <rtems_rfs_buffers_release+0x68><== NEVER TAKEN
201d4ec: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
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,
201d4f0: 92 06 20 60 add %i0, 0x60, %o1
201d4f4: 94 10 20 00 clr %o2
201d4f8: 7f ff fd c4 call 201cc08 <rtems_rfs_release_chain>
201d4fc: 90 06 20 54 add %i0, 0x54, %o0
201d500: 82 38 00 08 xnor %g0, %o0, %g1
201d504: 83 38 60 1f sra %g1, 0x1f, %g1
201d508: ba 10 00 08 mov %o0, %i5
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
201d50c: 92 06 20 70 add %i0, 0x70, %o1
201d510: ba 0f 40 01 and %i5, %g1, %i5
201d514: 90 06 20 64 add %i0, 0x64, %o0
201d518: 7f ff fd bc call 201cc08 <rtems_rfs_release_chain>
201d51c: 94 10 20 01 mov 1, %o2
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
201d520: 80 a7 60 00 cmp %i5, 0
201d524: 12 80 00 04 bne 201d534 <rtems_rfs_buffers_release+0x60> <== NEVER TAKEN
201d528: 80 a2 20 00 cmp %o0, 0
201d52c: 34 80 00 02 bg,a 201d534 <rtems_rfs_buffers_release+0x60><== NEVER TAKEN
201d530: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rrc = rc;
return rrc;
}
201d534: 81 c7 e0 08 ret
201d538: 91 e8 00 1d restore %g0, %i5, %o0
{
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
201d53c: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
201d540: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
201d544: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d548: 40 00 1c d9 call 20248ac <printf> <== NOT EXECUTED
201d54c: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 20361b8 <CSWTCH.2+0x4a4> <== 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,
201d550: 10 bf ff e9 b 201d4f4 <rtems_rfs_buffers_release+0x20> <== NOT EXECUTED
201d554: 92 06 20 60 add %i0, 0x60, %o1 <== NOT EXECUTED
0201dcb0 <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)
{
201dcb0: 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))
201dcb4: 90 10 20 00 clr %o0
201dcb8: 7f ff db 5f call 2014a34 <rtems_rfs_trace>
201dcbc: 13 08 00 00 sethi %hi(0x20000000), %o1
201dcc0: 80 8a 20 ff btst 0xff, %o0
201dcc4: 32 80 00 7c bne,a 201deb4 <rtems_rfs_dir_add_entry+0x204><== NEVER TAKEN
201dcc8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
201dccc: 90 10 00 18 mov %i0, %o0
201dcd0: 92 10 00 19 mov %i1, %o1
201dcd4: 7f ff f8 b2 call 201bf9c <rtems_rfs_block_map_open>
201dcd8: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201dcdc: ba 92 20 00 orcc %o0, 0, %i5
201dce0: 04 80 00 04 ble 201dcf0 <rtems_rfs_dir_add_entry+0x40> <== ALWAYS TAKEN
201dce4: 29 00 00 3f sethi %hi(0xfc00), %l4
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201dce8: 81 c7 e0 08 ret
201dcec: 91 e8 00 1d restore %g0, %i5, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201dcf0: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201dcf4: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201dcf8: c0 27 bf ac clr [ %fp + -84 ]
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
201dcfc: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
201dd00: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
201dd04: c0 27 bf a0 clr [ %fp + -96 ]
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201dd08: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
201dd0c: a6 06 e0 0a add %i3, 0xa, %l3
/*
* 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);
201dd10: 90 10 00 18 mov %i0, %o0
201dd14: 92 07 bf b0 add %fp, -80, %o1
201dd18: 94 07 bf 98 add %fp, -104, %o2
201dd1c: 7f ff f9 75 call 201c2f0 <rtems_rfs_block_map_find>
201dd20: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
201dd24: ba 92 20 00 orcc %o0, 0, %i5
201dd28: 04 80 00 ae ble 201dfe0 <rtems_rfs_dir_add_entry+0x330>
201dd2c: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
201dd30: 12 80 00 c7 bne 201e04c <rtems_rfs_dir_add_entry+0x39c> <== NEVER TAKEN
201dd34: 90 10 00 18 mov %i0, %o0
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
201dd38: 92 07 bf b0 add %fp, -80, %o1
201dd3c: 94 10 20 01 mov 1, %o2
201dd40: 7f ff f9 f0 call 201c500 <rtems_rfs_block_map_grow>
201dd44: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
201dd48: ba 92 20 00 orcc %o0, 0, %i5
201dd4c: 14 80 00 d1 bg 201e090 <rtems_rfs_dir_add_entry+0x3e0> <== NEVER TAKEN
201dd50: a0 10 20 00 clr %l0
}
read = false;
}
bpos.bno++;
201dd54: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201dd58: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
201dd5c: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201dd60: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
201dd64: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201dd68: 90 10 00 18 mov %i0, %o0
201dd6c: 92 07 bf a4 add %fp, -92, %o1
201dd70: 7f ff fc 8f call 201cfac <rtems_rfs_buffer_handle_request>
201dd74: 96 10 00 10 mov %l0, %o3
if (rc > 0)
201dd78: ba 92 20 00 orcc %o0, 0, %i5
201dd7c: 14 80 00 9b bg 201dfe8 <rtems_rfs_dir_add_entry+0x338> <== NEVER TAKEN
201dd80: c2 07 bf ac ld [ %fp + -84 ], %g1
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
201dd84: 80 a4 20 00 cmp %l0, 0
201dd88: 02 80 00 5e be 201df00 <rtems_rfs_dir_add_entry+0x250>
201dd8c: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201dd90: da 06 20 08 ld [ %i0 + 8 ], %o5
201dd94: 9e 83 7f f6 addcc %o5, -10, %o7
201dd98: 02 bf ff df be 201dd14 <rtems_rfs_dir_add_entry+0x64> <== NEVER TAKEN
201dd9c: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201dda0: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
201dda4: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
201dda8: e4 0f 40 00 ldub [ %i5 ], %l2
201ddac: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
201ddb0: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
201ddb4: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
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);
201ddb8: a1 2c 20 08 sll %l0, 8, %l0
eino = rtems_rfs_dir_entry_ino (entry);
201ddbc: a5 2c a0 18 sll %l2, 0x18, %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);
201ddc0: a0 14 00 04 or %l0, %g4, %l0
eino = rtems_rfs_dir_entry_ino (entry);
201ddc4: 87 28 e0 08 sll %g3, 8, %g3
201ddc8: 83 28 60 10 sll %g1, 0x10, %g1
201ddcc: a4 14 80 03 or %l2, %g3, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201ddd0: 80 a4 00 14 cmp %l0, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201ddd4: a4 14 80 02 or %l2, %g2, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201ddd8: 02 80 00 58 be 201df38 <rtems_rfs_dir_add_entry+0x288>
201dddc: a4 14 80 01 or %l2, %g1, %l2
201dde0: 10 80 00 20 b 201de60 <rtems_rfs_dir_add_entry+0x1b0>
201dde4: a2 10 20 00 clr %l1
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201dde8: 80 a4 00 01 cmp %l0, %g1
201ddec: 1a 80 00 20 bcc 201de6c <rtems_rfs_dir_add_entry+0x1bc> <== NEVER TAKEN
201ddf0: ba 07 40 10 add %i5, %l0, %i5
201ddf4: 80 a4 a0 00 cmp %l2, 0
201ddf8: 02 80 00 1e be 201de70 <rtems_rfs_dir_add_entry+0x1c0> <== NEVER TAKEN
201ddfc: 90 10 20 00 clr %o0
201de00: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
201de04: 80 a0 40 12 cmp %g1, %l2
201de08: 0a 80 00 1a bcs 201de70 <rtems_rfs_dir_add_entry+0x1c0> <== NEVER TAKEN
201de0c: 01 00 00 00 nop
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
201de10: a2 04 40 10 add %l1, %l0, %l1
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201de14: 80 a4 40 0f cmp %l1, %o7
201de18: 1a bf ff be bcc 201dd10 <rtems_rfs_dir_add_entry+0x60> <== NEVER TAKEN
201de1c: 98 10 00 11 mov %l1, %o4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201de20: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
201de24: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
201de28: e4 0f 40 00 ldub [ %i5 ], %l2
201de2c: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
201de30: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
201de34: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
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);
201de38: a1 2c 20 08 sll %l0, 8, %l0
eino = rtems_rfs_dir_entry_ino (entry);
201de3c: a5 2c a0 18 sll %l2, 0x18, %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);
201de40: a0 14 00 04 or %l0, %g4, %l0
eino = rtems_rfs_dir_entry_ino (entry);
201de44: 87 28 e0 10 sll %g3, 0x10, %g3
201de48: 83 28 60 08 sll %g1, 8, %g1
201de4c: a4 14 80 03 or %l2, %g3, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201de50: 80 a4 00 14 cmp %l0, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201de54: a4 14 80 02 or %l2, %g2, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201de58: 02 80 00 39 be 201df3c <rtems_rfs_dir_add_entry+0x28c>
201de5c: a4 14 80 01 or %l2, %g1, %l2
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201de60: 80 a4 20 0a cmp %l0, 0xa
201de64: 34 bf ff e1 bg,a 201dde8 <rtems_rfs_dir_add_entry+0x138> <== ALWAYS TAKEN
201de68: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201de6c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201de70: 7f ff da f1 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201de74: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201de78: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201de7c: 32 80 00 27 bne,a 201df18 <rtems_rfs_dir_add_entry+0x268><== NOT EXECUTED
201de80: d2 06 60 08 ld [ %i1 + 8 ], %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);
201de84: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201de88: 7f ff fb cf call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201de8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201de90: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
201de94: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
201de98: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
201de9c: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
201dea0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201dea4: 7f ff f8 9f call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
201dea8: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201deac: 81 c7 e0 08 ret <== NOT EXECUTED
201deb0: 91 e8 00 1d restore %g0, %i5, %o0 <== 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=",
201deb4: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201deb8: 40 00 1a 7d call 20248ac <printf> <== NOT EXECUTED
201debc: 90 12 22 28 or %o0, 0x228, %o0 ! 2036628 <CSWTCH.2+0x914> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
201dec0: ba 10 20 00 clr %i5 <== NOT EXECUTED
201dec4: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
201dec8: 02 80 00 08 be 201dee8 <rtems_rfs_dir_add_entry+0x238> <== NOT EXECUTED
201decc: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("%c", name[c]);
201ded0: d0 4e 80 01 ldsb [ %i2 + %g1 ], %o0 <== NOT EXECUTED
201ded4: 40 00 1a e0 call 2024a54 <putchar> <== NOT EXECUTED
201ded8: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
201dedc: 80 a7 40 1b cmp %i5, %i3 <== NOT EXECUTED
201dee0: 12 bf ff fc bne 201ded0 <rtems_rfs_dir_add_entry+0x220> <== NOT EXECUTED
201dee4: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
201dee8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201deec: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201def0: 40 00 1a 6f call 20248ac <printf> <== NOT EXECUTED
201def4: 90 12 22 58 or %o0, 0x258, %o0 ! 2036658 <CSWTCH.2+0x944> <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
201def8: 10 bf ff 76 b 201dcd0 <rtems_rfs_dir_add_entry+0x20> <== NOT EXECUTED
201defc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
201df00: d4 06 20 08 ld [ %i0 + 8 ], %o2
201df04: 90 10 00 1d mov %i5, %o0
201df08: 40 00 19 eb call 20246b4 <memset>
201df0c: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201df10: 10 bf ff a1 b 201dd94 <rtems_rfs_dir_add_entry+0xe4>
201df14: da 06 20 08 ld [ %i0 + 8 ], %o5
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
201df18: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201df1c: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201df20: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
201df24: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
201df28: 40 00 1a 61 call 20248ac <printf> <== NOT EXECUTED
201df2c: 90 12 23 40 or %o0, 0x340, %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);
201df30: 10 bf ff d6 b 201de88 <rtems_rfs_dir_add_entry+0x1d8> <== NOT EXECUTED
201df34: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
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))
201df38: 98 10 20 00 clr %o4
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
201df3c: 9a 23 40 0c sub %o5, %o4, %o5
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) <
201df40: 80 a4 c0 0d cmp %l3, %o5
201df44: 3a bf ff 74 bcc,a 201dd14 <rtems_rfs_dir_add_entry+0x64> <== NEVER TAKEN
201df48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
201df4c: 92 10 00 1b mov %i3, %o1
201df50: 40 00 13 d9 call 2022eb4 <rtems_rfs_dir_hash>
201df54: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
201df58: 83 32 20 08 srl %o0, 8, %g1
201df5c: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
201df60: 83 37 20 10 srl %i4, 0x10, %g1
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);
201df64: 85 32 20 10 srl %o0, 0x10, %g2
rtems_rfs_dir_set_entry_ino (entry, ino);
201df68: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
201df6c: 83 37 20 08 srl %i4, 8, %g1
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);
201df70: 87 32 20 18 srl %o0, 0x18, %g3
201df74: c4 2f 60 05 stb %g2, [ %i5 + 5 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
201df78: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
201df7c: 85 37 20 18 srl %i4, 0x18, %g2
rtems_rfs_dir_set_entry_length (entry,
201df80: 83 34 e0 08 srl %l3, 8, %g1
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);
201df84: c6 2f 60 04 stb %g3, [ %i5 + 4 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
201df88: c4 2f 40 00 stb %g2, [ %i5 ]
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
201df8c: 94 10 00 1b mov %i3, %o2
201df90: 92 10 00 1a mov %i2, %o1
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);
201df94: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
201df98: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
rtems_rfs_dir_set_entry_length (entry,
201df9c: e6 2f 60 09 stb %l3, [ %i5 + 9 ]
201dfa0: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
201dfa4: 40 00 19 35 call 2024478 <memcpy>
201dfa8: 90 07 60 0a add %i5, 0xa, %o0
rtems_rfs_buffer_mark_dirty (&buffer);
201dfac: 82 10 20 01 mov 1, %g1
201dfb0: 92 07 bf a4 add %fp, -92, %o1
201dfb4: 90 10 00 18 mov %i0, %o0
201dfb8: 7f ff fb 83 call 201cdc4 <rtems_rfs_buffer_handle_release>
201dfbc: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201dfc0: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
201dfc4: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201dfc8: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201dfcc: c0 27 bf ac clr [ %fp + -84 ]
201dfd0: 92 07 bf b0 add %fp, -80, %o1
201dfd4: 7f ff f8 53 call 201c120 <rtems_rfs_block_map_close>
201dfd8: ba 10 20 00 clr %i5
201dfdc: 30 bf ff 43 b,a 201dce8 <rtems_rfs_dir_add_entry+0x38>
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
201dfe0: 10 bf ff 5d b 201dd54 <rtems_rfs_dir_add_entry+0xa4>
201dfe4: a0 10 20 01 mov 1, %l0
bpos.bno++;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201dfe8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201dfec: 7f ff da 92 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201dff0: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201dff4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dff8: 22 80 00 0c be,a 201e028 <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
201dffc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201e000: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201e004: 40 00 1e 74 call 20259d4 <strerror> <== NOT EXECUTED
201e008: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e00c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201e010: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201e014: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201e018: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201e01c: 40 00 1a 24 call 20248ac <printf> <== NOT EXECUTED
201e020: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 20366f8 <CSWTCH.2+0x9e4> <== 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);
201e024: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201e028: 7f ff fb 67 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201e02c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201e030: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
201e034: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
201e038: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
201e03c: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
201e040: 7f ff f8 38 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
201e044: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201e048: 30 bf ff 28 b,a 201dce8 <rtems_rfs_dir_add_entry+0x38> <== NOT EXECUTED
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
if (rc > 0)
{
if (rc != ENXIO)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201e04c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e050: 7f ff da 79 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201e054: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201e058: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e05c: 22 bf ff f3 be,a 201e028 <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
201e060: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201e064: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201e068: 40 00 1e 5b call 20259d4 <strerror> <== NOT EXECUTED
201e06c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e070: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201e074: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201e078: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201e07c: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201e080: 40 00 1a 0b call 20248ac <printf> <== NOT EXECUTED
201e084: 90 12 22 68 or %o0, 0x268, %o0 ! 2036668 <CSWTCH.2+0x954> <== 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);
201e088: 10 bf ff e8 b 201e028 <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
201e08c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201e090: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e094: 7f ff da 68 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201e098: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201e09c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e0a0: 22 bf ff e2 be,a 201e028 <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
201e0a4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201e0a8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201e0ac: 40 00 1e 4a call 20259d4 <strerror> <== NOT EXECUTED
201e0b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e0b4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201e0b8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201e0bc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201e0c0: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201e0c4: 40 00 19 fa call 20248ac <printf> <== NOT EXECUTED
201e0c8: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 20366b0 <CSWTCH.2+0x99c> <== NOT EXECUTED
201e0cc: 10 bf ff d7 b 201e028 <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
201e0d0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
0201e0d4 <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)
{
201e0d4: 9d e3 bf 40 save %sp, -192, %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))
201e0d8: 90 10 20 00 clr %o0
201e0dc: 13 10 00 00 sethi %hi(0x40000000), %o1
201e0e0: 7f ff da 55 call 2014a34 <rtems_rfs_trace>
201e0e4: a2 10 00 18 mov %i0, %l1
201e0e8: 80 8a 20 ff btst 0xff, %o0
201e0ec: 12 80 00 0a bne 201e114 <rtems_rfs_dir_del_entry+0x40> <== NEVER TAKEN
201e0f0: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
201e0f4: 90 10 00 11 mov %l1, %o0
201e0f8: 7f ff f7 a9 call 201bf9c <rtems_rfs_block_map_open>
201e0fc: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201e100: b0 92 20 00 orcc %o0, 0, %i0
201e104: 04 80 00 11 ble 201e148 <rtems_rfs_dir_del_entry+0x74> <== ALWAYS TAKEN
201e108: 90 10 00 11 mov %l1, %o0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201e10c: 81 c7 e0 08 ret <== NOT EXECUTED
201e110: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
201e114: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201e118: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201e11c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
201e120: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201e124: 40 00 19 e2 call 20248ac <printf> <== NOT EXECUTED
201e128: 90 12 23 88 or %o0, 0x388, %o0 ! 2036788 <CSWTCH.2+0xa74> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
201e12c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
201e130: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201e134: 7f ff f7 9a call 201bf9c <rtems_rfs_block_map_open> <== NOT EXECUTED
201e138: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
201e13c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201e140: 14 bf ff f3 bg 201e10c <rtems_rfs_dir_del_entry+0x38> <== NOT EXECUTED
201e144: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
201e148: 92 07 bf b0 add %fp, -80, %o1
201e14c: 94 10 20 00 clr %o2
201e150: 96 10 00 1b mov %i3, %o3
201e154: 7f ff f8 c1 call 201c458 <rtems_rfs_block_map_seek>
201e158: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
201e15c: b0 92 20 00 orcc %o0, 0, %i0
201e160: 04 80 00 09 ble 201e184 <rtems_rfs_dir_del_entry+0xb0> <== ALWAYS TAKEN
201e164: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
201e168: 22 80 00 02 be,a 201e170 <rtems_rfs_dir_del_entry+0x9c> <== NOT EXECUTED
201e16c: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
201e170: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
201e174: 7f ff f7 eb call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
201e178: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201e17c: 81 c7 e0 08 ret <== NOT EXECUTED
201e180: 81 e8 00 00 restore <== 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)
201e184: 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)
201e188: 29 00 00 3f sethi %hi(0xfc00), %l4
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201e18c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201e190: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201e194: c0 27 bf ac clr [ %fp + -84 ]
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
201e198: a6 60 3f ff subx %g0, -1, %l3
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201e19c: a8 15 23 ff or %l4, 0x3ff, %l4
while (rc == 0)
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201e1a0: d4 07 bf a0 ld [ %fp + -96 ], %o2
201e1a4: 90 10 00 11 mov %l1, %o0
201e1a8: 92 07 bf a4 add %fp, -92, %o1
201e1ac: 7f ff fb 80 call 201cfac <rtems_rfs_buffer_handle_request>
201e1b0: 96 10 20 01 mov 1, %o3
if (rc > 0)
201e1b4: b0 92 20 00 orcc %o0, 0, %i0
201e1b8: 14 80 00 cc bg 201e4e8 <rtems_rfs_dir_del_entry+0x414> <== NEVER TAKEN
201e1bc: 80 a4 e0 00 cmp %l3, 0
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
201e1c0: 02 80 00 63 be 201e34c <rtems_rfs_dir_del_entry+0x278> <== ALWAYS TAKEN
201e1c4: ea 04 60 08 ld [ %l1 + 8 ], %l5
201e1c8: 90 10 20 00 clr %o0 <== NOT EXECUTED
eoffset = 0;
201e1cc: a4 10 20 00 clr %l2 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
201e1d0: c2 07 bf ac ld [ %fp + -84 ], %g1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201e1d4: 9e 05 7f f6 add %l5, -10, %o7
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
201e1d8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201e1dc: 80 a3 c0 08 cmp %o7, %o0
201e1e0: 08 80 00 33 bleu 201e2ac <rtems_rfs_dir_del_entry+0x1d8> <== NEVER TAKEN
201e1e4: ba 00 40 08 add %g1, %o0, %i5
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201e1e8: f8 0f 60 08 ldub [ %i5 + 8 ], %i4
201e1ec: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
201e1f0: e0 0f 60 01 ldub [ %i5 + 1 ], %l0
201e1f4: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
201e1f8: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
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);
201e1fc: b9 2f 20 08 sll %i4, 8, %i4
eino = rtems_rfs_dir_entry_ino (entry);
201e200: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
201e204: a1 2c 20 10 sll %l0, 0x10, %l0
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);
201e208: b8 17 00 04 or %i4, %g4, %i4
eino = rtems_rfs_dir_entry_ino (entry);
201e20c: 87 28 e0 08 sll %g3, 8, %g3
201e210: 10 80 00 22 b 201e298 <rtems_rfs_dir_del_entry+0x1c4>
201e214: 83 28 60 18 sll %g1, 0x18, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201e218: 80 a7 20 0a cmp %i4, 0xa
201e21c: 04 80 00 33 ble 201e2e8 <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
201e220: 90 10 20 00 clr %o0
201e224: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
201e228: 80 a7 00 01 cmp %i4, %g1
201e22c: 1a 80 00 2f bcc 201e2e8 <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
201e230: 80 a4 20 00 cmp %l0, 0
201e234: 02 80 00 2d be 201e2e8 <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
201e238: 01 00 00 00 nop
201e23c: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
201e240: 80 a0 40 10 cmp %g1, %l0
201e244: 0a 80 00 29 bcs 201e2e8 <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
201e248: 80 a6 80 10 cmp %i2, %l0
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
201e24c: 02 80 00 45 be 201e360 <rtems_rfs_dir_del_entry+0x28c> <== ALWAYS TAKEN
201e250: 80 a4 e0 00 cmp %l3, 0
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
201e254: 22 80 00 33 be,a 201e320 <rtems_rfs_dir_del_entry+0x24c> <== NOT EXECUTED
201e258: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
201e25c: a4 04 80 1c add %l2, %i4, %l2 <== 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))
201e260: 80 a4 80 0f cmp %l2, %o7 <== NOT EXECUTED
201e264: 1a 80 00 12 bcc 201e2ac <rtems_rfs_dir_del_entry+0x1d8> <== NOT EXECUTED
201e268: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201e26c: f8 0f 60 08 ldub [ %i5 + 8 ], %i4 <== NOT EXECUTED
201e270: c8 0f 60 09 ldub [ %i5 + 9 ], %g4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
201e274: e0 0f 40 00 ldub [ %i5 ], %l0 <== NOT EXECUTED
201e278: c6 0f 60 01 ldub [ %i5 + 1 ], %g3 <== NOT EXECUTED
201e27c: c2 0f 60 02 ldub [ %i5 + 2 ], %g1 <== NOT EXECUTED
201e280: c4 0f 60 03 ldub [ %i5 + 3 ], %g2 <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201e284: b9 2f 20 08 sll %i4, 8, %i4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
201e288: a1 2c 20 18 sll %l0, 0x18, %l0 <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201e28c: b8 17 00 04 or %i4, %g4, %i4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
201e290: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
201e294: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201e298: a0 14 00 03 or %l0, %g3, %l0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201e29c: 80 a7 00 14 cmp %i4, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201e2a0: a0 14 00 02 or %l0, %g2, %l0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201e2a4: 12 bf ff dd bne 201e218 <rtems_rfs_dir_del_entry+0x144> <== ALWAYS TAKEN
201e2a8: a0 14 00 01 or %l0, %g1, %l0
entry += elength;
eoffset += elength;
}
if (rc == 0)
201e2ac: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201e2b0: 12 80 00 1d bne 201e324 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
201e2b4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201e2b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
201e2bc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201e2c0: 7f ff f8 83 call 201c4cc <rtems_rfs_block_map_next_block> <== NOT EXECUTED
201e2c4: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED
if (rc == ENXIO)
201e2c8: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
201e2cc: 02 80 00 85 be 201e4e0 <rtems_rfs_dir_del_entry+0x40c> <== NOT EXECUTED
201e2d0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
201e2d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201e2d8: 02 bf ff b3 be 201e1a4 <rtems_rfs_dir_del_entry+0xd0> <== NOT EXECUTED
201e2dc: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== 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);
201e2e0: 10 80 00 11 b 201e324 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
201e2e4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201e2e8: 7f ff d9 d3 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201e2ec: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201e2f0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e2f4: 22 80 00 0b be,a 201e320 <rtems_rfs_dir_del_entry+0x24c> <== NOT EXECUTED
201e2f8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201e2fc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201e300: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
201e304: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201e308: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201e30c: 90 12 20 10 or %o0, 0x10, %o0 <== NOT EXECUTED
201e310: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
201e314: 40 00 19 66 call 20248ac <printf> <== NOT EXECUTED
201e318: 9a 10 00 12 mov %l2, %o5 <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
201e31c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201e320: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201e324: 7f ff fa a8 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201e328: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201e32c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
201e330: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
201e334: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
201e338: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
201e33c: 7f ff f7 79 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
201e340: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201e344: 81 c7 e0 08 ret <== NOT EXECUTED
201e348: 81 e8 00 00 restore <== NOT EXECUTED
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
201e34c: 90 10 00 1b mov %i3, %o0
201e350: 40 00 49 b6 call 2030a28 <.urem>
201e354: 92 10 00 15 mov %l5, %o1
201e358: 10 bf ff 9e b 201e1d0 <rtems_rfs_dir_del_entry+0xfc>
201e35c: a4 10 00 08 mov %o0, %l2
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
201e360: 82 07 00 12 add %i4, %l2, %g1
memmove (entry, entry + elength, remaining);
201e364: 92 07 40 1c add %i5, %i4, %o1
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
201e368: aa 25 40 01 sub %l5, %g1, %l5
memmove (entry, entry + elength, remaining);
201e36c: 90 10 00 1d mov %i5, %o0
201e370: 40 00 18 7f call 202456c <memmove>
201e374: 94 10 00 15 mov %l5, %o2
memset (entry + remaining, 0xff, elength);
201e378: 92 10 20 ff mov 0xff, %o1
201e37c: 94 10 00 1c mov %i4, %o2
201e380: 40 00 18 cd call 20246b4 <memset>
201e384: 90 07 40 15 add %i5, %l5, %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);
201e388: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
201e38c: c4 0f 60 08 ldub [ %i5 + 8 ], %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201e390: 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);
201e394: bb 28 a0 08 sll %g2, 8, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201e398: 13 10 00 00 sethi %hi(0x40000000), %o1
201e39c: 7f ff d9 a6 call 2014a34 <rtems_rfs_trace>
201e3a0: ba 17 40 01 or %i5, %g1, %i5
201e3a4: 80 8a 20 ff btst 0xff, %o0
201e3a8: 02 80 00 17 be 201e404 <rtems_rfs_dir_del_entry+0x330> <== ALWAYS TAKEN
201e3ac: 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");
201e3b0: c2 07 bf c0 ld [ %fp + -64 ], %g1 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
201e3b4: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
201e3b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201e3bc: 12 80 00 05 bne 201e3d0 <rtems_rfs_dir_del_entry+0x2fc> <== NOT EXECUTED
201e3c0: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
201e3c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201e3c8: 02 80 00 3e be 201e4c0 <rtems_rfs_dir_del_entry+0x3ec> <== NOT EXECUTED
201e3cc: 1b 00 80 d4 sethi %hi(0x2035000), %o5 <== NOT EXECUTED
201e3d0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
201e3d4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201e3d8: 02 80 00 3a be 201e4c0 <rtems_rfs_dir_del_entry+0x3ec> <== NOT EXECUTED
201e3dc: 1b 00 80 d4 sethi %hi(0x2035000), %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: "
201e3e0: 1b 00 80 cd sethi %hi(0x2033400), %o5 <== NOT EXECUTED
201e3e4: 9a 13 61 18 or %o5, 0x118, %o5 ! 2033518 <__FUNCTION__.7127+0x580><== NOT EXECUTED
201e3e8: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201e3ec: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201e3f0: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
201e3f4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201e3f8: 40 00 19 2d call 20248ac <printf> <== NOT EXECUTED
201e3fc: 98 10 00 12 mov %l2, %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) &&
201e400: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
201e404: ba 38 40 1d xnor %g1, %i5, %i5
201e408: 80 a7 60 00 cmp %i5, 0
201e40c: 12 80 00 1f bne 201e488 <rtems_rfs_dir_del_entry+0x3b4>
201e410: 80 a4 a0 00 cmp %l2, 0
201e414: 12 80 00 1d bne 201e488 <rtems_rfs_dir_del_entry+0x3b4> <== ALWAYS TAKEN
201e418: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
201e41c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201e420: 12 80 00 2a bne 201e4c8 <rtems_rfs_dir_del_entry+0x3f4> <== NOT EXECUTED
201e424: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
201e428: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201e42c: 12 80 00 28 bne 201e4cc <rtems_rfs_dir_del_entry+0x3f8> <== NOT EXECUTED
201e430: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
201e434: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
201e438: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201e43c: 7f ff f9 27 call 201c8d8 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
201e440: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
201e444: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
201e448: 04 80 00 10 ble 201e488 <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
201e44c: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201e450: 7f ff d9 79 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201e454: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201e458: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e45c: 02 80 00 0c be 201e48c <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
201e460: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201e464: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201e468: 40 00 1d 5b call 20259d4 <strerror> <== NOT EXECUTED
201e46c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e470: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201e474: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201e478: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201e47c: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201e480: 40 00 19 0b call 20248ac <printf> <== NOT EXECUTED
201e484: 90 12 20 c0 or %o0, 0xc0, %o0 ! 20368c0 <CSWTCH.2+0xbac> <== 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);
201e488: 82 10 20 01 mov 1, %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);
201e48c: 92 07 bf a4 add %fp, -92, %o1
201e490: 90 10 00 11 mov %l1, %o0
201e494: 7f ff fa 4c call 201cdc4 <rtems_rfs_buffer_handle_release>
201e498: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
201e49c: b0 10 20 00 clr %i0
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201e4a0: 90 10 00 11 mov %l1, %o0
handle->dirty = false;
201e4a4: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201e4a8: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201e4ac: c0 27 bf ac clr [ %fp + -84 ]
201e4b0: 7f ff f7 1c call 201c120 <rtems_rfs_block_map_close>
201e4b4: 92 07 bf b0 add %fp, -80, %o1
201e4b8: 81 c7 e0 08 ret
201e4bc: 81 e8 00 00 restore
* 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: "
201e4c0: 10 bf ff ca b 201e3e8 <rtems_rfs_dir_del_entry+0x314> <== NOT EXECUTED
201e4c4: 9a 13 63 60 or %o5, 0x360, %o5 <== NOT EXECUTED
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
(eoffset == 0) && rtems_rfs_block_map_last (&map))
201e4c8: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
201e4cc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201e4d0: 12 bf ff ef bne 201e48c <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
201e4d4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
201e4d8: 10 bf ff d8 b 201e438 <rtems_rfs_dir_del_entry+0x364> <== NOT EXECUTED
201e4dc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
201e4e0: 10 bf ff 90 b 201e320 <rtems_rfs_dir_del_entry+0x24c> <== NOT EXECUTED
201e4e4: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201e4e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e4ec: 7f ff d9 52 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201e4f0: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201e4f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e4f8: 22 bf ff 8b be,a 201e324 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
201e4fc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201e500: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
201e504: 40 00 1d 34 call 20259d4 <strerror> <== NOT EXECUTED
201e508: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e50c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201e510: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201e514: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
201e518: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201e51c: 40 00 18 e4 call 20248ac <printf> <== NOT EXECUTED
201e520: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20367c8 <CSWTCH.2+0xab4> <== 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);
201e524: 10 bf ff 80 b 201e324 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
201e528: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
0201e8e0 <rtems_rfs_dir_empty>:
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
201e8e0: 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))
201e8e4: 90 10 20 00 clr %o0
201e8e8: 13 20 00 00 sethi %hi(0x80000000), %o1
201e8ec: 7f ff d8 52 call 2014a34 <rtems_rfs_trace>
201e8f0: b4 10 00 18 mov %i0, %i2
201e8f4: 80 8a 20 ff btst 0xff, %o0
201e8f8: 12 80 00 0a bne 201e920 <rtems_rfs_dir_empty+0x40> <== NEVER TAKEN
201e8fc: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
201e900: 90 10 00 1a mov %i2, %o0
201e904: 7f ff f5 a6 call 201bf9c <rtems_rfs_block_map_open>
201e908: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201e90c: b0 92 20 00 orcc %o0, 0, %i0
201e910: 04 80 00 0f ble 201e94c <rtems_rfs_dir_empty+0x6c> <== ALWAYS TAKEN
201e914: 90 10 00 1a mov %i2, %o0
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201e918: 81 c7 e0 08 ret <== NOT EXECUTED
201e91c: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
201e920: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201e924: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201e928: 40 00 17 e1 call 20248ac <printf> <== NOT EXECUTED
201e92c: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 20369f0 <CSWTCH.2+0xcdc> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
201e930: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201e934: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201e938: 7f ff f5 99 call 201bf9c <rtems_rfs_block_map_open> <== NOT EXECUTED
201e93c: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
201e940: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201e944: 14 bf ff f5 bg 201e918 <rtems_rfs_dir_empty+0x38> <== NOT EXECUTED
201e948: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
201e94c: 92 07 bf b0 add %fp, -80, %o1
201e950: 94 10 20 00 clr %o2
201e954: 96 10 20 00 clr %o3
201e958: 7f ff f6 c0 call 201c458 <rtems_rfs_block_map_seek>
201e95c: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
201e960: b0 92 20 00 orcc %o0, 0, %i0
201e964: 14 80 00 7d bg 201eb58 <rtems_rfs_dir_empty+0x278> <== NEVER TAKEN
201e968: 23 00 00 3f sethi %hi(0xfc00), %l1
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
201e96c: 21 00 80 da sethi %hi(0x2036800), %l0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201e970: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201e974: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201e978: c0 27 bf ac clr [ %fp + -84 ]
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201e97c: a2 14 63 ff or %l1, 0x3ff, %l1
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
201e980: a0 14 22 10 or %l0, 0x210, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201e984: d4 07 bf a0 ld [ %fp + -96 ], %o2
201e988: 90 10 00 1a mov %i2, %o0
201e98c: 92 07 bf a4 add %fp, -92, %o1
201e990: 7f ff f9 87 call 201cfac <rtems_rfs_buffer_handle_request>
201e994: 96 10 20 01 mov 1, %o3
if (rc > 0)
201e998: b0 92 20 00 orcc %o0, 0, %i0
201e99c: 14 80 00 4d bg 201ead0 <rtems_rfs_dir_empty+0x1f0> <== NEVER TAKEN
201e9a0: c2 07 bf ac ld [ %fp + -84 ], %g1
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201e9a4: da 06 a0 08 ld [ %i2 + 8 ], %o5
201e9a8: 9a 83 7f f6 addcc %o5, -10, %o5
201e9ac: 02 80 00 5f be 201eb28 <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
201e9b0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201e9b4: fa 08 60 08 ldub [ %g1 + 8 ], %i5
201e9b8: f6 08 60 09 ldub [ %g1 + 9 ], %i3
eino = rtems_rfs_dir_entry_ino (entry);
201e9bc: f8 08 40 00 ldub [ %g1 ], %i4
201e9c0: c8 08 60 02 ldub [ %g1 + 2 ], %g4
201e9c4: c6 08 60 03 ldub [ %g1 + 3 ], %g3
201e9c8: c4 08 60 01 ldub [ %g1 + 1 ], %g2
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);
201e9cc: bb 2f 60 08 sll %i5, 8, %i5
eino = rtems_rfs_dir_entry_ino (entry);
201e9d0: b9 2f 20 18 sll %i4, 0x18, %i4
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);
201e9d4: ba 17 40 1b or %i5, %i3, %i5
eino = rtems_rfs_dir_entry_ino (entry);
201e9d8: 89 29 20 08 sll %g4, 8, %g4
201e9dc: 85 28 a0 10 sll %g2, 0x10, %g2
201e9e0: b8 17 00 04 or %i4, %g4, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201e9e4: 80 a7 40 11 cmp %i5, %l1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201e9e8: b8 17 00 03 or %i4, %g3, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201e9ec: 02 80 00 4f be 201eb28 <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
201e9f0: b8 17 00 02 or %i4, %g2, %i4
201e9f4: 10 80 00 20 b 201ea74 <rtems_rfs_dir_empty+0x194>
201e9f8: b6 10 20 00 clr %i3
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
201e9fc: 12 80 00 31 bne 201eac0 <rtems_rfs_dir_empty+0x1e0>
201ea00: 80 a0 00 18 cmp %g0, %i0
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
201ea04: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
201ea08: 80 a0 a0 2e cmp %g2, 0x2e
201ea0c: 12 80 00 2d bne 201eac0 <rtems_rfs_dir_empty+0x1e0> <== NEVER TAKEN
201ea10: 80 a0 00 18 cmp %g0, %i0
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
201ea14: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
201ea18: 80 a0 a0 2e cmp %g2, 0x2e
201ea1c: 12 80 00 29 bne 201eac0 <rtems_rfs_dir_empty+0x1e0> <== NEVER TAKEN
201ea20: 80 a0 00 18 cmp %g0, %i0
empty = false;
break;
}
entry += elength;
offset += elength;
201ea24: b6 06 c0 1d add %i3, %i5, %i3
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201ea28: 80 a6 c0 0d cmp %i3, %o5
201ea2c: 1a 80 00 3f bcc 201eb28 <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
201ea30: 82 00 40 1d add %g1, %i5, %g1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201ea34: fa 08 60 08 ldub [ %g1 + 8 ], %i5
201ea38: de 08 60 09 ldub [ %g1 + 9 ], %o7
eino = rtems_rfs_dir_entry_ino (entry);
201ea3c: f8 08 40 00 ldub [ %g1 ], %i4
201ea40: c8 08 60 01 ldub [ %g1 + 1 ], %g4
201ea44: c6 08 60 03 ldub [ %g1 + 3 ], %g3
201ea48: c4 08 60 02 ldub [ %g1 + 2 ], %g2
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);
201ea4c: bb 2f 60 08 sll %i5, 8, %i5
eino = rtems_rfs_dir_entry_ino (entry);
201ea50: b9 2f 20 18 sll %i4, 0x18, %i4
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);
201ea54: ba 17 40 0f or %i5, %o7, %i5
eino = rtems_rfs_dir_entry_ino (entry);
201ea58: 89 29 20 10 sll %g4, 0x10, %g4
201ea5c: 85 28 a0 08 sll %g2, 8, %g2
201ea60: b8 17 00 04 or %i4, %g4, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201ea64: 80 a7 40 11 cmp %i5, %l1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201ea68: b8 17 00 03 or %i4, %g3, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201ea6c: 02 80 00 2f be 201eb28 <rtems_rfs_dir_empty+0x248>
201ea70: b8 17 00 02 or %i4, %g2, %i4
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201ea74: 80 a7 60 0a cmp %i5, 0xa
201ea78: 04 80 00 21 ble 201eafc <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
201ea7c: 90 10 20 01 mov 1, %o0
201ea80: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
201ea84: 80 a7 40 02 cmp %i5, %g2
201ea88: 1a 80 00 1d bcc 201eafc <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
201ea8c: 80 a7 20 00 cmp %i4, 0
201ea90: 02 80 00 1b be 201eafc <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
201ea94: 01 00 00 00 nop
201ea98: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
201ea9c: 80 a0 80 1c cmp %g2, %i4
201eaa0: 0a 80 00 17 bcs 201eafc <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
201eaa4: 80 a7 60 0b cmp %i5, 0xb
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
201eaa8: 12 bf ff d5 bne 201e9fc <rtems_rfs_dir_empty+0x11c>
201eaac: 80 a7 60 0c cmp %i5, 0xc
201eab0: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
201eab4: 80 a0 a0 2e cmp %g2, 0x2e
201eab8: 02 bf ff db be 201ea24 <rtems_rfs_dir_empty+0x144> <== ALWAYS TAKEN
201eabc: 80 a0 00 18 cmp %g0, %i0
201eac0: 82 60 3f ff subx %g0, -1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
201eac4: 80 88 60 ff btst 0xff, %g1
201eac8: 32 80 00 02 bne,a 201ead0 <rtems_rfs_dir_empty+0x1f0> <== ALWAYS TAKEN
201eacc: b0 10 20 5a mov 0x5a, %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);
201ead0: 92 07 bf a4 add %fp, -92, %o1
201ead4: 7f ff f8 bc call 201cdc4 <rtems_rfs_buffer_handle_release>
201ead8: 90 10 00 1a mov %i2, %o0
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201eadc: 90 10 00 1a mov %i2, %o0
handle->dirty = false;
201eae0: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201eae4: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201eae8: c0 27 bf ac clr [ %fp + -84 ]
201eaec: 7f ff f5 8d call 201c120 <rtems_rfs_block_map_close>
201eaf0: 92 07 bf b0 add %fp, -80, %o1
201eaf4: 81 c7 e0 08 ret
201eaf8: 81 e8 00 00 restore
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
201eafc: 7f ff d7 ce call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201eb00: 92 10 20 00 clr %o1 <== NOT EXECUTED
201eb04: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201eb08: 02 80 00 09 be 201eb2c <rtems_rfs_dir_empty+0x24c> <== NOT EXECUTED
201eb0c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
201eb10: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201eb14: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201eb18: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201eb1c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
201eb20: 40 00 17 63 call 20248ac <printf> <== NOT EXECUTED
201eb24: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201eb28: 90 10 00 1a mov %i2, %o0
201eb2c: 92 07 bf b0 add %fp, -80, %o1
201eb30: 7f ff f6 67 call 201c4cc <rtems_rfs_block_map_next_block>
201eb34: 94 07 bf a0 add %fp, -96, %o2
if (rc > 0)
201eb38: b0 92 20 00 orcc %o0, 0, %i0
201eb3c: 04 bf ff 93 ble 201e988 <rtems_rfs_dir_empty+0xa8> <== NEVER TAKEN
201eb40: d4 07 bf a0 ld [ %fp + -96 ], %o2
{
if (rc == ENXIO)
rc = 0;
201eb44: 82 1e 20 06 xor %i0, 6, %g1
201eb48: 80 a0 00 01 cmp %g0, %g1
201eb4c: 82 60 20 00 subx %g0, 0, %g1
201eb50: 10 bf ff e0 b 201ead0 <rtems_rfs_dir_empty+0x1f0>
201eb54: b0 0e 00 01 and %i0, %g1, %i0
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
201eb58: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201eb5c: 7f ff f5 71 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
201eb60: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201eb64: 81 c7 e0 08 ret <== NOT EXECUTED
201eb68: 81 e8 00 00 restore <== NOT EXECUTED
02022eb4 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
2022eb4: 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;
2022eb8: 09 37 f7 c5 sethi %hi(0xdfdf1400), %g4
} 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)
2022ebc: 82 10 00 18 mov %i0, %g1
{
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;
2022ec0: 88 11 22 9f or %g4, 0x29f, %g4
} 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)
2022ec4: 80 a6 60 0c cmp %i1, 0xc
{
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;
2022ec8: 88 06 40 04 add %i1, %g4, %g4
} 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)
2022ecc: 84 10 00 04 mov %g4, %g2
2022ed0: 08 80 00 4b bleu 2022ffc <rtems_rfs_dir_hash+0x148>
2022ed4: 86 10 00 04 mov %g4, %g3
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;
2022ed8: f8 08 60 0b ldub [ %g1 + 0xb ], %i4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
2022edc: fa 08 60 03 ldub [ %g1 + 3 ], %i5
b += k[4];
b += ((uint32_t)k[5])<<8;
2022ee0: d8 08 60 05 ldub [ %g1 + 5 ], %o4
b += ((uint32_t)k[6])<<16;
2022ee4: d0 08 60 06 ldub [ %g1 + 6 ], %o0
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
2022ee8: d2 08 60 04 ldub [ %g1 + 4 ], %o1
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
2022eec: d4 08 60 07 ldub [ %g1 + 7 ], %o2
c += k[8];
c += ((uint32_t)k[9])<<8;
2022ef0: d6 08 60 09 ldub [ %g1 + 9 ], %o3
c += ((uint32_t)k[10])<<16;
2022ef4: f0 08 60 0a ldub [ %g1 + 0xa ], %i0
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];
2022ef8: da 08 60 08 ldub [ %g1 + 8 ], %o5
/*--------------- 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;
2022efc: de 08 60 01 ldub [ %g1 + 1 ], %o7
a += ((uint32_t)k[2])<<16;
2022f00: f6 08 60 02 ldub [ %g1 + 2 ], %i3
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];
2022f04: f4 08 40 00 ldub [ %g1 ], %i2
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;
2022f08: b9 2f 20 18 sll %i4, 0x18, %i4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
2022f0c: bb 2f 60 18 sll %i5, 0x18, %i5
b += k[4];
b += ((uint32_t)k[5])<<8;
2022f10: 99 2b 20 08 sll %o4, 8, %o4
b += ((uint32_t)k[6])<<16;
2022f14: 91 2a 20 10 sll %o0, 0x10, %o0
b += ((uint32_t)k[7])<<24;
2022f18: 95 2a a0 18 sll %o2, 0x18, %o2
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
2022f1c: 98 03 00 08 add %o4, %o0, %o4
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
2022f20: 97 2a e0 08 sll %o3, 8, %o3
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
2022f24: 98 03 00 09 add %o4, %o1, %o4
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;
2022f28: b1 2e 20 10 sll %i0, 0x10, %i0
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
2022f2c: 98 03 00 0a add %o4, %o2, %o4
b += ((uint32_t)k[7])<<24;
c += k[8];
2022f30: b0 02 c0 18 add %o3, %i0, %i0
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
2022f34: 84 03 00 02 add %o4, %g2, %g2
c += k[8];
c += ((uint32_t)k[9])<<8;
2022f38: b0 06 00 0d add %i0, %o5, %i0
/*--------------- 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;
2022f3c: 9f 2b e0 08 sll %o7, 8, %o7
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
2022f40: b0 06 00 1c add %i0, %i4, %i0
/*--------------- 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;
2022f44: b7 2e e0 10 sll %i3, 0x10, %i3
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;
2022f48: b0 06 00 04 add %i0, %g4, %i0
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];
2022f4c: b6 03 c0 1b add %o7, %i3, %i3
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
2022f50: 88 06 00 02 add %i0, %g2, %g4
2022f54: b9 2e 20 04 sll %i0, 4, %i4
/*--------------- 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;
2022f58: b6 06 c0 1a add %i3, %i2, %i3
a += ((uint32_t)k[2])<<16;
2022f5c: b6 06 c0 1d add %i3, %i5, %i3
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
2022f60: bb 36 20 1c srl %i0, 0x1c, %i5
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
2022f64: b0 26 c0 18 sub %i3, %i0, %i0
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
2022f68: ba 17 00 1d or %i4, %i5, %i5
2022f6c: 86 06 00 03 add %i0, %g3, %g3
2022f70: b8 18 c0 1d xor %g3, %i5, %i4
2022f74: 86 07 00 04 add %i4, %g4, %g3
2022f78: 84 20 80 1c sub %g2, %i4, %g2
2022f7c: bb 2f 20 06 sll %i4, 6, %i5
2022f80: b9 37 20 1a srl %i4, 0x1a, %i4
2022f84: ba 17 40 1c or %i5, %i4, %i5
2022f88: ba 1f 40 02 xor %i5, %g2, %i5
2022f8c: 84 07 40 03 add %i5, %g3, %g2
2022f90: 88 21 00 1d sub %g4, %i5, %g4
2022f94: b9 2f 60 08 sll %i5, 8, %i4
2022f98: bb 37 60 18 srl %i5, 0x18, %i5
2022f9c: ba 17 00 1d or %i4, %i5, %i5
2022fa0: 88 1f 40 04 xor %i5, %g4, %g4
2022fa4: b0 01 00 02 add %g4, %g2, %i0
2022fa8: bb 29 20 10 sll %g4, 0x10, %i5
2022fac: 86 20 c0 04 sub %g3, %g4, %g3
2022fb0: 89 31 20 10 srl %g4, 0x10, %g4
2022fb4: 88 17 40 04 or %i5, %g4, %g4
2022fb8: 86 19 00 03 xor %g4, %g3, %g3
2022fbc: bb 28 e0 13 sll %g3, 0x13, %i5
2022fc0: 89 30 e0 0d srl %g3, 0xd, %g4
2022fc4: 88 17 40 04 or %i5, %g4, %g4
2022fc8: 84 20 80 03 sub %g2, %g3, %g2
length -= 12;
2022fcc: b2 06 7f f4 add %i1, -12, %i1
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
2022fd0: 84 19 00 02 xor %g4, %g2, %g2
2022fd4: 86 00 c0 18 add %g3, %i0, %g3
2022fd8: bb 28 a0 04 sll %g2, 4, %i5
2022fdc: b0 26 00 02 sub %i0, %g2, %i0
2022fe0: 89 30 a0 1c srl %g2, 0x1c, %g4
length -= 12;
k += 12;
2022fe4: 82 00 60 0c add %g1, 0xc, %g1
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
2022fe8: 88 17 40 04 or %i5, %g4, %g4
} 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)
2022fec: 80 a6 60 0c cmp %i1, 0xc
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
2022ff0: 84 00 80 03 add %g2, %g3, %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)
2022ff4: 18 bf ff b9 bgu 2022ed8 <rtems_rfs_dir_hash+0x24> <== NEVER TAKEN
2022ff8: 88 19 00 18 xor %g4, %i0, %g4
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
2022ffc: b3 2e 60 02 sll %i1, 2, %i1
2023000: 3b 00 80 8b sethi %hi(0x2022c00), %i5
2023004: ba 17 62 80 or %i5, 0x280, %i5 ! 2022e80 <rtems_rfs_buffer_bdbuf_release+0x8c>
2023008: fa 07 40 19 ld [ %i5 + %i1 ], %i5
202300c: 81 c7 40 00 jmp %i5
2023010: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
2023014: fa 08 60 0b ldub [ %g1 + 0xb ], %i5
2023018: bb 2f 60 18 sll %i5, 0x18, %i5
202301c: 88 01 00 1d add %g4, %i5, %g4
case 11: c+=((uint32_t)k[10])<<16;
2023020: fa 08 60 0a ldub [ %g1 + 0xa ], %i5
2023024: bb 2f 60 10 sll %i5, 0x10, %i5
2023028: 88 01 00 1d add %g4, %i5, %g4
case 10: c+=((uint32_t)k[9])<<8;
202302c: fa 08 60 09 ldub [ %g1 + 9 ], %i5
2023030: bb 2f 60 08 sll %i5, 8, %i5
2023034: 88 01 00 1d add %g4, %i5, %g4
case 9 : c+=k[8];
2023038: fa 08 60 08 ldub [ %g1 + 8 ], %i5
202303c: 88 01 00 1d add %g4, %i5, %g4
case 8 : b+=((uint32_t)k[7])<<24;
2023040: fa 08 60 07 ldub [ %g1 + 7 ], %i5
2023044: bb 2f 60 18 sll %i5, 0x18, %i5
2023048: 84 00 80 1d add %g2, %i5, %g2
case 7 : b+=((uint32_t)k[6])<<16;
202304c: fa 08 60 06 ldub [ %g1 + 6 ], %i5
2023050: bb 2f 60 10 sll %i5, 0x10, %i5
2023054: 84 00 80 1d add %g2, %i5, %g2
case 6 : b+=((uint32_t)k[5])<<8;
2023058: fa 08 60 05 ldub [ %g1 + 5 ], %i5
202305c: bb 2f 60 08 sll %i5, 8, %i5
2023060: 84 00 80 1d add %g2, %i5, %g2
case 5 : b+=k[4];
2023064: fa 08 60 04 ldub [ %g1 + 4 ], %i5
2023068: 84 00 80 1d add %g2, %i5, %g2
case 4 : a+=((uint32_t)k[3])<<24;
202306c: fa 08 60 03 ldub [ %g1 + 3 ], %i5
2023070: bb 2f 60 18 sll %i5, 0x18, %i5
2023074: 86 00 c0 1d add %g3, %i5, %g3
case 3 : a+=((uint32_t)k[2])<<16;
2023078: fa 08 60 02 ldub [ %g1 + 2 ], %i5
202307c: bb 2f 60 10 sll %i5, 0x10, %i5
2023080: 86 00 c0 1d add %g3, %i5, %g3
case 2 : a+=((uint32_t)k[1])<<8;
2023084: fa 08 60 01 ldub [ %g1 + 1 ], %i5
2023088: bb 2f 60 08 sll %i5, 8, %i5
202308c: 86 00 c0 1d add %g3, %i5, %g3
case 1 : a+=k[0];
2023090: c2 08 40 00 ldub [ %g1 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
2023094: bb 30 a0 12 srl %g2, 0x12, %i5
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];
2023098: 86 00 c0 01 add %g3, %g1, %g3
break;
case 0 : return c;
}
}
final(a,b,c);
202309c: 83 28 a0 0e sll %g2, 0xe, %g1
20230a0: 82 17 40 01 or %i5, %g1, %g1
20230a4: 88 19 00 02 xor %g4, %g2, %g4
20230a8: 88 21 00 01 sub %g4, %g1, %g4
20230ac: bb 29 20 0b sll %g4, 0xb, %i5
20230b0: 83 31 20 15 srl %g4, 0x15, %g1
20230b4: 82 17 40 01 or %i5, %g1, %g1
20230b8: 86 19 00 03 xor %g4, %g3, %g3
20230bc: 86 20 c0 01 sub %g3, %g1, %g3
20230c0: bb 28 e0 19 sll %g3, 0x19, %i5
20230c4: 83 30 e0 07 srl %g3, 7, %g1
20230c8: 82 17 40 01 or %i5, %g1, %g1
20230cc: 84 18 c0 02 xor %g3, %g2, %g2
20230d0: 84 20 80 01 sub %g2, %g1, %g2
20230d4: bb 28 a0 10 sll %g2, 0x10, %i5
20230d8: 83 30 a0 10 srl %g2, 0x10, %g1
20230dc: 82 17 40 01 or %i5, %g1, %g1
20230e0: 88 18 80 04 xor %g2, %g4, %g4
20230e4: 88 21 00 01 sub %g4, %g1, %g4
20230e8: bb 29 20 04 sll %g4, 4, %i5
20230ec: 83 31 20 1c srl %g4, 0x1c, %g1
20230f0: 82 17 40 01 or %i5, %g1, %g1
20230f4: 86 19 00 03 xor %g4, %g3, %g3
20230f8: 86 20 c0 01 sub %g3, %g1, %g3
20230fc: 84 18 c0 02 xor %g3, %g2, %g2
2023100: 83 28 e0 0e sll %g3, 0xe, %g1
2023104: 87 30 e0 12 srl %g3, 0x12, %g3
2023108: 86 10 40 03 or %g1, %g3, %g3
202310c: 84 20 80 03 sub %g2, %g3, %g2
2023110: 88 18 80 04 xor %g2, %g4, %g4
2023114: b1 28 a0 18 sll %g2, 0x18, %i0
2023118: 85 30 a0 08 srl %g2, 8, %g2
202311c: 84 16 00 02 or %i0, %g2, %g2
2023120: 88 21 00 02 sub %g4, %g2, %g4
return c;
}
2023124: 81 c7 e0 08 ret
2023128: 91 e8 00 04 restore %g0, %g4, %o0
0201d774 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
201d774: 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))
201d778: 90 10 20 00 clr %o0
201d77c: 13 01 00 00 sethi %hi(0x4000000), %o1
201d780: 7f ff dc ad call 2014a34 <rtems_rfs_trace>
201d784: a2 10 00 18 mov %i0, %l1
201d788: 80 8a 20 ff btst 0xff, %o0
201d78c: 12 80 00 1c bne 201d7fc <rtems_rfs_dir_lookup_ino+0x88> <== NEVER TAKEN
201d790: 92 10 00 19 mov %i1, %o1
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
201d794: c0 27 00 00 clr [ %i4 ]
*offset = 0;
201d798: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
201d79c: 90 10 00 11 mov %l1, %o0
201d7a0: 7f ff f9 ff call 201bf9c <rtems_rfs_block_map_open>
201d7a4: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201d7a8: b0 92 20 00 orcc %o0, 0, %i0
201d7ac: 24 80 00 30 ble,a 201d86c <rtems_rfs_dir_lookup_ino+0xf8><== ALWAYS TAKEN
201d7b0: 92 10 00 1b mov %i3, %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201d7b4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201d7b8: 7f ff dc 9f call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d7bc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201d7c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d7c4: 32 80 00 04 bne,a 201d7d4 <rtems_rfs_dir_lookup_ino+0x60><== NOT EXECUTED
201d7c8: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201d7cc: 81 c7 e0 08 ret <== NOT EXECUTED
201d7d0: 81 e8 00 00 restore <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
201d7d4: 40 00 20 80 call 20259d4 <strerror> <== NOT EXECUTED
201d7d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201d7dc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d7e0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201d7e4: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
201d7e8: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d7ec: 40 00 1c 30 call 20248ac <printf> <== NOT EXECUTED
201d7f0: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 20363a0 <CSWTCH.2+0x68c> <== NOT EXECUTED
201d7f4: 81 c7 e0 08 ret <== NOT EXECUTED
201d7f8: 81 e8 00 00 restore <== 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=",
201d7fc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201d800: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d804: 40 00 1c 2a call 20248ac <printf> <== NOT EXECUTED
201d808: 90 12 23 58 or %o0, 0x358, %o0 ! 2036358 <CSWTCH.2+0x644> <== NOT EXECUTED
201d80c: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
201d810: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
201d814: 04 80 00 08 ble 201d834 <rtems_rfs_dir_lookup_ino+0xc0> <== NOT EXECUTED
201d818: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
201d81c: d0 4e 00 00 ldsb [ %i0 ], %o0 <== NOT EXECUTED
201d820: 40 00 1c 8d call 2024a54 <putchar> <== NOT EXECUTED
201d824: b0 06 20 01 inc %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
201d828: 80 a6 00 10 cmp %i0, %l0 <== NOT EXECUTED
201d82c: 32 bf ff fd bne,a 201d820 <rtems_rfs_dir_lookup_ino+0xac><== NOT EXECUTED
201d830: d0 4e 00 00 ldsb [ %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
201d834: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201d838: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201d83c: 40 00 1c 1c call 20248ac <printf> <== NOT EXECUTED
201d840: 90 12 23 90 or %o0, 0x390, %o0 ! 2036390 <CSWTCH.2+0x67c> <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
201d844: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
201d848: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
201d84c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
201d850: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201d854: 7f ff f9 d2 call 201bf9c <rtems_rfs_block_map_open> <== NOT EXECUTED
201d858: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
201d85c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201d860: 14 bf ff d6 bg 201d7b8 <rtems_rfs_dir_lookup_ino+0x44> <== NOT EXECUTED
201d864: 90 10 20 00 clr %o0 <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
201d868: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201d86c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201d870: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201d874: c0 27 bf ac clr [ %fp + -84 ]
201d878: 40 00 15 8f call 2022eb4 <rtems_rfs_dir_hash>
201d87c: 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);
201d880: 92 07 bf b0 add %fp, -80, %o1
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
201d884: a6 10 00 08 mov %o0, %l3
/*
* 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);
201d888: 94 10 20 00 clr %o2
201d88c: 90 10 00 11 mov %l1, %o0
201d890: 96 10 20 00 clr %o3
201d894: 7f ff fa f1 call 201c458 <rtems_rfs_block_map_seek>
201d898: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
201d89c: b0 92 20 00 orcc %o0, 0, %i0
201d8a0: 04 80 00 15 ble 201d8f4 <rtems_rfs_dir_lookup_ino+0x180> <== ALWAYS TAKEN
201d8a4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201d8a8: 7f ff dc 63 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201d8ac: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201d8b0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d8b4: 12 80 00 bf bne 201dbb0 <rtems_rfs_dir_lookup_ino+0x43c> <== NOT EXECUTED
201d8b8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
rc, strerror (rc));
if (rc == ENXIO)
201d8bc: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
201d8c0: 22 80 00 02 be,a 201d8c8 <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
201d8c4: b0 10 20 02 mov 2, %i0 <== 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);
201d8c8: 92 07 bf a4 add %fp, -92, %o1
201d8cc: 7f ff fd 3e call 201cdc4 <rtems_rfs_buffer_handle_release>
201d8d0: 90 10 00 11 mov %l1, %o0
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
201d8d4: 90 10 00 11 mov %l1, %o0
handle->dirty = false;
201d8d8: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201d8dc: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201d8e0: c0 27 bf ac clr [ %fp + -84 ]
201d8e4: 7f ff fa 0f call 201c120 <rtems_rfs_block_map_close>
201d8e8: 92 07 bf b0 add %fp, -80, %o1
201d8ec: 81 c7 e0 08 ret
201d8f0: 81 e8 00 00 restore
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",
201d8f4: 2d 00 80 d9 sethi %hi(0x2036400), %l6
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)
201d8f8: 25 00 00 3f sethi %hi(0xfc00), %l2
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201d8fc: 2b 00 80 d9 sethi %hi(0x2036400), %l5
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",
201d900: ac 15 a0 20 or %l6, 0x20, %l6
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)
201d904: a4 14 a3 ff or %l2, 0x3ff, %l2
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201d908: aa 15 60 f0 or %l5, 0xf0, %l5
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
201d90c: 80 a6 20 00 cmp %i0, 0
201d910: 12 80 00 6b bne 201dabc <rtems_rfs_dir_lookup_ino+0x348> <== NEVER TAKEN
201d914: c2 07 bf a0 ld [ %fp + -96 ], %g1
201d918: 80 a0 60 00 cmp %g1, 0
201d91c: 02 80 00 d3 be 201dc68 <rtems_rfs_dir_lookup_ino+0x4f4> <== NEVER TAKEN
201d920: 90 10 20 00 clr %o0
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201d924: 7f ff dc 44 call 2014a34 <rtems_rfs_trace>
201d928: 13 01 00 00 sethi %hi(0x4000000), %o1
201d92c: 80 8a 20 ff btst 0xff, %o0
201d930: 32 80 00 87 bne,a 201db4c <rtems_rfs_dir_lookup_ino+0x3d8><== NEVER TAKEN
201d934: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
201d938: d4 07 bf a0 ld [ %fp + -96 ], %o2
201d93c: 90 10 00 11 mov %l1, %o0
201d940: 92 07 bf a4 add %fp, -92, %o1
201d944: 7f ff fd 9a call 201cfac <rtems_rfs_buffer_handle_request>
201d948: 96 10 20 01 mov 1, %o3
if (rc > 0)
201d94c: a8 92 20 00 orcc %o0, 0, %l4
201d950: 14 80 00 b3 bg 201dc1c <rtems_rfs_dir_lookup_ino+0x4a8> <== NEVER TAKEN
201d954: c2 07 bf ac ld [ %fp + -84 ], %g1
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))
201d958: d8 04 60 08 ld [ %l1 + 8 ], %o4
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
201d95c: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201d960: 80 a3 20 0a cmp %o4, 0xa
201d964: 12 80 00 0a bne 201d98c <rtems_rfs_dir_lookup_ino+0x218> <== ALWAYS TAKEN
201d968: e0 00 60 1c ld [ %g1 + 0x1c ], %l0
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
201d96c: 10 80 00 47 b 201da88 <rtems_rfs_dir_lookup_ino+0x314> <== NOT EXECUTED
201d970: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201d974: 86 03 3f f6 add %o4, -10, %g3
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
201d978: 84 05 c0 02 add %l7, %g2, %g2
201d97c: c4 27 bf c4 st %g2, [ %fp + -60 ]
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201d980: 80 a0 c0 02 cmp %g3, %g2
201d984: 08 80 00 40 bleu 201da84 <rtems_rfs_dir_lookup_ino+0x310> <== NEVER TAKEN
201d988: a0 04 00 17 add %l0, %l7, %l0
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
201d98c: c4 0c 00 00 ldub [ %l0 ], %g2
201d990: d0 0c 20 01 ldub [ %l0 + 1 ], %o0
201d994: d2 0c 20 03 ldub [ %l0 + 3 ], %o1
201d998: d4 0c 20 02 ldub [ %l0 + 2 ], %o2
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);
201d99c: d6 0c 20 04 ldub [ %l0 + 4 ], %o3
201d9a0: c8 0c 20 05 ldub [ %l0 + 5 ], %g4
201d9a4: da 0c 20 07 ldub [ %l0 + 7 ], %o5
201d9a8: c6 0c 20 06 ldub [ %l0 + 6 ], %g3
elength = rtems_rfs_dir_entry_length (entry);
201d9ac: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
201d9b0: de 0c 20 09 ldub [ %l0 + 9 ], %o7
*ino = rtems_rfs_dir_entry_ino (entry);
201d9b4: 85 28 a0 18 sll %g2, 0x18, %g2
201d9b8: 91 2a 20 10 sll %o0, 0x10, %o0
201d9bc: 95 2a a0 08 sll %o2, 8, %o2
201d9c0: 84 10 80 08 or %g2, %o0, %g2
201d9c4: 84 10 80 09 or %g2, %o1, %g2
201d9c8: 84 10 80 0a or %g2, %o2, %g2
201d9cc: c4 27 00 00 st %g2, [ %i4 ]
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);
201d9d0: 97 2a e0 18 sll %o3, 0x18, %o3
201d9d4: 89 29 20 10 sll %g4, 0x10, %g4
201d9d8: 87 28 e0 08 sll %g3, 8, %g3
201d9dc: 88 12 c0 04 or %o3, %g4, %g4
elength = rtems_rfs_dir_entry_length (entry);
201d9e0: 83 28 60 08 sll %g1, 8, %g1
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);
201d9e4: 88 11 00 0d or %g4, %o5, %g4
elength = rtems_rfs_dir_entry_length (entry);
201d9e8: ae 10 40 0f or %g1, %o7, %l7
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201d9ec: 80 a5 c0 12 cmp %l7, %l2
201d9f0: 02 80 00 25 be 201da84 <rtems_rfs_dir_lookup_ino+0x310>
201d9f4: 86 11 00 03 or %g4, %g3, %g3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
201d9f8: 80 a5 e0 0a cmp %l7, 0xa
201d9fc: 24 80 00 34 ble,a 201dacc <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
201da00: 90 10 20 00 clr %o0 <== NOT EXECUTED
201da04: de 04 60 1c ld [ %l1 + 0x1c ], %o7
201da08: 80 a5 c0 0f cmp %l7, %o7
201da0c: 1a 80 00 2f bcc 201dac8 <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
201da10: 80 a0 a0 00 cmp %g2, 0
201da14: 22 80 00 2e be,a 201dacc <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
201da18: 90 10 20 00 clr %o0 <== NOT EXECUTED
201da1c: c8 04 60 14 ld [ %l1 + 0x14 ], %g4
201da20: 80 a0 80 04 cmp %g2, %g4
201da24: 18 80 00 29 bgu 201dac8 <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
201da28: 80 a0 c0 13 cmp %g3, %l3
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
201da2c: 12 bf ff d2 bne 201d974 <rtems_rfs_dir_lookup_ino+0x200>
201da30: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
201da34: 90 10 20 00 clr %o0
201da38: 7f ff db ff call 2014a34 <rtems_rfs_trace>
201da3c: 13 02 00 00 sethi %hi(0x8000000), %o1
201da40: 80 8a 20 ff btst 0xff, %o0
201da44: 32 80 00 32 bne,a 201db0c <rtems_rfs_dir_lookup_ino+0x398><== NEVER TAKEN
201da48: c8 0c 20 01 ldub [ %l0 + 1 ], %g4 <== 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)
201da4c: 90 04 20 0a add %l0, 0xa, %o0
201da50: 92 10 00 1a mov %i2, %o1
201da54: 40 00 1a 5f call 20243d0 <memcmp>
201da58: 94 10 00 1b mov %i3, %o2
201da5c: 80 a2 20 00 cmp %o0, 0
201da60: 02 80 00 5d be 201dbd4 <rtems_rfs_dir_lookup_ino+0x460> <== ALWAYS TAKEN
201da64: c4 07 bf c4 ld [ %fp + -60 ], %g2
201da68: d8 04 60 08 ld [ %l1 + 8 ], %o4 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
201da6c: 84 05 c0 02 add %l7, %g2, %g2 <== NOT EXECUTED
201da70: c4 27 bf c4 st %g2, [ %fp + -60 ] <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201da74: 86 03 3f f6 add %o4, -10, %g3 <== NOT EXECUTED
201da78: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
201da7c: 18 bf ff c4 bgu 201d98c <rtems_rfs_dir_lookup_ino+0x218> <== NOT EXECUTED
201da80: a0 04 00 17 add %l0, %l7, %l0 <== NOT EXECUTED
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
201da84: 80 a5 20 00 cmp %l4, 0
201da88: 32 bf ff 90 bne,a 201d8c8 <rtems_rfs_dir_lookup_ino+0x154><== NEVER TAKEN
201da8c: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201da90: 90 10 00 11 mov %l1, %o0
201da94: 92 07 bf b0 add %fp, -80, %o1
201da98: 7f ff fa 8d call 201c4cc <rtems_rfs_block_map_next_block>
201da9c: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
201daa0: 80 a2 20 06 cmp %o0, 6
201daa4: 12 80 00 2f bne 201db60 <rtems_rfs_dir_lookup_ino+0x3ec> <== NEVER TAKEN
201daa8: b0 10 00 08 mov %o0, %i0
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)
201daac: 80 a6 20 06 cmp %i0, 6
201dab0: 12 bf ff 98 bne 201d910 <rtems_rfs_dir_lookup_ino+0x19c> <== NEVER TAKEN
201dab4: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
201dab8: b0 10 20 02 mov 2, %i0
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
201dabc: a8 10 00 18 mov %i0, %l4
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;
201dac0: 10 bf ff 82 b 201d8c8 <rtems_rfs_dir_lookup_ino+0x154>
201dac4: b0 10 00 14 mov %l4, %i0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201dac8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201dacc: 7f ff db da call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201dad0: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201dad4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dad8: 12 80 00 04 bne 201dae8 <rtems_rfs_dir_lookup_ino+0x374> <== NOT EXECUTED
201dadc: a8 10 20 05 mov 5, %l4 <== 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;
201dae0: 10 bf ff 7a b 201d8c8 <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
201dae4: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
201dae8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201daec: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
201daf0: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
201daf4: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
201daf8: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201dafc: 40 00 1b 6c call 20248ac <printf> <== NOT EXECUTED
201db00: 90 12 20 a0 or %o0, 0xa0, %o0 ! 20364a0 <CSWTCH.2+0x78c> <== NOT EXECUTED
201db04: 10 bf ff 71 b 201d8c8 <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
201db08: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
201db0c: c4 0c 20 02 ldub [ %l0 + 2 ], %g2 <== NOT EXECUTED
201db10: da 0c 00 00 ldub [ %l0 ], %o5 <== NOT EXECUTED
201db14: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201db18: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201db1c: d4 1f bf c0 ldd [ %fp + -64 ], %o2 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
201db20: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
201db24: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
201db28: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201db2c: 90 10 00 15 mov %l5, %o0 <== 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));
201db30: 9a 13 40 04 or %o5, %g4, %o5 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201db34: 98 10 00 17 mov %l7, %o4 <== 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));
201db38: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201db3c: 40 00 1b 5c call 20248ac <printf> <== NOT EXECUTED
201db40: 9a 13 40 02 or %o5, %g2, %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)
201db44: 10 bf ff c3 b 201da50 <rtems_rfs_dir_lookup_ino+0x2dc> <== NOT EXECUTED
201db48: 90 04 20 0a add %l0, 0xa, %o0 <== 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",
201db4c: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
201db50: 40 00 1b 57 call 20248ac <printf> <== NOT EXECUTED
201db54: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
201db58: 10 bf ff 79 b 201d93c <rtems_rfs_dir_lookup_ino+0x1c8> <== NOT EXECUTED
201db5c: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
201db60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201db64: 04 bf ff d3 ble 201dab0 <rtems_rfs_dir_lookup_ino+0x33c> <== NOT EXECUTED
201db68: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201db6c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201db70: 7f ff db b1 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201db74: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201db78: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201db7c: 22 bf ff cd be,a 201dab0 <rtems_rfs_dir_lookup_ino+0x33c><== NOT EXECUTED
201db80: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
201db84: e0 06 60 08 ld [ %i1 + 8 ], %l0 <== NOT EXECUTED
201db88: 40 00 1f 93 call 20259d4 <strerror> <== NOT EXECUTED
201db8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201db90: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201db94: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201db98: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
201db9c: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201dba0: 40 00 1b 43 call 20248ac <printf> <== NOT EXECUTED
201dba4: 90 12 21 98 or %o0, 0x198, %o0 ! 2036598 <CSWTCH.2+0x884> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
201dba8: 10 bf ff 5a b 201d910 <rtems_rfs_dir_lookup_ino+0x19c> <== NOT EXECUTED
201dbac: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
201dbb0: 40 00 1f 89 call 20259d4 <strerror> <== NOT EXECUTED
201dbb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201dbb8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201dbbc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201dbc0: 11 00 80 d8 sethi %hi(0x2036000), %o0 <== NOT EXECUTED
201dbc4: 40 00 1b 3a call 20248ac <printf> <== NOT EXECUTED
201dbc8: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 20363e0 <CSWTCH.2+0x6cc> <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
201dbcc: 10 bf ff 3d b 201d8c0 <rtems_rfs_dir_lookup_ino+0x14c> <== NOT EXECUTED
201dbd0: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
{
*offset = rtems_rfs_block_map_pos (fs, &map);
201dbd4: 90 10 00 11 mov %l1, %o0
201dbd8: 7f ff f8 bc call 201bec8 <rtems_rfs_block_get_pos>
201dbdc: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
201dbe0: 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);
201dbe4: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
201dbe8: 7f ff db 93 call 2014a34 <rtems_rfs_trace>
201dbec: 13 04 00 00 sethi %hi(0x10000000), %o1
201dbf0: 80 8a 20 ff btst 0xff, %o0
201dbf4: 22 bf ff 36 be,a 201d8cc <rtems_rfs_dir_lookup_ino+0x158><== ALWAYS TAKEN
201dbf8: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
201dbfc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201dc00: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
201dc04: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
201dc08: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201dc0c: 40 00 1b 28 call 20248ac <printf> <== NOT EXECUTED
201dc10: 90 12 21 50 or %o0, 0x150, %o0 ! 2036550 <CSWTCH.2+0x83c> <== 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);
201dc14: 10 bf ff 2e b 201d8cc <rtems_rfs_dir_lookup_ino+0x158> <== NOT EXECUTED
201dc18: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201dc1c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201dc20: 7f ff db 85 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201dc24: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201dc28: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dc2c: 22 bf ff 27 be,a 201d8c8 <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
201dc30: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
201dc34: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201dc38: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
201dc3c: 40 00 1f 66 call 20259d4 <strerror> <== NOT EXECUTED
201dc40: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
201dc44: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201dc48: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201dc4c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201dc50: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
201dc54: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
201dc58: 40 00 1b 15 call 20248ac <printf> <== NOT EXECUTED
201dc5c: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
201dc60: 10 bf ff 1a b 201d8c8 <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
201dc64: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201dc68: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201dc6c: 7f ff db 72 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201dc70: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201dc74: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dc78: 22 bf ff 15 be,a 201d8cc <rtems_rfs_dir_lookup_ino+0x158><== NOT EXECUTED
201dc7c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
201dc80: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
201dc84: 40 00 1f 54 call 20259d4 <strerror> <== NOT EXECUTED
201dc88: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
201dc8c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201dc90: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201dc94: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
201dc98: 11 00 80 d9 sethi %hi(0x2036400), %o0 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
201dc9c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
201dca0: 40 00 1b 03 call 20248ac <printf> <== NOT EXECUTED
201dca4: 90 12 21 e8 or %o0, 0x1e8, %o0 <== NOT EXECUTED
201dca8: 10 bf ff 09 b 201d8cc <rtems_rfs_dir_lookup_ino+0x158> <== NOT EXECUTED
201dcac: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
0201e52c <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)
{
201e52c: 9d e3 bf 40 save %sp, -192, %sp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201e530: 90 10 20 00 clr %o0
201e534: 7f ff d9 40 call 2014a34 <rtems_rfs_trace>
201e538: 13 20 00 00 sethi %hi(0x80000000), %o1
201e53c: 80 8a 20 ff btst 0xff, %o0
201e540: 32 80 00 27 bne,a 201e5dc <rtems_rfs_dir_read+0xb0> <== NEVER TAKEN
201e544: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
201e548: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, dir, &map);
201e54c: 90 10 00 18 mov %i0, %o0
201e550: 92 10 00 19 mov %i1, %o1
201e554: 7f ff f6 92 call 201bf9c <rtems_rfs_block_map_open>
201e558: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201e55c: a0 92 20 00 orcc %o0, 0, %l0
201e560: 24 80 00 04 ble,a 201e570 <rtems_rfs_dir_read+0x44> <== ALWAYS TAKEN
201e564: e0 06 20 08 ld [ %i0 + 8 ], %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201e568: 81 c7 e0 08 ret
201e56c: 91 e8 00 10 restore %g0, %l0, %o0
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
201e570: 90 10 00 1a mov %i2, %o0
201e574: a2 10 00 10 mov %l0, %l1
201e578: 92 10 00 1b mov %i3, %o1
201e57c: a0 10 20 00 clr %l0
201e580: 96 10 00 11 mov %l1, %o3
201e584: 40 00 4a f2 call 203114c <__moddi3>
201e588: 94 10 00 10 mov %l0, %o2
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
201e58c: 92 a4 40 09 subcc %l1, %o1, %o1
201e590: 90 64 00 08 subx %l0, %o0, %o0
201e594: 80 a2 20 00 cmp %o0, 0
201e598: 04 80 00 18 ble 201e5f8 <rtems_rfs_dir_read+0xcc> <== ALWAYS TAKEN
201e59c: 01 00 00 00 nop
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
201e5a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e5a4: 92 07 bf b0 add %fp, -80, %o1
201e5a8: 94 10 00 1a mov %i2, %o2
201e5ac: 96 10 00 1b mov %i3, %o3
201e5b0: 7f ff f7 aa call 201c458 <rtems_rfs_block_map_seek>
201e5b4: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
201e5b8: a0 92 20 00 orcc %o0, 0, %l0
201e5bc: 04 80 00 25 ble 201e650 <rtems_rfs_dir_read+0x124> <== ALWAYS TAKEN
201e5c0: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
201e5c4: 02 80 00 1f be 201e640 <rtems_rfs_dir_read+0x114> <== NOT EXECUTED
201e5c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
201e5cc: 7f ff f6 d5 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
201e5d0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201e5d4: 81 c7 e0 08 ret <== NOT EXECUTED
201e5d8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
201e5dc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201e5e0: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201e5e4: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
201e5e8: 40 00 18 b1 call 20248ac <printf> <== NOT EXECUTED
201e5ec: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
201e5f0: 10 bf ff d7 b 201e54c <rtems_rfs_dir_read+0x20> <== NOT EXECUTED
201e5f4: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
201e5f8: 32 80 00 06 bne,a 201e610 <rtems_rfs_dir_read+0xe4> <== NEVER TAKEN
201e5fc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201e600: 80 a2 60 0a cmp %o1, 0xa
201e604: 38 bf ff e8 bgu,a 201e5a4 <rtems_rfs_dir_read+0x78> <== ALWAYS TAKEN
201e608: 90 10 00 18 mov %i0, %o0
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
201e60c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201e610: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201e614: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201e618: 40 00 49 e2 call 2030da0 <__divdi3> <== NOT EXECUTED
201e61c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201e620: 96 82 60 01 addcc %o1, 1, %o3 <== NOT EXECUTED
201e624: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
201e628: 94 42 20 00 addx %o0, 0, %o2 <== NOT EXECUTED
201e62c: 40 00 49 ab call 2030cd8 <__muldi3> <== NOT EXECUTED
201e630: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201e634: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
201e638: 10 bf ff da b 201e5a0 <rtems_rfs_dir_read+0x74> <== NOT EXECUTED
201e63c: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = ENOENT;
201e640: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
201e644: 7f ff f6 b7 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
201e648: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201e64c: 30 bf ff e2 b,a 201e5d4 <rtems_rfs_dir_read+0xa8> <== 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)
201e650: 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",
201e654: 2b 00 80 da sethi %hi(0x2036800), %l5
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201e658: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201e65c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201e660: c0 27 bf ac clr [ %fp + -84 ]
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
201e664: 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",
201e668: aa 15 61 b8 or %l5, 0x1b8, %l5
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201e66c: d4 07 bf a0 ld [ %fp + -96 ], %o2
201e670: 96 10 20 01 mov 1, %o3
201e674: 92 07 bf a4 add %fp, -92, %o1
201e678: 7f ff fa 4d call 201cfac <rtems_rfs_buffer_handle_request>
201e67c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
201e680: a0 92 20 00 orcc %o0, 0, %l0
201e684: 14 80 00 32 bg 201e74c <rtems_rfs_dir_read+0x220> <== NEVER TAKEN
201e688: c2 07 bf ac ld [ %fp + -84 ], %g1
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
201e68c: e4 07 bf c4 ld [ %fp + -60 ], %l2
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
201e690: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201e694: 90 10 20 00 clr %o0
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
201e698: a2 00 40 12 add %g1, %l2, %l1
elength = rtems_rfs_dir_entry_length (entry);
201e69c: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
201e6a0: e6 0c 60 08 ldub [ %l1 + 8 ], %l3
eino = rtems_rfs_dir_entry_ino (entry);
201e6a4: c8 08 40 12 ldub [ %g1 + %l2 ], %g4
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
201e6a8: a7 2c e0 08 sll %l3, 8, %l3
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201e6ac: 13 20 00 00 sethi %hi(0x80000000), %o1
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
201e6b0: a6 14 c0 02 or %l3, %g2, %l3
eino = rtems_rfs_dir_entry_ino (entry);
201e6b4: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
201e6b8: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
201e6bc: 80 a4 c0 14 cmp %l3, %l4
201e6c0: 12 80 00 2d bne 201e774 <rtems_rfs_dir_read+0x248>
201e6c4: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
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;
201e6c8: c4 06 20 08 ld [ %i0 + 8 ], %g2
201e6cc: c2 07 40 00 ld [ %i5 ], %g1
201e6d0: a4 20 80 12 sub %g2, %l2, %l2
201e6d4: a4 00 40 12 add %g1, %l2, %l2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201e6d8: 7f ff d8 d7 call 2014a34 <rtems_rfs_trace>
201e6dc: e4 27 40 00 st %l2, [ %i5 ]
201e6e0: 80 8a 20 ff btst 0xff, %o0
201e6e4: 12 80 00 0d bne 201e718 <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
201e6e8: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201e6ec: 92 07 bf b0 add %fp, -80, %o1
201e6f0: 7f ff f7 77 call 201c4cc <rtems_rfs_block_map_next_block>
201e6f4: 94 07 bf a0 add %fp, -96, %o2
if (rc == ENXIO)
201e6f8: 80 a2 20 06 cmp %o0, 6
201e6fc: 02 80 00 13 be 201e748 <rtems_rfs_dir_read+0x21c> <== ALWAYS TAKEN
201e700: a0 10 00 08 mov %o0, %l0
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
201e704: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201e708: 02 bf ff da be 201e670 <rtems_rfs_dir_read+0x144> <== NOT EXECUTED
201e70c: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== 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);
201e710: 10 80 00 10 b 201e750 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
201e714: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
201e718: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
201e71c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201e720: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
201e724: 40 00 18 62 call 20248ac <printf> <== NOT EXECUTED
201e728: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201e72c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e730: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201e734: 7f ff f7 66 call 201c4cc <rtems_rfs_block_map_next_block> <== NOT EXECUTED
201e738: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED
if (rc == ENXIO)
201e73c: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
201e740: 12 bf ff f1 bne 201e704 <rtems_rfs_dir_read+0x1d8> <== NOT EXECUTED
201e744: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = ENOENT;
201e748: a0 10 20 02 mov 2, %l0
201e74c: 92 07 bf a4 add %fp, -92, %o1
201e750: 7f ff f9 9d call 201cdc4 <rtems_rfs_buffer_handle_release>
201e754: 90 10 00 18 mov %i0, %o0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201e758: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
201e75c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201e760: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201e764: c0 27 bf ac clr [ %fp + -84 ]
201e768: 7f ff f6 6e call 201c120 <rtems_rfs_block_map_close>
201e76c: 92 07 bf b0 add %fp, -80, %o1
201e770: 30 bf ff 7e b,a 201e568 <rtems_rfs_dir_read+0x3c>
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201e774: 89 29 20 18 sll %g4, 0x18, %g4
201e778: 86 08 e0 ff and %g3, 0xff, %g3
201e77c: 84 08 a0 ff and %g2, 0xff, %g2
201e780: 87 28 e0 10 sll %g3, 0x10, %g3
201e784: 82 08 60 ff and %g1, 0xff, %g1
201e788: 88 11 00 03 or %g4, %g3, %g4
201e78c: 83 28 60 08 sll %g1, 8, %g1
201e790: 84 11 00 02 or %g4, %g2, %g2
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201e794: 80 a4 e0 0a cmp %l3, 0xa
201e798: 04 80 00 0d ble 201e7cc <rtems_rfs_dir_read+0x2a0> <== NEVER TAKEN
201e79c: a8 10 80 01 or %g2, %g1, %l4
201e7a0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201e7a4: 80 a4 c0 01 cmp %l3, %g1
201e7a8: 1a 80 00 0a bcc 201e7d0 <rtems_rfs_dir_read+0x2a4> <== NEVER TAKEN
201e7ac: 90 10 20 00 clr %o0
201e7b0: 80 a5 20 00 cmp %l4, 0
201e7b4: 02 80 00 08 be 201e7d4 <rtems_rfs_dir_read+0x2a8> <== NEVER TAKEN
201e7b8: 13 20 00 00 sethi %hi(0x80000000), %o1
201e7bc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
201e7c0: 80 a5 00 01 cmp %l4, %g1
201e7c4: 08 80 00 12 bleu 201e80c <rtems_rfs_dir_read+0x2e0> <== ALWAYS TAKEN
201e7c8: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201e7cc: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e7d0: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
201e7d4: 7f ff d8 98 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201e7d8: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
201e7dc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e7e0: 22 bf ff dc be,a 201e750 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
201e7e4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
201e7e8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201e7ec: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
201e7f0: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
201e7f4: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201e7f8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
201e7fc: 40 00 18 2c call 20248ac <printf> <== NOT EXECUTED
201e800: 90 12 21 38 or %o0, 0x138, %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);
201e804: 10 bf ff d3 b 201e750 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
201e808: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
201e80c: 92 10 20 00 clr %o1
201e810: 40 00 17 a9 call 20246b4 <memset>
201e814: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
201e818: c2 07 40 00 ld [ %i5 ], %g1
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
201e81c: 84 10 21 18 mov 0x118, %g2
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
201e820: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
201e824: c4 37 20 10 sth %g2, [ %i4 + 0x10 ]
*length += elength;
201e828: 82 04 c0 01 add %l3, %g1, %g1
201e82c: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
201e830: c4 06 20 08 ld [ %i0 + 8 ], %g2
201e834: 84 20 80 12 sub %g2, %l2, %g2
201e838: 84 20 80 13 sub %g2, %l3, %g2
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
201e83c: 80 a0 a0 0a cmp %g2, 0xa
201e840: 14 80 00 04 bg 201e850 <rtems_rfs_dir_read+0x324> <== ALWAYS TAKEN
201e844: a6 04 ff f6 add %l3, -10, %l3
*length += remaining;
201e848: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
201e84c: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
201e850: 80 a4 e0 ff cmp %l3, 0xff
201e854: 34 80 00 02 bg,a 201e85c <rtems_rfs_dir_read+0x330> <== NEVER TAKEN
201e858: a6 10 20 ff mov 0xff, %l3 <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
201e85c: 92 04 60 0a add %l1, 0xa, %o1
201e860: 94 10 00 13 mov %l3, %o2
201e864: ba 07 20 14 add %i4, 0x14, %i5
201e868: 40 00 17 04 call 2024478 <memcpy>
201e86c: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
201e870: c8 0c 40 00 ldub [ %l1 ], %g4
201e874: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
201e878: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
201e87c: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
201e880: 89 29 20 18 sll %g4, 0x18, %g4
201e884: 87 28 e0 10 sll %g3, 0x10, %g3
201e888: 83 28 60 08 sll %g1, 8, %g1
201e88c: 86 11 00 03 or %g4, %g3, %g3
201e890: 84 10 c0 02 or %g3, %g2, %g2
201e894: 82 10 80 01 or %g2, %g1, %g1
dirent->d_namlen = elength;
201e898: e6 37 20 12 sth %l3, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201e89c: 90 10 20 00 clr %o0
201e8a0: 13 20 00 00 sethi %hi(0x80000000), %o1
201e8a4: 7f ff d8 64 call 2014a34 <rtems_rfs_trace>
201e8a8: c2 27 00 00 st %g1, [ %i4 ]
201e8ac: 80 8a 20 ff btst 0xff, %o0
201e8b0: 22 bf ff a8 be,a 201e750 <rtems_rfs_dir_read+0x224> <== ALWAYS TAKEN
201e8b4: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
201e8b8: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
201e8bc: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
201e8c0: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
201e8c4: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
201e8c8: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201e8cc: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
201e8d0: 40 00 17 f7 call 20248ac <printf> <== NOT EXECUTED
201e8d4: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED
201e8d8: 10 bf ff 9e b 201e750 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
201e8dc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
0201eeb0 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
201eeb0: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201eeb4: 90 10 20 10 mov 0x10, %o0
201eeb8: 92 10 20 00 clr %o1
201eebc: 7f ff d6 de call 2014a34 <rtems_rfs_trace>
201eec0: ba 10 00 18 mov %i0, %i5
201eec4: 80 8a 20 ff btst 0xff, %o0
201eec8: 32 80 00 87 bne,a 201f0e4 <rtems_rfs_file_close+0x234> <== NEVER TAKEN
201eecc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
if (handle->shared->references > 0)
201eed0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201eed4: c2 02 60 08 ld [ %o1 + 8 ], %g1
201eed8: 80 a0 60 00 cmp %g1, 0
201eedc: 04 80 00 04 ble 201eeec <rtems_rfs_file_close+0x3c> <== NEVER TAKEN
201eee0: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
201eee4: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
201eee8: 80 a0 60 00 cmp %g1, 0
201eeec: 12 80 00 74 bne 201f0bc <rtems_rfs_file_close+0x20c> <== NEVER TAKEN
201eef0: 90 10 00 1d mov %i5, %o0
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
201eef4: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
201eef8: 80 a0 60 00 cmp %g1, 0
201eefc: 22 80 00 a7 be,a 201f198 <rtems_rfs_file_close+0x2e8> <== ALWAYS TAKEN
201ef00: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
201ef04: c4 02 60 8c ld [ %o1 + 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);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ef08: 86 10 20 01 mov 1, %g3
*/
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);
201ef0c: 89 30 a0 18 srl %g2, 0x18, %g4
201ef10: c8 28 60 10 stb %g4, [ %g1 + 0x10 ]
201ef14: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
201ef18: 89 30 a0 10 srl %g2, 0x10, %g4
201ef1c: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
201ef20: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
201ef24: 89 30 a0 08 srl %g2, 8, %g4
201ef28: c8 28 60 12 stb %g4, [ %g1 + 0x12 ]
201ef2c: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
201ef30: c4 28 60 13 stb %g2, [ %g1 + 0x13 ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
201ef34: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ef38: c6 2a 60 1c stb %g3, [ %o1 + 0x1c ]
201ef3c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1
*/
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);
201ef40: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
201ef44: b9 30 60 18 srl %g1, 0x18, %i4
201ef48: f8 29 20 14 stb %i4, [ %g4 + 0x14 ]
201ef4c: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
201ef50: b9 30 60 10 srl %g1, 0x10, %i4
201ef54: f8 29 20 15 stb %i4, [ %g4 + 0x15 ]
201ef58: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
201ef5c: b9 30 60 08 srl %g1, 8, %i4
201ef60: f8 29 20 16 stb %i4, [ %g4 + 0x16 ]
201ef64: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
201ef68: c2 29 20 17 stb %g1, [ %g4 + 0x17 ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
201ef6c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ef70: c6 28 a0 1c stb %g3, [ %g2 + 0x1c ]
*/
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);
201ef74: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ef78: c4 00 60 94 ld [ %g1 + 0x94 ], %g2
201ef7c: b9 30 a0 18 srl %g2, 0x18, %i4
201ef80: f8 29 20 18 stb %i4, [ %g4 + 0x18 ]
201ef84: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ef88: b9 30 a0 10 srl %g2, 0x10, %i4
201ef8c: f8 29 20 19 stb %i4, [ %g4 + 0x19 ]
201ef90: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ef94: b9 30 a0 08 srl %g2, 8, %i4
201ef98: f8 29 20 1a stb %i4, [ %g4 + 0x1a ]
201ef9c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201efa0: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
201efa4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201efa8: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
201efac: c4 02 60 3c ld [ %o1 + 0x3c ], %g2
201efb0: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
201efb4: 80 a0 40 02 cmp %g1, %g2
201efb8: 02 80 00 72 be 201f180 <rtems_rfs_file_close+0x2d0> <== ALWAYS TAKEN
201efbc: c4 02 60 88 ld [ %o1 + 0x88 ], %g2
*/
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);
201efc0: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED
201efc4: c4 22 60 40 st %g2, [ %o1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
201efc8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
201efcc: b0 10 20 00 clr %i0 <== NOT EXECUTED
201efd0: c2 2a 60 34 stb %g1, [ %o1 + 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);
201efd4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201efd8: 7f ff f4 52 call 201c120 <rtems_rfs_block_map_close>
201efdc: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
201efe0: b8 92 20 00 orcc %o0, 0, %i4
201efe4: 04 80 00 0a ble 201f00c <rtems_rfs_file_close+0x15c> <== ALWAYS TAKEN
201efe8: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201efec: 7f ff d6 92 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201eff0: 92 10 20 00 clr %o1 <== NOT EXECUTED
201eff4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201eff8: 32 80 00 57 bne,a 201f154 <rtems_rfs_file_close+0x2a4> <== NOT EXECUTED
201effc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201f000: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201f004: 22 80 00 02 be,a 201f00c <rtems_rfs_file_close+0x15c> <== NOT EXECUTED
201f008: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
201f00c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201f010: 90 10 00 1d mov %i5, %o0
201f014: 7f ff d0 59 call 2013178 <rtems_rfs_inode_close>
201f018: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
201f01c: b8 92 20 00 orcc %o0, 0, %i4
201f020: 04 80 00 0a ble 201f048 <rtems_rfs_file_close+0x198> <== ALWAYS TAKEN
201f024: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201f028: 7f ff d6 83 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201f02c: 92 10 20 00 clr %o1 <== NOT EXECUTED
201f030: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f034: 32 80 00 3d bne,a 201f128 <rtems_rfs_file_close+0x278> <== NOT EXECUTED
201f038: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201f03c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201f040: 22 80 00 2f be,a 201f0fc <rtems_rfs_file_close+0x24c> <== NOT EXECUTED
201f044: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
201f048: 7f ff ea d1 call 2019b8c <_Chain_Extract>
201f04c: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
201f050: 7f ff a5 ed call 2008804 <free>
201f054: 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);
201f058: 90 10 00 1d mov %i5, %o0
201f05c: 7f ff f7 5a call 201cdc4 <rtems_rfs_buffer_handle_release>
201f060: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
201f064: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
201f068: 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)
201f06c: 80 a6 20 00 cmp %i0, 0
201f070: 04 80 00 19 ble 201f0d4 <rtems_rfs_file_close+0x224> <== ALWAYS TAKEN
201f074: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201f078: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
201f07c: 7f ff d6 6e call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201f080: 92 10 20 00 clr %o1 <== NOT EXECUTED
201f084: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f088: 02 80 00 13 be 201f0d4 <rtems_rfs_file_close+0x224> <== NOT EXECUTED
201f08c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
201f090: 40 00 1a 51 call 20259d4 <strerror> <== NOT EXECUTED
201f094: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201f098: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201f09c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201f0a0: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201f0a4: 40 00 16 02 call 20248ac <printf> <== NOT EXECUTED
201f0a8: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 2036be8 <CSWTCH.2+0xed4> <== NOT EXECUTED
}
free (handle);
201f0ac: 7f ff a5 d6 call 2008804 <free> <== NOT EXECUTED
201f0b0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
201f0b4: 81 c7 e0 08 ret <== NOT EXECUTED
201f0b8: 81 e8 00 00 restore <== 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);
201f0bc: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED
201f0c0: 7f ff f7 41 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201f0c4: b0 10 20 00 clr %i0 <== NOT EXECUTED
handle->dirty = false;
201f0c8: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
201f0cc: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
handle->buffer = NULL;
201f0d0: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
201f0d4: 7f ff a5 cc call 2008804 <free>
201f0d8: 90 10 00 19 mov %i1, %o0
201f0dc: 81 c7 e0 08 ret
201f0e0: 81 e8 00 00 restore
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
201f0e4: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201f0e8: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
201f0ec: 40 00 15 f0 call 20248ac <printf> <== NOT EXECUTED
201f0f0: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
201f0f4: 10 bf ff 78 b 201eed4 <rtems_rfs_file_close+0x24> <== NOT EXECUTED
201f0f8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
201f0fc: 7f ff ea a4 call 2019b8c <_Chain_Extract> <== NOT EXECUTED
201f100: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
if (rrc == 0)
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
201f104: 7f ff a5 c0 call 2008804 <free> <== NOT EXECUTED
201f108: d0 06 60 1c ld [ %i1 + 0x1c ], %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);
201f10c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f110: 7f ff f7 2d call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201f114: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED
handle->dirty = false;
201f118: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
201f11c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
handle->buffer = NULL;
201f120: 10 bf ff d6 b 201f078 <rtems_rfs_file_close+0x1c8> <== NOT EXECUTED
201f124: c0 26 60 0c clr [ %i1 + 0xc ] <== 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",
201f128: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201f12c: 40 00 1a 2a call 20259d4 <strerror> <== NOT EXECUTED
201f130: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
201f134: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201f138: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201f13c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201f140: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201f144: 40 00 15 da call 20248ac <printf> <== NOT EXECUTED
201f148: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 2036ba8 <CSWTCH.2+0xe94> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201f14c: 10 bf ff bd b 201f040 <rtems_rfs_file_close+0x190> <== NOT EXECUTED
201f150: 80 a6 20 00 cmp %i0, 0 <== 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",
201f154: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201f158: 40 00 1a 1f call 20259d4 <strerror> <== NOT EXECUTED
201f15c: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
201f160: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201f164: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201f168: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201f16c: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201f170: 40 00 15 cf call 20248ac <printf> <== NOT EXECUTED
201f174: 90 12 23 68 or %o0, 0x368, %o0 ! 2036b68 <CSWTCH.2+0xe54> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201f178: 10 bf ff a3 b 201f004 <rtems_rfs_file_close+0x154> <== NOT EXECUTED
201f17c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
201f180: c6 02 60 40 ld [ %o1 + 0x40 ], %g3
201f184: 80 a0 80 03 cmp %g2, %g3
201f188: 12 bf ff 8e bne 201efc0 <rtems_rfs_file_close+0x110> <== NEVER TAKEN
201f18c: b0 10 20 00 clr %i0
&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);
201f190: 10 bf ff 92 b 201efd8 <rtems_rfs_file_close+0x128>
201f194: 90 10 00 1d mov %i5, %o0
handle->shared->references--;
if (handle->shared->references == 0)
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
201f198: 7f ff cf 53 call 2012ee4 <rtems_rfs_inode_load>
201f19c: 90 10 00 1d mov %i5, %o0
201f1a0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
if (rrc == 0)
201f1a4: 80 a2 20 00 cmp %o0, 0
201f1a8: 12 bf ff 8b bne 201efd4 <rtems_rfs_file_close+0x124> <== NEVER TAKEN
201f1ac: b0 10 00 08 mov %o0, %i0
201f1b0: 10 bf ff 55 b 201ef04 <rtems_rfs_file_close+0x54>
201f1b4: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
0201fb60 <rtems_rfs_file_get_shared>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
201fb60: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
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 ));
201fb64: 90 02 20 78 add %o0, 0x78, %o0
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
201fb68: 80 a0 40 08 cmp %g1, %o0
201fb6c: 32 80 00 08 bne,a 201fb8c <rtems_rfs_file_get_shared+0x2c>
201fb70: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
201fb74: 81 c3 e0 08 retl
201fb78: 90 10 20 00 clr %o0
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
201fb7c: 80 a0 40 08 cmp %g1, %o0
201fb80: 22 80 00 08 be,a 201fba0 <rtems_rfs_file_get_shared+0x40><== ALWAYS TAKEN
201fb84: 90 10 20 00 clr %o0
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
201fb88: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
201fb8c: 80 a0 80 09 cmp %g2, %o1
201fb90: 32 bf ff fb bne,a 201fb7c <rtems_rfs_file_get_shared+0x1c>
201fb94: c2 00 40 00 ld [ %g1 ], %g1
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
201fb98: 81 c3 e0 08 retl
201fb9c: 90 10 00 01 mov %g1, %o0
201fba0: 81 c3 e0 08 retl
0201f3fc <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
201f3fc: 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))
201f400: 90 10 20 20 mov 0x20, %o0
201f404: 92 10 20 00 clr %o1
201f408: 7f ff d5 8b call 2014a34 <rtems_rfs_trace>
201f40c: ba 10 00 18 mov %i0, %i5
201f410: 80 8a 20 ff btst 0xff, %o0
201f414: 22 80 00 0c be,a 201f444 <rtems_rfs_file_io_end+0x48> <== ALWAYS TAKEN
201f418: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
201f41c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201f420: 12 80 00 22 bne 201f4a8 <rtems_rfs_file_io_end+0xac> <== NOT EXECUTED
201f424: 13 00 80 d6 sethi %hi(0x2035800), %o1 <== NOT EXECUTED
201f428: 13 00 80 db sethi %hi(0x2036c00), %o1 <== NOT EXECUTED
201f42c: 92 12 60 10 or %o1, 0x10, %o1 ! 2036c10 <CSWTCH.2+0xefc> <== NOT EXECUTED
201f430: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201f434: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
201f438: 40 00 15 1d call 20248ac <printf> <== NOT EXECUTED
201f43c: 90 12 20 d0 or %o0, 0xd0, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
201f440: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
201f444: 80 a0 60 00 cmp %g1, 0
201f448: 02 80 00 1a be 201f4b0 <rtems_rfs_file_io_end+0xb4> <== NEVER TAKEN
201f44c: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
201f450: 12 80 00 8b bne 201f67c <rtems_rfs_file_io_end+0x280>
201f454: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201f458: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
201f45c: 82 10 20 01 mov 1, %g1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201f460: 92 07 60 04 add %i5, 4, %o1
201f464: 7f ff f6 58 call 201cdc4 <rtems_rfs_buffer_handle_release>
201f468: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rtems_rfs_file_buffer (handle));
if (rc > 0)
201f46c: b0 92 20 00 orcc %o0, 0, %i0
201f470: 04 80 00 11 ble 201f4b4 <rtems_rfs_file_io_end+0xb8> <== ALWAYS TAKEN
201f474: 39 00 80 db sethi %hi(0x2036c00), %i4
{
printf (
201f478: b8 17 20 10 or %i4, 0x10, %i4 ! 2036c10 <CSWTCH.2+0xefc> <== NOT EXECUTED
201f47c: 40 00 19 56 call 20259d4 <strerror> <== NOT EXECUTED
201f480: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201f484: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201f488: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201f48c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
201f490: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201f494: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
201f498: 40 00 15 05 call 20248ac <printf> <== NOT EXECUTED
201f49c: 90 12 20 f8 or %o0, 0xf8, %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;
201f4a0: 81 c7 e0 08 ret <== NOT EXECUTED
201f4a4: 81 e8 00 00 restore <== NOT EXECUTED
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
201f4a8: 10 bf ff e2 b 201f430 <rtems_rfs_file_io_end+0x34> <== NOT EXECUTED
201f4ac: 92 12 60 e0 or %o1, 0xe0, %o1 <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
201f4b0: b0 10 20 00 clr %i0 <== NOT EXECUTED
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201f4b4: 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;
201f4b8: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201f4bc: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
* 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;
201f4c0: b2 06 40 03 add %i1, %g3, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201f4c4: 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 >=
201f4c8: 80 a6 40 02 cmp %i1, %g2
201f4cc: 0a 80 00 07 bcs 201f4e8 <rtems_rfs_file_io_end+0xec>
201f4d0: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
201f4d4: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201f4d8: 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++;
201f4dc: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201f4e0: 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++;
201f4e4: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
201f4e8: 80 a6 a0 00 cmp %i2, 0
201f4ec: 32 80 00 11 bne,a 201f530 <rtems_rfs_file_io_end+0x134>
201f4f0: f2 07 40 00 ld [ %i5 ], %i1
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
201f4f4: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
}
length = false;
mtime = false;
if (!read &&
201f4f8: 80 a0 a0 00 cmp %g2, 0
201f4fc: 02 80 00 05 be 201f510 <rtems_rfs_file_io_end+0x114>
201f500: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
201f504: 80 a0 e0 00 cmp %g3, 0
201f508: 22 80 00 25 be,a 201f59c <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
201f50c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3 <== NOT EXECUTED
201f510: 80 a0 c0 02 cmp %g3, %g2
201f514: 28 80 00 22 bleu,a 201f59c <rtems_rfs_file_io_end+0x1a0>
201f518: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
201f51c: 86 00 ff ff add %g3, -1, %g3
201f520: 80 a0 80 03 cmp %g2, %g3
201f524: 22 80 00 5f be,a 201f6a0 <rtems_rfs_file_io_end+0x2a4>
201f528: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201f52c: f2 07 40 00 ld [ %i5 ], %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
201f530: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201f534: b2 0e 60 01 and %i1, 1, %i1
201f538: b2 1e 60 01 xor %i1, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
201f53c: b6 10 20 00 clr %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f540: 90 10 20 20 mov 0x20, %o0
201f544: 92 10 20 00 clr %o1
201f548: 7f ff d5 3b call 2014a34 <rtems_rfs_trace>
201f54c: b2 0e 60 ff and %i1, 0xff, %i1
201f550: 80 8a 20 ff btst 0xff, %o0
201f554: 12 80 00 22 bne 201f5dc <rtems_rfs_file_io_end+0x1e0> <== NEVER TAKEN
201f558: 80 a0 00 19 cmp %g0, %i1
201f55c: b8 0f 20 ff and %i4, 0xff, %i4
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
201f560: 80 a7 20 00 cmp %i4, 0
201f564: 12 80 00 33 bne 201f630 <rtems_rfs_file_io_end+0x234>
201f568: b6 0e e0 ff and %i3, 0xff, %i3
201f56c: 80 a6 60 00 cmp %i1, 0
201f570: 12 80 00 30 bne 201f630 <rtems_rfs_file_io_end+0x234> <== ALWAYS TAKEN
201f574: 80 a6 e0 00 cmp %i3, 0
if (read && atime)
handle->shared->atime = now;
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
201f578: 02 80 00 17 be 201f5d4 <rtems_rfs_file_io_end+0x1d8>
201f57c: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
201f580: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
201f584: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
201f588: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
201f58c: c6 20 60 84 st %g3, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
201f590: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
201f594: 81 c7 e0 08 ret
201f598: 81 e8 00 00 restore
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201f59c: c4 07 40 00 ld [ %i5 ], %g2
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
201f5a0: c6 20 60 40 st %g3, [ %g1 + 0x40 ]
map->dirty = true;
201f5a4: 86 10 20 01 mov 1, %g3
201f5a8: c6 28 60 34 stb %g3, [ %g1 + 0x34 ]
201f5ac: b2 08 a0 01 and %g2, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
201f5b0: b9 30 a0 01 srl %g2, 1, %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201f5b4: b2 1e 60 01 xor %i1, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
201f5b8: b8 1f 20 01 xor %i4, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
201f5bc: b6 10 20 01 mov 1, %i3
201f5c0: 80 88 a0 04 btst 4, %g2
201f5c4: 02 bf ff df be 201f540 <rtems_rfs_file_io_end+0x144> <== ALWAYS TAKEN
201f5c8: b8 0f 20 01 and %i4, 1, %i4
201f5cc: 10 bf ff dd b 201f540 <rtems_rfs_file_io_end+0x144> <== NOT EXECUTED
201f5d0: b6 10 20 00 clr %i3 <== NOT EXECUTED
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
201f5d4: 81 c7 e0 08 ret
201f5d8: 81 e8 00 00 restore
atime = rtems_rfs_file_update_atime (handle);
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
201f5dc: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED
201f5e0: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
201f5e4: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
201f5e8: 80 a0 00 1c cmp %g0, %i4 <== NOT EXECUTED
201f5ec: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
201f5f0: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
201f5f4: b6 0e e0 ff and %i3, 0xff, %i3 <== NOT EXECUTED
201f5f8: 80 a0 00 1b cmp %g0, %i3 <== NOT EXECUTED
201f5fc: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
201f600: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
201f604: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
201f608: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
201f60c: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201f610: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
201f614: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
201f618: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
201f61c: 40 00 14 a4 call 20248ac <printf> <== NOT EXECUTED
201f620: 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)
201f624: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
201f628: 02 bf ff d2 be 201f570 <rtems_rfs_file_io_end+0x174> <== NOT EXECUTED
201f62c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
{
time_t now = time (NULL);
201f630: 40 00 24 99 call 2028894 <time>
201f634: 90 10 20 00 clr %o0
if (read && atime)
201f638: 80 a6 60 00 cmp %i1, 0
201f63c: 02 80 00 06 be 201f654 <rtems_rfs_file_io_end+0x258> <== NEVER TAKEN
201f640: 80 a7 20 00 cmp %i4, 0
201f644: 80 a6 a0 00 cmp %i2, 0
201f648: 32 80 00 0b bne,a 201f674 <rtems_rfs_file_io_end+0x278>
201f64c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->shared->atime = now;
if (!read && mtime)
201f650: 80 a7 20 00 cmp %i4, 0
201f654: 02 bf ff c9 be 201f578 <rtems_rfs_file_io_end+0x17c>
201f658: 80 a6 e0 00 cmp %i3, 0
201f65c: 80 a6 a0 01 cmp %i2, 1
201f660: 02 bf ff c6 be 201f578 <rtems_rfs_file_io_end+0x17c> <== NEVER TAKEN
201f664: 80 a6 e0 00 cmp %i3, 0
handle->shared->mtime = now;
201f668: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201f66c: 10 bf ff c3 b 201f578 <rtems_rfs_file_io_end+0x17c>
201f670: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
if (atime || mtime)
{
time_t now = time (NULL);
if (read && atime)
handle->shared->atime = now;
201f674: 10 bf ff f7 b 201f650 <rtems_rfs_file_io_end+0x254>
201f678: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201f67c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f680: 92 07 60 04 add %i5, 4, %o1
201f684: 7f ff f5 d0 call 201cdc4 <rtems_rfs_buffer_handle_release>
201f688: 39 00 80 d6 sethi %hi(0x2035800), %i4
rtems_rfs_file_buffer (handle));
if (rc > 0)
201f68c: b0 92 20 00 orcc %o0, 0, %i0
201f690: 14 bf ff 7b bg 201f47c <rtems_rfs_file_io_end+0x80> <== NEVER TAKEN
201f694: b8 17 20 e0 or %i4, 0xe0, %i4
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201f698: 10 bf ff 88 b 201f4b8 <rtems_rfs_file_io_end+0xbc>
201f69c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
length = false;
mtime = false;
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
201f6a0: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
201f6a4: 80 a0 c0 02 cmp %g3, %g2
201f6a8: 28 bf ff a2 bleu,a 201f530 <rtems_rfs_file_io_end+0x134>
201f6ac: f2 07 40 00 ld [ %i5 ], %i1
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201f6b0: 10 bf ff bc b 201f5a0 <rtems_rfs_file_io_end+0x1a4>
201f6b4: c4 07 40 00 ld [ %i5 ], %g2
0201f6b8 <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))
201f6b8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
201f6bc: 80 a0 60 00 cmp %g1, 0
201f6c0: 02 80 00 07 be 201f6dc <rtems_rfs_file_io_release+0x24> <== ALWAYS TAKEN
201f6c4: 92 02 20 04 add %o0, 4, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201f6c8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
201f6cc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
201f6d0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201f6d4: 7f ff f5 bc call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201f6d8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
201f6dc: 81 c3 e0 08 retl
201f6e0: 90 10 20 00 clr %o0
0201f1b8 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
201f1b8: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f1bc: 90 10 20 20 mov 0x20, %o0
201f1c0: 92 10 20 00 clr %o1
201f1c4: 7f ff d6 1c call 2014a34 <rtems_rfs_trace>
201f1c8: ba 10 00 18 mov %i0, %i5
201f1cc: 80 8a 20 ff btst 0xff, %o0
201f1d0: 22 80 00 0d be,a 201f204 <rtems_rfs_file_io_start+0x4c> <== ALWAYS TAKEN
201f1d4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
201f1d8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201f1dc: 02 80 00 2f be 201f298 <rtems_rfs_file_io_start+0xe0> <== NOT EXECUTED
201f1e0: 13 00 80 db sethi %hi(0x2036c00), %o1 <== NOT EXECUTED
201f1e4: 13 00 80 d6 sethi %hi(0x2035800), %o1 <== NOT EXECUTED
201f1e8: 92 12 60 e0 or %o1, 0xe0, %o1 ! 20358e0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201f1ec: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
201f1f0: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
201f1f4: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201f1f8: 40 00 15 ad call 20248ac <printf> <== NOT EXECUTED
201f1fc: 90 12 20 18 or %o0, 0x18, %o0 ! 2036c18 <CSWTCH.2+0xf04> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
201f200: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
201f204: 80 a0 60 00 cmp %g1, 0
201f208: 22 80 00 2c be,a 201f2b8 <rtems_rfs_file_io_start+0x100>
201f20c: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
block, request_read);
if (rc > 0)
return rc;
}
if (read
201f210: 80 a6 a0 00 cmp %i2, 0
201f214: 02 80 00 0d be 201f248 <rtems_rfs_file_io_start+0x90>
201f218: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
201f21c: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
201f220: 80 a0 a0 00 cmp %g2, 0
201f224: 12 80 00 1f bne 201f2a0 <rtems_rfs_file_io_start+0xe8>
201f228: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
201f22c: 80 a0 e0 00 cmp %g3, 0
201f230: 12 80 00 1d bne 201f2a4 <rtems_rfs_file_io_start+0xec> <== ALWAYS TAKEN
201f234: 86 00 ff ff add %g3, -1, %g3
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
201f238: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
201f23c: 80 a7 20 00 cmp %i4, 0
201f240: 32 80 00 05 bne,a 201f254 <rtems_rfs_file_io_start+0x9c>
201f244: 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));
201f248: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
201f24c: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
201f250: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f254: 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);
201f258: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f25c: 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);
201f260: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f264: 7f ff d5 f4 call 2014a34 <rtems_rfs_trace>
201f268: b0 10 20 00 clr %i0
201f26c: 80 8a 20 ff btst 0xff, %o0
201f270: 32 80 00 04 bne,a 201f280 <rtems_rfs_file_io_start+0xc8> <== NEVER TAKEN
201f274: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
*available, size);
return 0;
}
201f278: 81 c7 e0 08 ret
201f27c: 81 e8 00 00 restore
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
*available = size - rtems_rfs_file_block_offset (handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
201f280: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201f284: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201f288: 40 00 15 89 call 20248ac <printf> <== NOT EXECUTED
201f28c: 90 12 20 a0 or %o0, 0xa0, %o0 ! 2036ca0 <CSWTCH.2+0xf8c> <== NOT EXECUTED
*available, size);
return 0;
}
201f290: 81 c7 e0 08 ret <== NOT EXECUTED
201f294: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
201f298: 10 bf ff d5 b 201f1ec <rtems_rfs_file_io_start+0x34> <== NOT EXECUTED
201f29c: 92 12 60 10 or %o1, 0x10, %o1 <== NOT EXECUTED
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
201f2a0: 86 00 ff ff add %g3, -1, %g3
201f2a4: 80 a0 80 03 cmp %g2, %g3
201f2a8: 32 bf ff e9 bne,a 201f24c <rtems_rfs_file_io_start+0x94>
201f2ac: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
201f2b0: 10 bf ff e3 b 201f23c <rtems_rfs_file_io_start+0x84>
201f2b4: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
201f2b8: 94 07 60 10 add %i5, 0x10, %o2
201f2bc: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f2c0: 96 07 bf fc add %fp, -4, %o3
201f2c4: 7f ff f4 0b call 201c2f0 <rtems_rfs_block_map_find>
201f2c8: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
201f2cc: b0 92 20 00 orcc %o0, 0, %i0
201f2d0: 04 80 00 0a ble 201f2f8 <rtems_rfs_file_io_start+0x140>
201f2d4: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
201f2d8: 32 bf ff e8 bne,a 201f278 <rtems_rfs_file_io_start+0xc0> <== NEVER TAKEN
201f2dc: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
201f2e0: 80 a6 a0 00 cmp %i2, 0
201f2e4: 22 80 00 2d be,a 201f398 <rtems_rfs_file_io_start+0x1e0> <== ALWAYS TAKEN
201f2e8: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
201f2ec: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
201f2f0: 81 c7 e0 08 ret <== NOT EXECUTED
201f2f4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
201f2f8: 80 a6 a0 00 cmp %i2, 0
201f2fc: 12 80 00 0d bne 201f330 <rtems_rfs_file_io_start+0x178>
201f300: 82 10 00 1a mov %i2, %g1
201f304: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
201f308: 80 a0 a0 00 cmp %g2, 0
201f30c: 12 80 00 09 bne 201f330 <rtems_rfs_file_io_start+0x178>
201f310: 82 10 20 01 mov 1, %g1
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
201f314: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
* 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) ||
201f318: c6 06 40 00 ld [ %i1 ], %g3
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
201f31c: c4 00 a0 98 ld [ %g2 + 0x98 ], %g2
* 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) ||
201f320: c4 00 a0 08 ld [ %g2 + 8 ], %g2
201f324: 80 a0 c0 02 cmp %g3, %g2
201f328: 3a 80 00 02 bcc,a 201f330 <rtems_rfs_file_io_start+0x178><== NEVER TAKEN
201f32c: 82 10 20 00 clr %g1 <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f330: 90 10 20 20 mov 0x20, %o0
201f334: 92 10 20 00 clr %o1
201f338: 7f ff d5 bf call 2014a34 <rtems_rfs_trace>
201f33c: b8 08 60 ff and %g1, 0xff, %i4
201f340: 80 8a 20 ff btst 0xff, %o0
201f344: 22 80 00 0b be,a 201f370 <rtems_rfs_file_io_start+0x1b8> <== ALWAYS TAKEN
201f348: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
201f34c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
201f350: 02 80 00 24 be 201f3e0 <rtems_rfs_file_io_start+0x228> <== NOT EXECUTED
201f354: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
201f358: 15 00 80 d4 sethi %hi(0x2035000), %o2 <== NOT EXECUTED
201f35c: 94 12 a3 60 or %o2, 0x360, %o2 ! 2035360 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
201f360: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201f364: 40 00 15 52 call 20248ac <printf> <== NOT EXECUTED
201f368: 90 12 20 68 or %o0, 0x68, %o0 ! 2036c68 <CSWTCH.2+0xf54> <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
201f36c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
201f370: d4 07 bf fc ld [ %fp + -4 ], %o2
201f374: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f378: 92 07 60 04 add %i5, 4, %o1
201f37c: 7f ff f7 0c call 201cfac <rtems_rfs_buffer_handle_request>
201f380: 96 10 00 1c mov %i4, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
201f384: b0 92 20 00 orcc %o0, 0, %i0
201f388: 04 bf ff a3 ble 201f214 <rtems_rfs_file_io_start+0x5c> <== ALWAYS TAKEN
201f38c: 80 a6 a0 00 cmp %i2, 0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
*available, size);
return 0;
}
201f390: 81 c7 e0 08 ret <== NOT EXECUTED
201f394: 81 e8 00 00 restore <== NOT EXECUTED
{
*available = 0;
return 0;
}
if (rc != ENXIO)
201f398: 12 bf ff b8 bne 201f278 <rtems_rfs_file_io_start+0xc0> <== NEVER TAKEN
201f39c: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f3a0: 7f ff d5 a5 call 2014a34 <rtems_rfs_trace>
201f3a4: 92 10 20 00 clr %o1
201f3a8: 80 8a 20 ff btst 0xff, %o0
201f3ac: 12 80 00 10 bne 201f3ec <rtems_rfs_file_io_start+0x234> <== NEVER TAKEN
201f3b0: 11 00 80 db sethi %hi(0x2036c00), %o0
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
201f3b4: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
201f3b8: 94 10 20 01 mov 1, %o2
201f3bc: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f3c0: 96 07 bf fc add %fp, -4, %o3
201f3c4: 7f ff f4 4f call 201c500 <rtems_rfs_block_map_grow>
201f3c8: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
201f3cc: b0 92 20 00 orcc %o0, 0, %i0
201f3d0: 14 bf ff aa bg 201f278 <rtems_rfs_file_io_start+0xc0>
201f3d4: 82 10 20 00 clr %g1
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f3d8: 10 bf ff d7 b 201f334 <rtems_rfs_file_io_start+0x17c>
201f3dc: 90 10 20 20 mov 0x20, %o0
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
201f3e0: 15 00 80 cd sethi %hi(0x2033400), %o2 <== NOT EXECUTED
201f3e4: 10 bf ff df b 201f360 <rtems_rfs_file_io_start+0x1a8> <== NOT EXECUTED
201f3e8: 94 12 a1 18 or %o2, 0x118, %o2 ! 2033518 <__FUNCTION__.7127+0x580><== NOT EXECUTED
if (rc != ENXIO)
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
201f3ec: 40 00 15 c8 call 2024b0c <puts> <== NOT EXECUTED
201f3f0: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
201f3f4: 10 bf ff f1 b 201f3b8 <rtems_rfs_file_io_start+0x200> <== NOT EXECUTED
201f3f8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
0201eb6c <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)
{
201eb6c: 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))
201eb70: 90 10 20 08 mov 8, %o0
201eb74: 92 10 20 00 clr %o1
201eb78: 7f ff d7 af call 2014a34 <rtems_rfs_trace>
201eb7c: a0 10 00 18 mov %i0, %l0
201eb80: 80 8a 20 ff btst 0xff, %o0
201eb84: 12 80 00 2b bne 201ec30 <rtems_rfs_file_open+0xc4> <== NEVER TAKEN
201eb88: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
201eb8c: c0 26 c0 00 clr [ %i3 ]
/*
* 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));
201eb90: 90 10 20 20 mov 0x20, %o0
201eb94: 7f ff a8 b9 call 2008e78 <malloc>
201eb98: b0 10 20 0c mov 0xc, %i0
if (!handle)
201eb9c: 80 a2 20 00 cmp %o0, 0
201eba0: 02 80 00 4f be 201ecdc <rtems_rfs_file_open+0x170> <== NEVER TAKEN
201eba4: b8 10 00 08 mov %o0, %i4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
201eba8: fa 04 20 74 ld [ %l0 + 0x74 ], %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
201ebac: c0 22 00 00 clr [ %o0 ]
201ebb0: c0 22 20 04 clr [ %o0 + 4 ]
201ebb4: c0 22 20 10 clr [ %o0 + 0x10 ]
201ebb8: c0 22 20 14 clr [ %o0 + 0x14 ]
201ebbc: c0 22 20 18 clr [ %o0 + 0x18 ]
201ebc0: c0 22 20 1c clr [ %o0 + 0x1c ]
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
201ebc4: c0 22 20 08 clr [ %o0 + 8 ]
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 ));
201ebc8: 84 04 20 78 add %l0, 0x78, %g2
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
201ebcc: 80 a7 40 02 cmp %i5, %g2
201ebd0: 12 80 00 06 bne 201ebe8 <rtems_rfs_file_open+0x7c>
201ebd4: c0 22 20 0c clr [ %o0 + 0xc ]
201ebd8: 30 80 00 1b b,a 201ec44 <rtems_rfs_file_open+0xd8>
201ebdc: 80 a7 40 02 cmp %i5, %g2
201ebe0: 02 80 00 19 be 201ec44 <rtems_rfs_file_open+0xd8> <== ALWAYS TAKEN
201ebe4: 01 00 00 00 nop
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
201ebe8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
201ebec: 80 a6 40 01 cmp %i1, %g1
201ebf0: 32 bf ff fb bne,a 201ebdc <rtems_rfs_file_open+0x70> <== ALWAYS TAKEN
201ebf4: fa 07 40 00 ld [ %i5 ], %i5
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
201ebf8: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201ebfc: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
201ec00: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201ec04: 92 10 20 00 clr %o1 <== NOT EXECUTED
201ec08: 7f ff d7 8b call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201ec0c: c2 27 60 08 st %g1, [ %i5 + 8 ] <== NOT EXECUTED
201ec10: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ec14: 12 80 00 34 bne 201ece4 <rtems_rfs_file_open+0x178> <== NOT EXECUTED
201ec18: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = oflag;
201ec1c: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
handle->shared = shared;
201ec20: fa 27 20 1c st %i5, [ %i4 + 0x1c ]
*file = handle;
201ec24: f8 26 c0 00 st %i4, [ %i3 ]
return 0;
201ec28: 81 c7 e0 08 ret
201ec2c: 91 e8 20 00 restore %g0, 0, %o0
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
201ec30: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201ec34: 40 00 17 1e call 20248ac <printf> <== NOT EXECUTED
201ec38: 90 12 22 58 or %o0, 0x258, %o0 ! 2036a58 <CSWTCH.2+0xd44> <== NOT EXECUTED
*file = NULL;
201ec3c: 10 bf ff d5 b 201eb90 <rtems_rfs_file_open+0x24> <== NOT EXECUTED
201ec40: c0 26 c0 00 clr [ %i3 ] <== 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));
201ec44: 7f ff a8 8d call 2008e78 <malloc>
201ec48: 90 10 20 9c mov 0x9c, %o0
if (!shared)
201ec4c: ba 92 20 00 orcc %o0, 0, %i5
201ec50: 02 80 00 46 be 201ed68 <rtems_rfs_file_open+0x1fc> <== NEVER TAKEN
201ec54: 92 10 20 00 clr %o1
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
201ec58: 40 00 16 97 call 20246b4 <memset>
201ec5c: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
201ec60: a2 07 60 0c add %i5, 0xc, %l1
201ec64: 90 10 00 10 mov %l0, %o0
201ec68: 92 10 00 19 mov %i1, %o1
201ec6c: 94 10 00 11 mov %l1, %o2
201ec70: 7f ff d0 ca call 2012f98 <rtems_rfs_inode_open>
201ec74: 96 10 20 01 mov 1, %o3
if (rc > 0)
201ec78: b0 92 20 00 orcc %o0, 0, %i0
201ec7c: 04 80 00 23 ble 201ed08 <rtems_rfs_file_open+0x19c> <== ALWAYS TAKEN
201ec80: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201ec84: 7f ff d7 6c call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201ec88: 92 10 20 00 clr %o1 <== NOT EXECUTED
201ec8c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ec90: 02 80 00 09 be 201ecb4 <rtems_rfs_file_open+0x148> <== NOT EXECUTED
201ec94: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
201ec98: 40 00 1b 4f call 20259d4 <strerror> <== NOT EXECUTED
201ec9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201eca0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201eca4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201eca8: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201ecac: 40 00 17 00 call 20248ac <printf> <== NOT EXECUTED
201ecb0: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 2036aa0 <CSWTCH.2+0xd8c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
free (shared);
201ecb4: 7f ff a6 d4 call 2008804 <free> <== NOT EXECUTED
201ecb8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
201ecbc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201ecc0: 7f ff f8 41 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201ecc4: 92 07 20 04 add %i4, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
201ecc8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
handle->dirty = false;
201eccc: c0 2f 20 04 clrb [ %i4 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
201ecd0: c0 27 20 08 clr [ %i4 + 8 ] <== NOT EXECUTED
201ecd4: 7f ff a6 cc call 2008804 <free> <== NOT EXECUTED
201ecd8: c0 27 20 0c clr [ %i4 + 0xc ] <== NOT EXECUTED
return rc;
201ecdc: 81 c7 e0 08 ret <== NOT EXECUTED
201ece0: 81 e8 00 00 restore <== NOT EXECUTED
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
201ece4: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
handle->flags = oflag;
handle->shared = shared;
*file = handle;
return 0;
201ece8: b0 10 20 00 clr %i0 <== NOT EXECUTED
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
201ecec: 40 00 16 f0 call 20248ac <printf> <== NOT EXECUTED
201ecf0: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = oflag;
201ecf4: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
handle->shared = shared;
201ecf8: fa 27 20 1c st %i5, [ %i4 + 0x1c ] <== NOT EXECUTED
*file = handle;
201ecfc: f8 26 c0 00 st %i4, [ %i3 ] <== NOT EXECUTED
return 0;
201ed00: 81 c7 e0 08 ret <== NOT EXECUTED
201ed04: 81 e8 00 00 restore <== 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);
201ed08: 90 10 00 10 mov %l0, %o0
201ed0c: 92 10 00 11 mov %l1, %o1
201ed10: 7f ff f4 a3 call 201bf9c <rtems_rfs_block_map_open>
201ed14: 94 07 60 34 add %i5, 0x34, %o2
if (rc > 0)
201ed18: b0 92 20 00 orcc %o0, 0, %i0
201ed1c: 24 80 00 1e ble,a 201ed94 <rtems_rfs_file_open+0x228> <== ALWAYS TAKEN
201ed20: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201ed24: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
201ed28: 7f ff d7 43 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201ed2c: 92 10 20 00 clr %o1 <== NOT EXECUTED
201ed30: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ed34: 22 80 00 0a be,a 201ed5c <rtems_rfs_file_open+0x1f0> <== NOT EXECUTED
201ed38: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
201ed3c: 40 00 1b 26 call 20259d4 <strerror> <== NOT EXECUTED
201ed40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201ed44: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201ed48: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ed4c: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201ed50: 40 00 16 d7 call 20248ac <printf> <== NOT EXECUTED
201ed54: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 2036ad8 <CSWTCH.2+0xdc4> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
201ed58: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
201ed5c: 7f ff d1 07 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
201ed60: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201ed64: 30 bf ff d4 b,a 201ecb4 <rtems_rfs_file_open+0x148> <== 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);
201ed68: 92 07 20 04 add %i4, 4, %o1 <== NOT EXECUTED
201ed6c: 7f ff f8 16 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201ed70: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
if (!shared)
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
201ed74: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
if (!shared)
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
201ed78: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
handle->dirty = false;
201ed7c: c0 2f 20 04 clrb [ %i4 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
201ed80: c0 27 20 08 clr [ %i4 + 8 ] <== NOT EXECUTED
201ed84: 7f ff a6 a0 call 2008804 <free> <== NOT EXECUTED
201ed88: c0 27 20 0c clr [ %i4 + 0xc ] <== NOT EXECUTED
return ENOMEM;
201ed8c: 81 c7 e0 08 ret <== NOT EXECUTED
201ed90: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
201ed94: 84 10 20 01 mov 1, %g2
201ed98: c4 27 60 08 st %g2, [ %i5 + 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);
201ed9c: f0 08 60 0c ldub [ %g1 + 0xc ], %i0
201eda0: c8 08 60 0d ldub [ %g1 + 0xd ], %g4
201eda4: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
201eda8: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
201edac: b1 2e 20 18 sll %i0, 0x18, %i0
201edb0: 89 29 20 10 sll %g4, 0x10, %g4
201edb4: 85 28 a0 08 sll %g2, 8, %g2
201edb8: 88 16 00 04 or %i0, %g4, %g4
201edbc: 86 11 00 03 or %g4, %g3, %g3
201edc0: 84 10 c0 02 or %g3, %g2, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
201edc4: c4 27 60 84 st %g2, [ %i5 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
201edc8: 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);
201edcc: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
201edd0: 90 04 20 74 add %l0, 0x74, %o0
201edd4: 85 28 a0 08 sll %g2, 8, %g2
201edd8: 84 10 c0 02 or %g3, %g2, %g2
201eddc: c4 27 60 88 st %g2, [ %i5 + 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);
201ede0: f0 08 60 10 ldub [ %g1 + 0x10 ], %i0
201ede4: c8 08 60 11 ldub [ %g1 + 0x11 ], %g4
201ede8: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
201edec: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
201edf0: b1 2e 20 18 sll %i0, 0x18, %i0
201edf4: 89 29 20 10 sll %g4, 0x10, %g4
201edf8: 85 28 a0 08 sll %g2, 8, %g2
201edfc: 88 16 00 04 or %i0, %g4, %g4
201ee00: 86 11 00 03 or %g4, %g3, %g3
201ee04: 84 10 c0 02 or %g3, %g2, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
201ee08: c4 27 60 8c st %g2, [ %i5 + 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);
201ee0c: f0 08 60 14 ldub [ %g1 + 0x14 ], %i0
201ee10: c8 08 60 15 ldub [ %g1 + 0x15 ], %g4
201ee14: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
201ee18: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
201ee1c: b1 2e 20 18 sll %i0, 0x18, %i0
201ee20: 89 29 20 10 sll %g4, 0x10, %g4
201ee24: 85 28 a0 08 sll %g2, 8, %g2
201ee28: 88 16 00 04 or %i0, %g4, %g4
201ee2c: 86 11 00 03 or %g4, %g3, %g3
201ee30: 84 10 c0 02 or %g3, %g2, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
201ee34: c4 27 60 90 st %g2, [ %i5 + 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);
201ee38: c8 08 60 18 ldub [ %g1 + 0x18 ], %g4
201ee3c: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
201ee40: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
201ee44: c2 08 60 1a ldub [ %g1 + 0x1a ], %g1
201ee48: 89 29 20 18 sll %g4, 0x18, %g4
201ee4c: 87 28 e0 10 sll %g3, 0x10, %g3
201ee50: 83 28 60 08 sll %g1, 8, %g1
201ee54: 86 11 00 03 or %g4, %g3, %g3
201ee58: 84 10 c0 02 or %g3, %g2, %g2
201ee5c: 82 10 80 01 or %g2, %g1, %g1
201ee60: 92 10 00 1d mov %i5, %o1
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
201ee64: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
201ee68: 7f ff bc e4 call 200e1f8 <_Chain_Append>
201ee6c: e0 27 60 98 st %l0, [ %i5 + 0x98 ]
shared->fs = fs;
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
201ee70: 92 10 00 11 mov %l1, %o1
201ee74: 94 10 20 00 clr %o2
201ee78: 7f ff d0 7f call 2013074 <rtems_rfs_inode_unload>
201ee7c: 90 10 00 10 mov %l0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201ee80: 90 10 20 08 mov 8, %o0
201ee84: 7f ff d6 ec call 2014a34 <rtems_rfs_trace>
201ee88: 92 10 20 00 clr %o1
201ee8c: 80 8a 20 ff btst 0xff, %o0
201ee90: 22 bf ff 64 be,a 201ec20 <rtems_rfs_file_open+0xb4> <== ALWAYS TAKEN
201ee94: f4 27 00 00 st %i2, [ %i4 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
201ee98: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201ee9c: 11 00 80 da sethi %hi(0x2036800), %o0 <== NOT EXECUTED
201eea0: 40 00 16 83 call 20248ac <printf> <== NOT EXECUTED
201eea4: 90 12 23 10 or %o0, 0x310, %o0 ! 2036b10 <CSWTCH.2+0xdfc> <== NOT EXECUTED
}
handle->flags = oflag;
201eea8: 10 bf ff 5e b 201ec20 <rtems_rfs_file_open+0xb4> <== NOT EXECUTED
201eeac: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
0201f6e4 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
201f6e4: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f6e8: 90 10 20 20 mov 0x20, %o0
201f6ec: 92 10 20 00 clr %o1
201f6f0: 7f ff d4 d1 call 2014a34 <rtems_rfs_trace>
201f6f4: ba 10 00 18 mov %i0, %i5
201f6f8: 80 8a 20 ff btst 0xff, %o0
201f6fc: 32 80 00 2b bne,a 201f7a8 <rtems_rfs_file_seek+0xc4> <== NEVER TAKEN
201f700: 92 10 00 19 mov %i1, %o1 <== 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),
201f704: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
201f708: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f70c: 7f ff f2 0e call 201bf44 <rtems_rfs_block_get_size>
201f710: 92 02 60 84 add %o1, 0x84, %o1
201f714: 80 a6 40 08 cmp %i1, %o0
201f718: 18 80 00 1b bgu 201f784 <rtems_rfs_file_seek+0xa0> <== NEVER TAKEN
201f71c: 01 00 00 00 nop
201f720: 02 80 00 17 be 201f77c <rtems_rfs_file_seek+0x98> <== ALWAYS TAKEN
201f724: 80 a6 80 09 cmp %i2, %o1
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
201f728: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
201f72c: b8 07 60 10 add %i5, 0x10, %i4
201f730: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f734: 92 10 00 19 mov %i1, %o1
201f738: 94 10 00 1a mov %i2, %o2
201f73c: 7f ff f1 d3 call 201be88 <rtems_rfs_block_get_bpos>
201f740: 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))
201f744: c2 07 60 0c ld [ %i5 + 0xc ], %g1
201f748: 80 a0 60 00 cmp %g1, 0
201f74c: 02 80 00 13 be 201f798 <rtems_rfs_file_seek+0xb4>
201f750: 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),
201f754: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
201f758: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f75c: 96 07 bf fc add %fp, -4, %o3
201f760: 7f ff f2 e4 call 201c2f0 <rtems_rfs_block_map_find>
201f764: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
201f768: b0 92 20 00 orcc %o0, 0, %i0
201f76c: 24 80 00 15 ble,a 201f7c0 <rtems_rfs_file_seek+0xdc> <== ALWAYS TAKEN
201f770: c4 07 60 08 ld [ %i5 + 8 ], %g2
return rc;
}
*new_pos = pos;
return 0;
}
201f774: 81 c7 e0 08 ret <== NOT EXECUTED
201f778: 81 e8 00 00 restore <== 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),
201f77c: 28 bf ff ec bleu,a 201f72c <rtems_rfs_file_seek+0x48>
201f780: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
{
/*
* 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);
201f784: 7f ff ff cd call 201f6b8 <rtems_rfs_file_io_release>
201f788: 90 10 00 1d mov %i5, %o0
if (rc > 0)
201f78c: b0 92 20 00 orcc %o0, 0, %i0
201f790: 14 80 00 16 bg 201f7e8 <rtems_rfs_file_seek+0x104> <== NEVER TAKEN
201f794: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
201f798: f2 26 c0 00 st %i1, [ %i3 ]
201f79c: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
}
201f7a0: 81 c7 e0 08 ret
201f7a4: 91 e8 20 00 restore %g0, 0, %o0
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
201f7a8: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201f7ac: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201f7b0: 40 00 14 3f call 20248ac <printf> <== NOT EXECUTED
201f7b4: 90 12 21 78 or %o0, 0x178, %o0 <== 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),
201f7b8: 10 bf ff d4 b 201f708 <rtems_rfs_file_seek+0x24> <== NOT EXECUTED
201f7bc: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
201f7c0: c2 07 bf fc ld [ %fp + -4 ], %g1
201f7c4: 80 a0 80 01 cmp %g2, %g1
201f7c8: 02 bf ff f4 be 201f798 <rtems_rfs_file_seek+0xb4> <== ALWAYS TAKEN
201f7cc: 92 07 60 04 add %i5, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201f7d0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
201f7d4: 7f ff f5 7c call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201f7d8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
201f7dc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201f7e0: 24 bf ff ef ble,a 201f79c <rtems_rfs_file_seek+0xb8> <== NOT EXECUTED
201f7e4: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED
return rc;
}
*new_pos = pos;
return 0;
}
201f7e8: 81 c7 e0 08 ret <== NOT EXECUTED
201f7ec: 81 e8 00 00 restore <== NOT EXECUTED
0201f7f0 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
201f7f0: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
201f7f4: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201f7f8: 90 10 20 20 mov 0x20, %o0
201f7fc: 92 10 20 00 clr %o1
201f800: 7f ff d4 8d call 2014a34 <rtems_rfs_trace>
201f804: b8 10 00 19 mov %i1, %i4
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
201f808: 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))
201f80c: 80 8a 20 ff btst 0xff, %o0
201f810: 12 80 00 92 bne 201fa58 <rtems_rfs_file_set_size+0x268> <== NEVER TAKEN
201f814: b2 06 e0 34 add %i3, 0x34, %i1
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
size = rtems_rfs_file_size (handle);
201f818: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
201f81c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f820: 7f ff f1 c9 call 201bf44 <rtems_rfs_block_get_size>
201f824: 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)
201f828: 80 a7 00 08 cmp %i4, %o0
201f82c: 02 80 00 98 be 201fa8c <rtems_rfs_file_set_size+0x29c> <== ALWAYS TAKEN
201f830: 80 a7 40 09 cmp %i5, %o1
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
201f834: 80 97 00 1d orcc %i4, %i5, %g0 <== NOT EXECUTED
201f838: 22 80 00 9a be,a 201faa0 <rtems_rfs_file_set_size+0x2b0> <== NOT EXECUTED
201f83c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
201f840: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
201f844: 08 80 00 57 bleu 201f9a0 <rtems_rfs_file_set_size+0x1b0> <== ALWAYS TAKEN
201f848: 01 00 00 00 nop
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));
201f84c: e8 06 20 1c ld [ %i0 + 0x1c ], %l4 <== NOT EXECUTED
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
201f850: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201f854: c2 05 20 98 ld [ %l4 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
201f858: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201f85c: a6 10 00 14 mov %l4, %l3
201f860: f4 00 60 08 ld [ %g1 + 8 ], %i2
read_block = false;
while (count)
201f864: a4 10 20 00 clr %l2
201f868: a2 10 20 01 mov 1, %l1
201f86c: 80 97 00 1d orcc %i4, %i5, %g0
201f870: 12 80 00 2a bne 201f918 <rtems_rfs_file_set_size+0x128> <== ALWAYS TAKEN
201f874: a0 06 20 04 add %i0, 4, %l0
201f878: 10 80 00 92 b 201fac0 <rtems_rfs_file_set_size+0x2d0> <== NOT EXECUTED
201f87c: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2 <== NOT EXECUTED
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
201f880: 80 a0 80 1d cmp %g2, %i5
201f884: 28 80 00 45 bleu,a 201f998 <rtems_rfs_file_set_size+0x1a8>
201f888: c0 26 e0 40 clr [ %i3 + 0x40 ]
{
length = count + bpos.boff;
201f88c: b4 00 40 1d add %g1, %i5, %i2
201f890: e2 2e e0 34 stb %l1, [ %i3 + 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;
201f894: f4 26 e0 40 st %i2, [ %i3 + 0x40 ]
read_block = true;
201f898: a4 10 20 01 mov 1, %l2
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
201f89c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201f8a0: d4 07 bf f0 ld [ %fp + -16 ], %o2
201f8a4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f8a8: 92 10 00 10 mov %l0, %o1
201f8ac: 7f ff f5 c0 call 201cfac <rtems_rfs_buffer_handle_request>
201f8b0: 96 0c a0 01 and %l2, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
201f8b4: 82 92 20 00 orcc %o0, 0, %g1
201f8b8: 14 80 00 66 bg 201fa50 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
201f8bc: 92 10 20 00 clr %o1
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
201f8c0: c4 06 20 0c ld [ %i0 + 0xc ], %g2
memset (dst + bpos.boff, 0, length - bpos.boff);
201f8c4: c2 07 bf f8 ld [ %fp + -8 ], %g1
201f8c8: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
201f8cc: 94 26 80 01 sub %i2, %g1, %o2
201f8d0: 40 00 13 79 call 20246b4 <memset>
201f8d4: 90 02 00 01 add %o0, %g1, %o0
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201f8d8: c2 06 20 1c ld [ %i0 + 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));
201f8dc: e2 2e 20 04 stb %l1, [ %i0 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201f8e0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f8e4: 7f ff f5 38 call 201cdc4 <rtems_rfs_buffer_handle_release>
201f8e8: 92 10 00 10 mov %l0, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
201f8ec: 82 92 20 00 orcc %o0, 0, %g1
201f8f0: 14 80 00 58 bg 201fa50 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
201f8f4: 01 00 00 00 nop
return rc;
count -= length - bpos.boff;
201f8f8: c2 07 bf f8 ld [ %fp + -8 ], %g1
201f8fc: 82 26 80 01 sub %i2, %g1, %g1
201f900: ba a7 40 01 subcc %i5, %g1, %i5
201f904: 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)
201f908: 80 97 00 1d orcc %i4, %i5, %g0
201f90c: 22 80 00 6c be,a 201fabc <rtems_rfs_file_set_size+0x2cc>
201f910: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
201f914: e6 06 20 1c ld [ %i0 + 0x1c ], %l3
/*
* 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);
201f918: c2 06 e0 40 ld [ %i3 + 0x40 ], %g1
201f91c: c4 06 e0 3c ld [ %i3 + 0x3c ], %g2
201f920: c2 27 bf f8 st %g1, [ %fp + -8 ]
201f924: c4 27 bf f4 st %g2, [ %fp + -12 ]
201f928: 80 a0 60 00 cmp %g1, 0
201f92c: 02 80 00 04 be 201f93c <rtems_rfs_file_set_size+0x14c>
201f930: c0 27 bf fc clr [ %fp + -4 ]
201f934: 84 00 bf ff add %g2, -1, %g2
201f938: c4 27 bf f4 st %g2, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
201f93c: d0 04 e0 98 ld [ %l3 + 0x98 ], %o0
201f940: 92 10 00 19 mov %i1, %o1
201f944: 94 07 bf f4 add %fp, -12, %o2
201f948: 7f ff f2 6a call 201c2f0 <rtems_rfs_block_map_find>
201f94c: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
201f950: 82 92 20 00 orcc %o0, 0, %g1
201f954: 04 80 00 0c ble 201f984 <rtems_rfs_file_set_size+0x194>
201f958: 80 a0 60 06 cmp %g1, 6
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
201f95c: 12 80 00 3d bne 201fa50 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
201f960: 92 10 00 19 mov %i1, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
201f964: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201f968: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f96c: 94 10 20 01 mov 1, %o2
201f970: 7f ff f2 e4 call 201c500 <rtems_rfs_block_map_grow>
201f974: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
201f978: 82 92 20 00 orcc %o0, 0, %g1
201f97c: 14 80 00 35 bg 201fa50 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
201f980: 01 00 00 00 nop
return rc;
}
if (count < (length - bpos.boff))
201f984: c2 07 bf f8 ld [ %fp + -8 ], %g1
201f988: 80 a7 20 00 cmp %i4, 0
201f98c: 02 bf ff bd be 201f880 <rtems_rfs_file_set_size+0x90> <== ALWAYS TAKEN
201f990: 84 26 80 01 sub %i2, %g1, %g2
201f994: c0 26 e0 40 clr [ %i3 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
201f998: 10 bf ff c1 b 201f89c <rtems_rfs_file_set_size+0xac>
201f99c: e2 2e e0 34 stb %l1, [ %i3 + 0x34 ]
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
201f9a0: 02 80 00 54 be 201faf0 <rtems_rfs_file_set_size+0x300> <== ALWAYS TAKEN
201f9a4: 80 a7 40 09 cmp %i5, %o1
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
201f9a8: e6 06 20 1c ld [ %i0 + 0x1c ], %l3 <== NOT EXECUTED
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
201f9ac: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
201f9b0: e0 04 e0 98 ld [ %l3 + 0x98 ], %l0
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
201f9b4: 92 87 7f ff addcc %i5, -1, %o1
201f9b8: f2 04 20 08 ld [ %l0 + 8 ], %i1
201f9bc: 90 47 3f ff addx %i4, -1, %o0
201f9c0: 96 10 00 19 mov %i1, %o3
201f9c4: 40 00 46 d6 call 203151c <__udivdi3>
201f9c8: 94 10 20 00 clr %o2
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
201f9cc: 92 38 00 09 xnor %g0, %o1, %o1
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201f9d0: 96 10 00 19 mov %i1, %o3
201f9d4: 94 10 20 00 clr %o2
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
201f9d8: b2 02 40 1a add %o1, %i2, %i1
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));
201f9dc: 90 10 00 1c mov %i4, %o0
201f9e0: 40 00 47 a3 call 203186c <__umoddi3>
201f9e4: 92 10 00 1d mov %i5, %o1
if (blocks)
201f9e8: 80 a6 60 00 cmp %i1, 0
201f9ec: 12 80 00 4e bne 201fb24 <rtems_rfs_file_set_size+0x334>
201f9f0: ba 10 00 09 mov %o1, %i5
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
201f9f4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201f9f8: 84 10 20 01 mov 1, %g2
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
201f9fc: fa 26 e0 40 st %i5, [ %i3 + 0x40 ]
201fa00: 80 a0 60 00 cmp %g1, 0
201fa04: 02 80 00 3f be 201fb00 <rtems_rfs_file_set_size+0x310>
201fa08: c4 2e e0 34 stb %g2, [ %i3 + 0x34 ]
201fa0c: 80 a6 a0 00 cmp %i2, 0
201fa10: 12 80 00 3d bne 201fb04 <rtems_rfs_file_set_size+0x314> <== ALWAYS TAKEN
201fa14: 80 a0 40 1a cmp %g1, %i2
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
201fa18: f4 26 20 10 st %i2, [ %i0 + 0x10 ] <== NOT EXECUTED
201fa1c: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
201fa20: 80 a7 60 00 cmp %i5, 0
201fa24: 02 80 00 3e be 201fb1c <rtems_rfs_file_set_size+0x32c> <== NEVER TAKEN
201fa28: c0 26 20 18 clr [ %i0 + 0x18 ]
201fa2c: 82 06 bf ff add %i2, -1, %g1
201fa30: a8 10 00 13 mov %l3, %l4
201fa34: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
201fa38: c2 06 00 00 ld [ %i0 ], %g1
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);
201fa3c: f4 25 20 84 st %i2, [ %l4 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
201fa40: 80 88 60 02 btst 2, %g1
201fa44: 02 80 00 25 be 201fad8 <rtems_rfs_file_set_size+0x2e8> <== ALWAYS TAKEN
201fa48: fa 25 20 88 st %i5, [ %l4 + 0x88 ]
handle->shared->mtime = time (NULL);
}
return 0;
201fa4c: 82 10 20 00 clr %g1
}
201fa50: 81 c7 e0 08 ret
201fa54: 91 e8 00 01 restore %g0, %g1, %o0
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
201fa58: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201fa5c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201fa60: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201fa64: 40 00 13 92 call 20248ac <printf> <== NOT EXECUTED
201fa68: 90 12 21 98 or %o0, 0x198, %o0 ! 2036d98 <CSWTCH.2+0x1084><== NOT EXECUTED
size = rtems_rfs_file_size (handle);
201fa6c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
201fa70: d0 02 60 98 ld [ %o1 + 0x98 ], %o0 <== NOT EXECUTED
201fa74: 7f ff f1 34 call 201bf44 <rtems_rfs_block_get_size> <== NOT EXECUTED
201fa78: 92 02 60 84 add %o1, 0x84, %o1 <== NOT EXECUTED
/*
* 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)
201fa7c: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
201fa80: 12 bf ff 6e bne 201f838 <rtems_rfs_file_set_size+0x48> <== NOT EXECUTED
201fa84: 80 97 00 1d orcc %i4, %i5, %g0 <== NOT EXECUTED
201fa88: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED
201fa8c: 02 bf ff f0 be 201fa4c <rtems_rfs_file_set_size+0x25c>
201fa90: 80 97 00 1d orcc %i4, %i5, %g0
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
201fa94: 12 bf ff 6c bne 201f844 <rtems_rfs_file_set_size+0x54>
201fa98: 80 a7 00 08 cmp %i4, %o0
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
201fa9c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201faa0: 92 10 00 19 mov %i1, %o1
201faa4: 7f ff f4 55 call 201cbf8 <rtems_rfs_block_map_free_all>
201faa8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
if (rc > 0)
201faac: 82 92 20 00 orcc %o0, 0, %g1
201fab0: 14 bf ff e8 bg 201fa50 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
201fab4: 01 00 00 00 nop
201fab8: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
201fabc: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
201fac0: fa 06 e0 40 ld [ %i3 + 0x40 ], %i5
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
201fac4: c2 06 00 00 ld [ %i0 ], %g1
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);
201fac8: f4 25 20 84 st %i2, [ %l4 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
201facc: 80 88 60 02 btst 2, %g1
201fad0: 12 bf ff df bne 201fa4c <rtems_rfs_file_set_size+0x25c> <== NEVER TAKEN
201fad4: fa 25 20 88 st %i5, [ %l4 + 0x88 ]
handle->shared->mtime = time (NULL);
201fad8: 40 00 23 6f call 2028894 <time>
201fadc: 90 10 20 00 clr %o0
}
return 0;
201fae0: 82 10 20 00 clr %g1
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
201fae4: d0 25 20 90 st %o0, [ %l4 + 0x90 ]
}
return 0;
}
201fae8: 81 c7 e0 08 ret
201faec: 91 e8 00 01 restore %g0, %g1, %o0
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
201faf0: 28 bf ff af bleu,a 201f9ac <rtems_rfs_file_set_size+0x1bc>
201faf4: e6 06 20 1c ld [ %i0 + 0x1c ], %l3
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));
201faf8: 10 bf ff 56 b 201f850 <rtems_rfs_file_set_size+0x60>
201fafc: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
201fb00: 80 a0 40 1a cmp %g1, %i2
201fb04: 3a bf ff c6 bcc,a 201fa1c <rtems_rfs_file_set_size+0x22c><== NEVER TAKEN
201fb08: f4 26 20 10 st %i2, [ %i0 + 0x10 ] <== NOT EXECUTED
201fb0c: 84 06 bf ff add %i2, -1, %g2
201fb10: 80 a0 40 02 cmp %g1, %g2
201fb14: 22 80 00 0e be,a 201fb4c <rtems_rfs_file_set_size+0x35c> <== ALWAYS TAKEN
201fb18: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
201fb1c: 10 bf ff c7 b 201fa38 <rtems_rfs_file_set_size+0x248> <== NOT EXECUTED
201fb20: a8 10 00 13 mov %l3, %l4 <== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
201fb24: 90 10 00 10 mov %l0, %o0
201fb28: 92 04 e0 34 add %l3, 0x34, %o1
201fb2c: 7f ff f3 6b call 201c8d8 <rtems_rfs_block_map_shrink>
201fb30: 94 10 00 19 mov %i1, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
201fb34: 82 92 20 00 orcc %o0, 0, %g1
201fb38: 14 bf ff c6 bg 201fa50 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
201fb3c: 01 00 00 00 nop
201fb40: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
201fb44: 10 bf ff ac b 201f9f4 <rtems_rfs_file_set_size+0x204>
201fb48: e6 06 20 1c ld [ %i0 + 0x1c ], %l3
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
201fb4c: 80 a7 40 01 cmp %i5, %g1
201fb50: 2a bf ff b3 bcs,a 201fa1c <rtems_rfs_file_set_size+0x22c>
201fb54: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
201fb58: 10 bf ff b8 b 201fa38 <rtems_rfs_file_set_size+0x248>
201fb5c: a8 10 00 13 mov %l3, %l4
02011808 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
2011808: 9d e3 be c8 save %sp, -312, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
201180c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
2011810: 80 a0 60 00 cmp %g1, 0
2011814: 32 80 00 88 bne,a 2011a34 <rtems_rfs_format+0x22c> <== NEVER TAKEN
2011818: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
201181c: 92 10 20 00 clr %o1
2011820: 94 10 20 84 mov 0x84, %o2
2011824: 40 00 4b a4 call 20246b4 <memset>
2011828: 90 07 bf 7c add %fp, -132, %o0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201182c: 82 07 bf c4 add %fp, -60, %g1
2011830: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
2011834: 82 07 bf c0 add %fp, -64, %g1
2011838: c2 27 bf c8 st %g1, [ %fp + -56 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201183c: 82 07 bf d4 add %fp, -44, %g1
2011840: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
2011844: 82 07 bf d0 add %fp, -48, %g1
2011848: c2 27 bf d8 st %g1, [ %fp + -40 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201184c: 82 07 bf e4 add %fp, -28, %g1
2011850: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
2011854: 82 07 bf e0 add %fp, -32, %g1
2011858: c2 27 bf e8 st %g1, [ %fp + -24 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201185c: 82 07 bf f4 add %fp, -12, %g1
2011860: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
2011864: 82 07 bf f0 add %fp, -16, %g1
2011868: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
201186c: 82 10 20 05 mov 5, %g1
2011870: c2 27 bf bc st %g1, [ %fp + -68 ]
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
2011874: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
2011878: 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;
201187c: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
2011880: 40 00 2e 83 call 201d28c <rtems_rfs_buffer_open>
2011884: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
2011888: ba 92 20 00 orcc %o0, 0, %i5
201188c: 14 80 02 bd bg 2012380 <rtems_rfs_format+0xb78> <== NEVER TAKEN
2011890: c2 07 bf 8c ld [ %fp + -116 ], %g1
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
2011894: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
2011898: 80 a7 20 00 cmp %i4, 0
201189c: 02 80 02 c2 be 20123a4 <rtems_rfs_format+0xb9c> <== NEVER TAKEN
20118a0: 92 10 20 00 clr %o1
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
20118a4: fa 06 40 00 ld [ %i1 ], %i5
if (!fs->block_size)
20118a8: 80 a7 60 00 cmp %i5, 0
20118ac: 02 80 00 d1 be 2011bf0 <rtems_rfs_format+0x3e8>
20118b0: fa 27 bf 84 st %i5, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
20118b4: 90 10 00 1d mov %i5, %o0
20118b8: 40 00 7c 5c call 2030a28 <.urem>
20118bc: 92 10 00 1c mov %i4, %o1
20118c0: 80 a2 20 00 cmp %o0, 0
20118c4: 32 80 00 ef bne,a 2011c80 <rtems_rfs_format+0x478> <== NEVER TAKEN
20118c8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
20118cc: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
/*
* 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);
20118d0: 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)
20118d4: 80 a0 60 00 cmp %g1, 0
20118d8: 12 80 00 50 bne 2011a18 <rtems_rfs_format+0x210> <== NEVER TAKEN
20118dc: c2 27 bf a4 st %g1, [ %fp + -92 ]
{
/*
* 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);
20118e0: fa 27 bf a4 st %i5, [ %fp + -92 ]
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
20118e4: 40 00 38 ba call 201fbcc <rtems_rfs_fs_media_size>
20118e8: 90 07 bf 7c add %fp, -132, %o0
20118ec: fa 07 bf 84 ld [ %fp + -124 ], %i5
20118f0: 94 10 20 00 clr %o2
20118f4: 40 00 7f 0a call 203151c <__udivdi3>
20118f8: 96 10 00 1d mov %i5, %o3
20118fc: d2 27 bf 80 st %o1, [ %fp + -128 ]
2011900: b8 10 00 09 mov %o1, %i4
* 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));
2011904: b5 2f 60 03 sll %i5, 3, %i2
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
2011908: 80 a2 60 00 cmp %o1, 0
201190c: 02 80 00 06 be 2011924 <rtems_rfs_format+0x11c> <== NEVER TAKEN
2011910: a0 10 20 01 mov 1, %l0
return 1;
return ((dividend - 1) / divisor) + 1;
2011914: 90 02 7f ff add %o1, -1, %o0
2011918: 7f ff c3 5f call 2002694 <.udiv>
201191c: 92 10 00 1a mov %i2, %o1
2011920: a0 02 20 01 add %o0, 1, %l0
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
2011924: f6 06 60 08 ld [ %i1 + 8 ], %i3
if (!fs->group_inodes)
2011928: 80 a6 e0 00 cmp %i3, 0
201192c: 02 80 01 38 be 2011e0c <rtems_rfs_format+0x604> <== ALWAYS TAKEN
2011930: e0 27 bf a0 st %l0, [ %fp + -96 ]
2011934: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2011938: 7f ff c3 57 call 2002694 <.udiv> <== NOT EXECUTED
201193c: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
2011940: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
2011944: d0 27 bf ac st %o0, [ %fp + -84 ] <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
2011948: 90 06 ff ff add %i3, -1, %o0 <== NOT EXECUTED
201194c: 7f ff c3 52 call 2002694 <.udiv>
2011950: 92 10 00 1c mov %i4, %o1
2011954: 90 02 20 01 inc %o0
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
2011958: 7f ff c3 15 call 20025ac <.umul>
201195c: 92 10 00 1c mov %i4, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
2011960: 80 a6 80 08 cmp %i2, %o0
2011964: 0a 80 01 25 bcs 2011df8 <rtems_rfs_format+0x5f0> <== NEVER TAKEN
2011968: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
if (!fs->max_name_length)
201196c: 80 a0 60 00 cmp %g1, 0
2011970: 12 80 01 25 bne 2011e04 <rtems_rfs_format+0x5fc> <== NEVER TAKEN
2011974: d0 27 bf a8 st %o0, [ %fp + -88 ]
{
fs->max_name_length = 512;
2011978: 82 10 22 00 mov 0x200, %g1
201197c: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
2011980: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
2011984: 80 a0 60 00 cmp %g1, 0
2011988: 12 80 00 c5 bne 2011c9c <rtems_rfs_format+0x494> <== NEVER TAKEN
201198c: 01 00 00 00 nop
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
2011990: 92 10 00 1d mov %i5, %o1
2011994: 40 00 2e f1 call 201d558 <rtems_rfs_buffer_setblksize>
2011998: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
201199c: ba 92 20 00 orcc %o0, 0, %i5
20119a0: 14 80 02 33 bg 201226c <rtems_rfs_format+0xa64> <== NEVER TAKEN
20119a4: 92 07 bf 30 add %fp, -208, %o1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20119a8: c0 2f bf 30 clrb [ %fp + -208 ]
handle->bnum = 0;
20119ac: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
20119b0: c0 27 bf 38 clr [ %fp + -200 ]
printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
20119b4: 90 07 bf 7c add %fp, -132, %o0
20119b8: 94 10 20 00 clr %o2
20119bc: 40 00 2d 7c call 201cfac <rtems_rfs_buffer_handle_request>
20119c0: 96 10 20 00 clr %o3
if (rc > 0)
20119c4: ba 92 20 00 orcc %o0, 0, %i5
20119c8: 04 80 00 20 ble 2011a48 <rtems_rfs_format+0x240> <== ALWAYS TAKEN
20119cc: 92 07 bf 30 add %fp, -208, %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);
20119d0: 40 00 2c fd call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
20119d4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
20119d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
20119dc: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
20119e0: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
20119e4: 40 00 4f fc call 20259d4 <strerror> <== NOT EXECUTED
20119e8: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
20119ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20119f0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20119f4: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
20119f8: 40 00 4b ad call 20248ac <printf> <== NOT EXECUTED
20119fc: 90 12 20 00 mov %o0, %o0 ! 2034c00 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
2011a00: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
return -1;
2011a04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
2011a08: 40 00 4c 41 call 2024b0c <puts> <== NOT EXECUTED
2011a0c: 90 12 21 30 or %o0, 0x130, %o0 <== NOT EXECUTED
2011a10: 81 c7 e0 08 ret <== NOT EXECUTED
2011a14: 81 e8 00 00 restore <== NOT EXECUTED
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
2011a18: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
2011a1c: 08 bf ff b2 bleu 20118e4 <rtems_rfs_format+0xdc> <== NOT EXECUTED
2011a20: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
2011a24: 40 00 4c 3a call 2024b0c <puts> <== NOT EXECUTED
2011a28: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 20349b8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
2011a2c: 81 c7 e0 08 ret <== NOT EXECUTED
2011a30: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
printf ("rtems-rfs: format: %s\n", name);
2011a34: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011a38: 40 00 4b 9d call 20248ac <printf> <== NOT EXECUTED
2011a3c: 90 12 21 08 or %o0, 0x108, %o0 ! 2034908 <_CPU_Trap_slot_template+0x10><== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
2011a40: 10 bf ff 78 b 2011820 <rtems_rfs_format+0x18> <== NOT EXECUTED
2011a44: 92 10 20 00 clr %o1 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
2011a48: c2 07 bf 38 ld [ %fp + -200 ], %g1
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
2011a4c: d4 07 bf 84 ld [ %fp + -124 ], %o2
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
2011a50: 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));
2011a54: 92 10 20 ff mov 0xff, %o1
2011a58: 40 00 4b 17 call 20246b4 <memset>
2011a5c: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
2011a60: 82 10 20 28 mov 0x28, %g1
2011a64: c2 2f 40 00 stb %g1, [ %i5 ]
2011a68: 82 10 20 09 mov 9, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
2011a6c: 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);
2011a70: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
2011a74: c0 2f 60 05 clrb [ %i5 + 5 ]
2011a78: c0 2f 60 06 clrb [ %i5 + 6 ]
2011a7c: 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);
2011a80: 84 10 20 01 mov 1, %g2
2011a84: 82 10 20 20 mov 0x20, %g1
2011a88: c4 2f 60 03 stb %g2, [ %i5 + 3 ]
2011a8c: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
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));
2011a90: c6 0f bf 84 ldub [ %fp + -124 ], %g3
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));
2011a94: c2 07 bf 80 ld [ %fp + -128 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2011a98: c6 2f 60 08 stb %g3, [ %i5 + 8 ]
2011a9c: c6 17 bf 84 lduh [ %fp + -124 ], %g3
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));
2011aa0: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2011aa4: c6 2f 60 09 stb %g3, [ %i5 + 9 ]
2011aa8: c8 07 bf 84 ld [ %fp + -124 ], %g4
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));
2011aac: 87 30 60 18 srl %g1, 0x18, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2011ab0: 89 31 20 08 srl %g4, 8, %g4
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));
2011ab4: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2011ab8: c8 2f 60 0a stb %g4, [ %i5 + 0xa ]
2011abc: c6 07 bf 84 ld [ %fp + -124 ], %g3
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);
2011ac0: 90 07 bf 7c add %fp, -132, %o0
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2011ac4: c6 2f 60 0b stb %g3, [ %i5 + 0xb ]
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));
2011ac8: 87 30 60 10 srl %g1, 0x10, %g3
2011acc: 83 30 60 08 srl %g1, 8, %g1
2011ad0: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
2011ad4: c2 2f 60 0e stb %g1, [ %i5 + 0xe ]
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);
2011ad8: c2 0f bf 94 ldub [ %fp + -108 ], %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);
2011adc: 92 07 bf 30 add %fp, -208, %o1
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));
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
2011ae0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
2011ae4: c2 17 bf 94 lduh [ %fp + -108 ], %g1
2011ae8: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
2011aec: c2 07 bf 94 ld [ %fp + -108 ], %g1
2011af0: 83 30 60 08 srl %g1, 8, %g1
2011af4: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
2011af8: c2 07 bf 94 ld [ %fp + -108 ], %g1
2011afc: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
2011b00: c2 0f bf 98 ldub [ %fp + -104 ], %g1
2011b04: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
2011b08: c2 17 bf 98 lduh [ %fp + -104 ], %g1
2011b0c: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
2011b10: c2 07 bf 98 ld [ %fp + -104 ], %g1
2011b14: 83 30 60 08 srl %g1, 8, %g1
2011b18: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
2011b1c: c2 07 bf 98 ld [ %fp + -104 ], %g1
2011b20: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
2011b24: c2 0f bf a0 ldub [ %fp + -96 ], %g1
2011b28: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
2011b2c: c2 17 bf a0 lduh [ %fp + -96 ], %g1
2011b30: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
2011b34: c2 07 bf a0 ld [ %fp + -96 ], %g1
2011b38: 83 30 60 08 srl %g1, 8, %g1
2011b3c: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
2011b40: c2 07 bf a0 ld [ %fp + -96 ], %g1
2011b44: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
2011b48: c2 0f bf a4 ldub [ %fp + -92 ], %g1
2011b4c: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
2011b50: c2 17 bf a4 lduh [ %fp + -92 ], %g1
2011b54: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
2011b58: c2 07 bf a4 ld [ %fp + -92 ], %g1
2011b5c: 83 30 60 08 srl %g1, 8, %g1
2011b60: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
2011b64: c2 07 bf a4 ld [ %fp + -92 ], %g1
2011b68: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
2011b6c: c2 0f bf a8 ldub [ %fp + -88 ], %g1
2011b70: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
2011b74: c2 17 bf a8 lduh [ %fp + -88 ], %g1
2011b78: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
2011b7c: c2 07 bf a8 ld [ %fp + -88 ], %g1
2011b80: 83 30 60 08 srl %g1, 8, %g1
2011b84: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
2011b88: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
2011b8c: 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);
2011b90: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
2011b94: c0 2f 60 25 clrb [ %i5 + 0x25 ]
2011b98: c0 2f 60 26 clrb [ %i5 + 0x26 ]
2011b9c: 82 10 20 38 mov 0x38, %g1
2011ba0: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
2011ba4: 40 00 2c 88 call 201cdc4 <rtems_rfs_buffer_handle_release>
2011ba8: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
2011bac: ba 92 20 00 orcc %o0, 0, %i5
2011bb0: 04 80 00 e3 ble 2011f3c <rtems_rfs_format+0x734> <== ALWAYS TAKEN
2011bb4: 92 07 bf 30 add %fp, -208, %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);
2011bb8: 40 00 2c 83 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2011bbc: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
2011bc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
2011bc4: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2011bc8: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
2011bcc: 40 00 4f 82 call 20259d4 <strerror> <== NOT EXECUTED
2011bd0: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
2011bd4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011bd8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011bdc: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
2011be0: 40 00 4b 33 call 20248ac <printf> <== NOT EXECUTED
2011be4: 90 12 20 38 or %o0, 0x38, %o0 ! 2034c38 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
2011be8: 10 bf ff 87 b 2011a04 <rtems_rfs_format+0x1fc> <== NOT EXECUTED
2011bec: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
2011bf0: 40 00 37 f7 call 201fbcc <rtems_rfs_fs_media_size>
2011bf4: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
2011bf8: 80 a2 20 00 cmp %o0, 0
2011bfc: 22 80 00 9f be,a 2011e78 <rtems_rfs_format+0x670> <== ALWAYS TAKEN
2011c00: 03 00 03 ff sethi %hi(0xffc00), %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
2011c04: b4 10 20 00 clr %i2 <== NOT EXECUTED
2011c08: 37 00 04 00 sethi %hi(0x100000), %i3 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
2011c0c: 82 10 20 1f mov 0x1f, %g1 <== 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);
2011c10: ba 82 40 1b addcc %o1, %i3, %i5 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
2011c14: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
2011c18: b8 42 00 1a addx %o0, %i2, %i4 <== NOT EXECUTED
2011c1c: 85 37 60 14 srl %i5, 0x14, %g2 <== NOT EXECUTED
2011c20: 89 2f 20 0c sll %i4, 0xc, %g4 <== NOT EXECUTED
2011c24: 10 80 00 04 b 2011c34 <rtems_rfs_format+0x42c> <== NOT EXECUTED
2011c28: 84 11 00 02 or %g4, %g2, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
2011c2c: 02 80 00 06 be 2011c44 <rtems_rfs_format+0x43c> <== NOT EXECUTED
2011c30: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
2011c34: bb 28 c0 01 sll %g3, %g1, %i5 <== NOT EXECUTED
2011c38: 80 8f 40 02 btst %i5, %g2 <== NOT EXECUTED
2011c3c: 02 bf ff fc be 2011c2c <rtems_rfs_format+0x424> <== NOT EXECUTED
2011c40: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
2011c44: 80 a7 61 ff cmp %i5, 0x1ff <== NOT EXECUTED
2011c48: 18 80 00 94 bgu 2011e98 <rtems_rfs_format+0x690> <== NOT EXECUTED
2011c4c: fa 27 bf 84 st %i5, [ %fp + -124 ] <== NOT EXECUTED
2011c50: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
fs->block_size = 512;
2011c54: ba 10 22 00 mov 0x200, %i5
2011c58: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
2011c5c: 82 10 22 00 mov 0x200, %g1
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
2011c60: 90 10 00 1d mov %i5, %o0
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
fs->block_size = 512;
2011c64: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
2011c68: 40 00 7b 70 call 2030a28 <.urem>
2011c6c: 92 10 00 1c mov %i4, %o1
2011c70: 80 a2 20 00 cmp %o0, 0
2011c74: 22 bf ff 17 be,a 20118d0 <rtems_rfs_format+0xc8> <== ALWAYS TAKEN
2011c78: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
2011c7c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011c80: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2011c84: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
2011c88: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
2011c8c: 40 00 4b 08 call 20248ac <printf> <== NOT EXECUTED
2011c90: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED
2011c94: 81 c7 e0 08 ret <== NOT EXECUTED
2011c98: 81 e8 00 00 restore <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
2011c9c: 40 00 37 cc call 201fbcc <rtems_rfs_fs_media_size> <== NOT EXECUTED
2011ca0: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
2011ca4: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
2011ca8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2011cac: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011cb0: 40 00 4a ff call 20248ac <printf> <== NOT EXECUTED
2011cb4: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 20349e8 <_CPU_Trap_slot_template+0xf0><== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
2011cb8: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
2011cbc: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011cc0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
2011cc4: 40 00 4a fa call 20248ac <printf> <== NOT EXECUTED
2011cc8: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
rtems_rfs_fs_media_block_size (&fs));
2011ccc: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
2011cd0: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011cd4: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
2011cd8: 40 00 4a f5 call 20248ac <printf> <== NOT EXECUTED
2011cdc: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
2011ce0: 40 00 37 b2 call 201fba8 <rtems_rfs_fs_size> <== NOT EXECUTED
2011ce4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
2011ce8: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
2011cec: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2011cf0: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011cf4: 40 00 4a ee call 20248ac <printf> <== NOT EXECUTED
2011cf8: 90 12 22 68 or %o0, 0x268, %o0 ! 2034a68 <_CPU_Trap_slot_template+0x170><== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
2011cfc: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
2011d00: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011d04: 40 00 4a ea call 20248ac <printf> <== NOT EXECUTED
2011d08: 90 12 22 88 or %o0, 0x288, %o0 ! 2034a88 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
2011d0c: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
2011d10: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011d14: 40 00 4a e6 call 20248ac <printf> <== NOT EXECUTED
2011d18: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 2034ab0 <_CPU_Trap_slot_template+0x1b8><== 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));
2011d1c: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
2011d20: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011d24: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
2011d28: 40 00 4a e1 call 20248ac <printf> <== NOT EXECUTED
2011d2c: 90 12 22 d8 or %o0, 0x2d8, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
2011d30: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
2011d34: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011d38: 40 00 4a dd call 20248ac <printf> <== NOT EXECUTED
2011d3c: 90 12 23 00 or %o0, 0x300, %o0 ! 2034b00 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
2011d40: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
2011d44: fa 07 bf a8 ld [ %fp + -88 ], %i5 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
2011d48: 7f ff c2 19 call 20025ac <.umul> <== NOT EXECUTED
2011d4c: 90 10 00 1d mov %i5, %o0 <== 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,
2011d50: 83 2f 60 03 sll %i5, 3, %g1 <== 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",
2011d54: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
2011d58: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
2011d5c: f8 07 bf 84 ld [ %fp + -124 ], %i4 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
2011d60: ba a7 40 01 subcc %i5, %g1, %i5 <== NOT EXECUTED
2011d64: 12 80 00 55 bne 2011eb8 <rtems_rfs_format+0x6b0> <== NOT EXECUTED
2011d68: 90 10 27 d0 mov 0x7d0, %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))
2011d6c: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
2011d70: b9 2f 20 03 sll %i4, 3, %i4 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
2011d74: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
2011d78: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
2011d7c: 28 80 00 02 bleu,a 2011d84 <rtems_rfs_format+0x57c> <== NOT EXECUTED
2011d80: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
return ((blocks + 1) * 100 * 10) / bits_per_block;
2011d84: 7f ff c2 46 call 200269c <.div> <== NOT EXECUTED
2011d88: 01 00 00 00 nop <== 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",
2011d8c: 92 10 20 0a mov 0xa, %o1 ! a <PROM_START+0xa> <== NOT EXECUTED
2011d90: 7f ff c2 43 call 200269c <.div> <== NOT EXECUTED
2011d94: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
2011d98: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2011d9c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
2011da0: 40 00 7b 24 call 2030a30 <.rem> <== NOT EXECUTED
2011da4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2011da8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2011dac: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2011db0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2011db4: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011db8: 40 00 4a bd call 20248ac <printf> <== NOT EXECUTED
2011dbc: 90 12 23 28 or %o0, 0x328, %o0 ! 2034b28 <_CPU_Trap_slot_template+0x230><== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
rtems_rfs_inode_overhead (&fs) % 10);
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
2011dc0: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
2011dc4: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011dc8: 40 00 4a b9 call 20248ac <printf> <== NOT EXECUTED
2011dcc: 90 12 23 58 or %o0, 0x358, %o0 ! 2034b58 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
2011dd0: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
2011dd4: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011dd8: 40 00 4a b5 call 20248ac <printf> <== NOT EXECUTED
2011ddc: 90 12 23 78 or %o0, 0x378, %o0 ! 2034b78 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
2011de0: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
2011de4: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2011de8: 40 00 4a b1 call 20248ac <printf> <== NOT EXECUTED
2011dec: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 2034ba0 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
2011df0: 10 bf fe e8 b 2011990 <rtems_rfs_format+0x188> <== NOT EXECUTED
2011df4: fa 07 bf 84 ld [ %fp + -124 ], %i5 <== NOT EXECUTED
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
if (!fs->max_name_length)
2011df8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2011dfc: 02 bf fe df be 2011978 <rtems_rfs_format+0x170> <== NOT EXECUTED
2011e00: f4 27 bf a8 st %i2, [ %fp + -88 ] <== NOT EXECUTED
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
2011e04: 10 bf fe df b 2011980 <rtems_rfs_format+0x178> <== NOT EXECUTED
2011e08: c2 27 bf 98 st %g1, [ %fp + -104 ] <== NOT EXECUTED
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
2011e0c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2011e10: 80 a0 60 00 cmp %g1, 0
2011e14: 02 80 00 03 be 2011e20 <rtems_rfs_format+0x618> <== ALWAYS TAKEN
2011e18: 90 10 20 01 mov 1, %o0
2011e1c: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
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;
2011e20: 7f ff c1 e3 call 20025ac <.umul>
2011e24: 92 07 3f ff add %i4, -1, %o1
2011e28: 92 10 20 64 mov 0x64, %o1
2011e2c: 7f ff c2 1a call 2002694 <.udiv>
2011e30: b6 10 20 01 mov 1, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
2011e34: 80 a2 20 00 cmp %o0, 0
2011e38: 32 80 00 30 bne,a 2011ef8 <rtems_rfs_format+0x6f0>
2011e3c: 92 10 00 10 mov %l0, %o1
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2011e40: 92 10 20 38 mov 0x38, %o1
2011e44: 7f ff c2 14 call 2002694 <.udiv>
2011e48: 90 10 00 1d mov %i5, %o0
2011e4c: b8 10 00 08 mov %o0, %i4
2011e50: 90 10 00 1b mov %i3, %o0
2011e54: 7f ff c1 d6 call 20025ac <.umul>
2011e58: 92 10 00 1c mov %i4, %o1
}
/*
* 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;
2011e5c: f8 27 bf ac st %i4, [ %fp + -84 ]
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2011e60: b6 10 00 08 mov %o0, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
2011e64: 80 a6 e0 00 cmp %i3, 0
2011e68: 02 bf fe bc be 2011958 <rtems_rfs_format+0x150> <== NEVER TAKEN
2011e6c: 90 10 20 01 mov 1, %o0
return 1;
return ((dividend - 1) / divisor) + 1;
2011e70: 10 bf fe b7 b 201194c <rtems_rfs_format+0x144>
2011e74: 90 06 ff ff add %i3, -1, %o0
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
2011e78: 82 10 63 ff or %g1, 0x3ff, %g1
2011e7c: 80 a2 40 01 cmp %o1, %g1
2011e80: 18 bf ff 62 bgu 2011c08 <rtems_rfs_format+0x400> <== NEVER TAKEN
2011e84: b4 10 20 00 clr %i2
2011e88: fa 07 bf 84 ld [ %fp + -124 ], %i5
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
2011e8c: 80 a7 61 ff cmp %i5, 0x1ff
2011e90: 08 bf ff 71 bleu 2011c54 <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
2011e94: c2 07 bf 8c ld [ %fp + -116 ], %g1
fs->block_size = 512;
if (fs->block_size > (4 * 1024))
2011e98: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
2011e9c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2011ea0: 08 80 02 06 bleu 20126b8 <rtems_rfs_format+0xeb0> <== NOT EXECUTED
2011ea4: c4 07 bf 8c ld [ %fp + -116 ], %g2 <== NOT EXECUTED
fs->block_size = (4 * 1024);
2011ea8: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
2011eac: f8 00 a0 20 ld [ %g2 + 0x20 ], %i4 <== NOT EXECUTED
2011eb0: 10 bf fe 81 b 20118b4 <rtems_rfs_format+0xac> <== NOT EXECUTED
2011eb4: ba 10 00 01 mov %g1, %i5 <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
2011eb8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2011ebc: 7f ff c1 f6 call 2002694 <.udiv> <== NOT EXECUTED
2011ec0: 90 07 7f ff add %i5, -1, %o0 <== NOT EXECUTED
2011ec4: 90 02 20 02 add %o0, 2, %o0 <== NOT EXECUTED
2011ec8: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
2011ecc: 85 2a 20 07 sll %o0, 7, %g2 <== NOT EXECUTED
2011ed0: 84 20 80 01 sub %g2, %g1, %g2 <== 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))
2011ed4: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
2011ed8: 84 00 80 08 add %g2, %o0, %g2 <== 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));
2011edc: b9 2f 20 03 sll %i4, 3, %i4 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
2011ee0: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
2011ee4: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
2011ee8: 18 bf ff a7 bgu 2011d84 <rtems_rfs_format+0x57c> <== NOT EXECUTED
2011eec: 91 28 a0 03 sll %g2, 3, %o0 <== 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));
2011ef0: 10 bf ff a5 b 2011d84 <rtems_rfs_format+0x57c> <== NOT EXECUTED
2011ef4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
2011ef8: 7f ff c1 e7 call 2002694 <.udiv>
2011efc: 90 02 3f ff add %o0, -1, %o0
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2011f00: 92 10 20 38 mov 0x38, %o1
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
2011f04: b6 02 20 01 add %o0, 1, %i3
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2011f08: 7f ff c1 e3 call 2002694 <.udiv>
2011f0c: 90 10 00 1d mov %i5, %o0
2011f10: b8 10 00 08 mov %o0, %i4
2011f14: 90 10 00 1b mov %i3, %o0
2011f18: 7f ff c1 a5 call 20025ac <.umul>
2011f1c: 92 10 00 1c mov %i4, %o1
}
/*
* 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;
2011f20: f8 27 bf ac st %i4, [ %fp + -84 ]
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2011f24: b6 10 00 08 mov %o0, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
2011f28: 80 a6 e0 00 cmp %i3, 0
2011f2c: 02 bf fe 8b be 2011958 <rtems_rfs_format+0x150> <== NEVER TAKEN
2011f30: 90 10 20 01 mov 1, %o0
return 1;
return ((dividend - 1) / divisor) + 1;
2011f34: 10 bf fe 86 b 201194c <rtems_rfs_format+0x144>
2011f38: 90 06 ff ff add %i3, -1, %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);
2011f3c: 90 07 bf 7c add %fp, -132, %o0
2011f40: 40 00 2b a1 call 201cdc4 <rtems_rfs_buffer_handle_release>
2011f44: 92 07 bf 30 add %fp, -208, %o1
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
2011f48: c2 07 bf a0 ld [ %fp + -96 ], %g1
2011f4c: 80 a0 60 00 cmp %g1, 0
2011f50: 04 80 01 36 ble 2012428 <rtems_rfs_format+0xc20> <== NEVER TAKEN
2011f54: c2 07 bf 80 ld [ %fp + -128 ], %g1
if (!rtems_rfs_write_group (&fs, group,
2011f58: e2 0e 60 14 ldub [ %i1 + 0x14 ], %l1
2011f5c: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
2011f60: 80 a0 60 00 cmp %g1, 0
2011f64: 02 80 01 2f be 2012420 <rtems_rfs_format+0xc18> <== NEVER TAKEN
2011f68: f8 07 bf a4 ld [ %fp + -92 ], %i4
*/
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",
2011f6c: 27 00 80 d3 sethi %hi(0x2034c00), %l3
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
2011f70: 25 00 80 d3 sethi %hi(0x2034c00), %l2
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
2011f74: 2b 00 80 d3 sethi %hi(0x2034c00), %l5
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
2011f78: b6 10 20 01 mov 1, %i3
2011f7c: a0 10 20 00 clr %l0
2011f80: b4 10 20 00 clr %i2
*/
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",
2011f84: a6 14 e0 b8 or %l3, 0xb8, %l3
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
2011f88: a4 14 a0 f0 or %l2, 0xf0, %l2
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
2011f8c: a8 10 20 01 mov 1, %l4
if (verbose)
printf (", inodes");
2011f90: aa 15 61 e0 or %l5, 0x1e0, %l5
/*
* 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))
2011f94: 86 06 c0 1c add %i3, %i4, %g3
2011f98: 80 a0 c0 01 cmp %g3, %g1
2011f9c: 38 80 00 02 bgu,a 2011fa4 <rtems_rfs_format+0x79c> <== ALWAYS TAKEN
2011fa0: b8 20 40 1b sub %g1, %i3, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
2011fa4: ac 88 a0 ff andcc %g2, 0xff, %l6
2011fa8: 12 80 00 3b bne 2012094 <rtems_rfs_format+0x88c> <== NEVER TAKEN
2011fac: 90 10 00 13 mov %l3, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2011fb0: c0 2f bf 30 clrb [ %fp + -208 ]
handle->bnum = 0;
2011fb4: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
2011fb8: c0 27 bf 38 clr [ %fp + -200 ]
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
2011fbc: 90 07 bf 3c add %fp, -196, %o0
2011fc0: 92 07 bf 7c add %fp, -132, %o1
2011fc4: 94 07 bf 30 add %fp, -208, %o2
2011fc8: 96 10 00 1c mov %i4, %o3
2011fcc: 40 00 26 e5 call 201bb60 <rtems_rfs_bitmap_open>
2011fd0: 98 10 00 1b mov %i3, %o4
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
2011fd4: ba 92 20 00 orcc %o0, 0, %i5
2011fd8: 04 80 00 12 ble 2012020 <rtems_rfs_format+0x818> <== ALWAYS TAKEN
2011fdc: 92 07 bf 30 add %fp, -208, %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);
2011fe0: 40 00 2b 79 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2011fe4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
2011fe8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
2011fec: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2011ff0: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
2011ff4: 40 00 4e 78 call 20259d4 <strerror> <== NOT EXECUTED
2011ff8: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
2011ffc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012000: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2012004: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2012008: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
201200c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
2012010: 40 00 4a 27 call 20248ac <printf> <== NOT EXECUTED
2012014: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
2012018: 81 c7 e0 08 ret <== NOT EXECUTED
201201c: 81 e8 00 00 restore <== 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));
2012020: c2 07 bf 38 ld [ %fp + -200 ], %g1
2012024: d4 07 bf 84 ld [ %fp + -124 ], %o2
2012028: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201202c: 40 00 49 a2 call 20246b4 <memset>
2012030: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
2012034: 40 00 26 23 call 201b8c0 <rtems_rfs_bitmap_map_clear_all>
2012038: 90 07 bf 3c add %fp, -196, %o0
if (rc > 0)
201203c: ba 92 20 00 orcc %o0, 0, %i5
2012040: 04 80 00 20 ble 20120c0 <rtems_rfs_format+0x8b8> <== ALWAYS TAKEN
2012044: 92 10 20 00 clr %o1
{
rtems_rfs_bitmap_close (&bitmap);
2012048: 40 00 26 d7 call 201bba4 <rtems_rfs_bitmap_close> <== NOT EXECUTED
201204c: 90 07 bf 3c add %fp, -196, %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);
2012050: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
2012054: 40 00 2b 5c call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2012058: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
201205c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
2012060: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2012064: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
2012068: 40 00 4e 5b call 20259d4 <strerror> <== NOT EXECUTED
201206c: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
2012070: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012074: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2012078: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201207c: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
2012080: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
2012084: 40 00 4a 0a call 20248ac <printf> <== NOT EXECUTED
2012088: 90 12 21 48 or %o0, 0x148, %o0 <== NOT EXECUTED
201208c: 81 c7 e0 08 ret <== NOT EXECUTED
2012090: 81 e8 00 00 restore <== NOT EXECUTED
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
2012094: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012098: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
201209c: 40 00 4a 04 call 20248ac <printf> <== NOT EXECUTED
20120a0: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
20120a4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20120a8: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
20120ac: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
20120b0: 40 00 49 ff call 20248ac <printf> <== NOT EXECUTED
20120b4: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
20120b8: 10 bf ff c2 b 2011fc0 <rtems_rfs_format+0x7b8> <== NOT EXECUTED
20120bc: 90 07 bf 3c add %fp, -196, %o0 <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
20120c0: 40 00 25 79 call 201b6a4 <rtems_rfs_bitmap_map_set>
20120c4: 90 07 bf 3c add %fp, -196, %o0
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
20120c8: 92 10 20 01 mov 1, %o1
20120cc: 40 00 25 76 call 201b6a4 <rtems_rfs_bitmap_map_set>
20120d0: 90 07 bf 3c add %fp, -196, %o0
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
20120d4: d0 07 bf a8 ld [ %fp + -88 ], %o0
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
20120d8: 80 a2 20 00 cmp %o0, 0
20120dc: 12 80 00 2b bne 2012188 <rtems_rfs_format+0x980> <== ALWAYS TAKEN
20120e0: d2 07 bf ac ld [ %fp + -84 ], %o1
return 1;
20120e4: ae 10 20 01 mov 1, %l7 <== NOT EXECUTED
20120e8: ba 10 20 00 clr %i5 <== NOT EXECUTED
/*
* 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);
20120ec: 92 07 60 02 add %i5, 2, %o1
20120f0: 40 00 25 6d call 201b6a4 <rtems_rfs_bitmap_map_set>
20120f4: 90 07 bf 3c add %fp, -196, %o0
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++)
20120f8: ba 07 60 01 inc %i5
20120fc: 80 a7 40 17 cmp %i5, %l7
2012100: 06 bf ff fc bl 20120f0 <rtems_rfs_format+0x8e8>
2012104: 92 07 60 02 add %i5, 2, %o1
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
2012108: 40 00 26 a7 call 201bba4 <rtems_rfs_bitmap_close>
201210c: 90 07 bf 3c add %fp, -196, %o0
if (rc > 0)
2012110: ba 92 20 00 orcc %o0, 0, %i5
2012114: 14 80 00 24 bg 20121a4 <rtems_rfs_format+0x99c> <== NEVER TAKEN
2012118: 80 a5 a0 00 cmp %l6, 0
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
201211c: 12 80 00 50 bne 201225c <rtems_rfs_format+0xa54> <== NEVER TAKEN
2012120: e8 2f bf 30 stb %l4, [ %fp + -208 ]
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
2012124: 90 07 bf 3c add %fp, -196, %o0
2012128: 92 07 bf 7c add %fp, -132, %o1
201212c: 94 07 bf 30 add %fp, -208, %o2
2012130: 96 10 00 1c mov %i4, %o3
2012134: 40 00 26 8b call 201bb60 <rtems_rfs_bitmap_open>
2012138: 98 04 20 02 add %l0, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
201213c: ba 92 20 00 orcc %o0, 0, %i5
2012140: 04 80 00 2a ble 20121e8 <rtems_rfs_format+0x9e0> <== ALWAYS TAKEN
2012144: 92 07 bf 30 add %fp, -208, %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);
2012148: 40 00 2b 1f call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201214c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
2012150: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
2012154: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2012158: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
201215c: 40 00 4e 1e call 20259d4 <strerror> <== NOT EXECUTED
2012160: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
2012164: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012168: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201216c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2012170: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
2012174: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
2012178: 40 00 49 cd call 20248ac <printf> <== NOT EXECUTED
201217c: 90 12 21 f0 or %o0, 0x1f0, %o0 <== NOT EXECUTED
2012180: 81 c7 e0 08 ret <== NOT EXECUTED
2012184: 81 e8 00 00 restore <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
2012188: 7f ff c1 43 call 2002694 <.udiv>
201218c: 90 02 3f ff add %o0, -1, %o0
2012190: ae 02 20 01 add %o0, 1, %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++)
2012194: 80 a5 e0 00 cmp %l7, 0
2012198: 14 bf ff d5 bg 20120ec <rtems_rfs_format+0x8e4> <== ALWAYS TAKEN
201219c: ba 10 20 00 clr %i5
20121a0: 30 bf ff da b,a 2012108 <rtems_rfs_format+0x900> <== 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);
20121a4: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
20121a8: 40 00 2b 07 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
20121ac: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
20121b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
20121b4: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
20121b8: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
20121bc: 40 00 4e 06 call 20259d4 <strerror> <== NOT EXECUTED
20121c0: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
20121c4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
20121c8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20121cc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
20121d0: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
20121d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
20121d8: 40 00 49 b5 call 20248ac <printf> <== NOT EXECUTED
20121dc: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED
20121e0: 81 c7 e0 08 ret <== NOT EXECUTED
20121e4: 81 e8 00 00 restore <== 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));
20121e8: c2 07 bf 38 ld [ %fp + -200 ], %g1
20121ec: d4 07 bf 84 ld [ %fp + -124 ], %o2
20121f0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20121f4: 40 00 49 30 call 20246b4 <memset>
20121f8: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
20121fc: 40 00 25 b1 call 201b8c0 <rtems_rfs_bitmap_map_clear_all>
2012200: 90 07 bf 3c add %fp, -196, %o0
2012204: ba 10 00 08 mov %o0, %i5
if (rc > 0)
2012208: 80 a7 60 00 cmp %i5, 0
201220c: 04 80 00 21 ble 2012290 <rtems_rfs_format+0xa88> <== ALWAYS TAKEN
2012210: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
2012214: 40 00 26 64 call 201bba4 <rtems_rfs_bitmap_close> <== NOT EXECUTED
2012218: b0 10 3f ff mov -1, %i0 <== 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);
201221c: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
2012220: 40 00 2a e9 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2012224: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
2012228: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
201222c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2012230: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
2012234: 40 00 4d e8 call 20259d4 <strerror> <== NOT EXECUTED
2012238: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
201223c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012240: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2012244: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2012248: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201224c: 40 00 49 98 call 20248ac <printf> <== NOT EXECUTED
2012250: 90 12 22 38 or %o0, 0x238, %o0 ! 2034e38 <_CPU_Trap_slot_template+0x540><== NOT EXECUTED
2012254: 81 c7 e0 08 ret <== NOT EXECUTED
2012258: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
201225c: 40 00 49 94 call 20248ac <printf> <== NOT EXECUTED
2012260: 90 10 00 15 mov %l5, %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,
2012264: 10 bf ff b1 b 2012128 <rtems_rfs_format+0x920> <== NOT EXECUTED
2012268: 90 07 bf 3c add %fp, -196, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
if (rc > 0)
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
201226c: 40 00 4d da call 20259d4 <strerror> <== NOT EXECUTED
2012270: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012274: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2012278: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201227c: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2012280: 40 00 49 8b call 20248ac <printf> <== NOT EXECUTED
2012284: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 2034bc8 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
2012288: 81 c7 e0 08 ret <== NOT EXECUTED
201228c: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
2012290: 40 00 26 45 call 201bba4 <rtems_rfs_bitmap_close>
2012294: 01 00 00 00 nop
if (rc > 0)
2012298: ba 92 20 00 orcc %o0, 0, %i5
201229c: 14 80 00 2a bg 2012344 <rtems_rfs_format+0xb3c> <== NEVER TAKEN
20122a0: 80 8c 60 ff btst 0xff, %l1
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
20122a4: 02 80 00 46 be 20123bc <rtems_rfs_format+0xbb4> <== ALWAYS TAKEN
20122a8: e8 2f bf 30 stb %l4, [ %fp + -208 ]
{
for (b = 0; b < blocks; b++)
20122ac: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
20122b0: 04 80 00 43 ble 20123bc <rtems_rfs_format+0xbb4> <== NOT EXECUTED
20122b4: b6 06 e0 02 add %i3, 2, %i3 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
20122b8: 10 80 00 0a b 20122e0 <rtems_rfs_format+0xad8> <== NOT EXECUTED
20122bc: ae 05 c0 1b add %l7, %i3, %l7 <== 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));
20122c0: c2 07 bf 38 ld [ %fp + -200 ], %g1 <== NOT EXECUTED
20122c4: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
20122c8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 <== NOT EXECUTED
20122cc: 40 00 48 fa call 20246b4 <memset> <== NOT EXECUTED
20122d0: b6 06 e0 01 inc %i3 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
20122d4: 80 a6 c0 17 cmp %i3, %l7 <== NOT EXECUTED
20122d8: 02 80 00 39 be 20123bc <rtems_rfs_format+0xbb4> <== NOT EXECUTED
20122dc: e8 2f bf 30 stb %l4, [ %fp + -208 ] <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
20122e0: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
20122e4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
20122e8: 96 10 20 00 clr %o3 <== NOT EXECUTED
20122ec: 40 00 2b 30 call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
20122f0: 90 07 bf 7c add %fp, -132, %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));
20122f4: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
20122f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20122fc: 04 bf ff f1 ble 20122c0 <rtems_rfs_format+0xab8> <== NOT EXECUTED
2012300: ba 10 00 08 mov %o0, %i5 <== 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);
2012304: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
2012308: 40 00 2a af call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201230c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
2012310: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
2012314: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2012318: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
201231c: 40 00 4d ae call 20259d4 <strerror> <== NOT EXECUTED
2012320: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
2012324: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012328: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201232c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2012330: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
2012334: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
2012338: 40 00 49 5d call 20248ac <printf> <== NOT EXECUTED
201233c: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
2012340: 30 bf fd bb b,a 2011a2c <rtems_rfs_format+0x224> <== 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);
2012344: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
2012348: 40 00 2a 9f call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201234c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
2012350: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
2012354: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2012358: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
201235c: 40 00 4d 9e call 20259d4 <strerror> <== NOT EXECUTED
2012360: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
2012364: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012368: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201236c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2012370: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
2012374: 40 00 49 4e call 20248ac <printf> <== NOT EXECUTED
2012378: 90 12 22 88 or %o0, 0x288, %o0 ! 2034e88 <_CPU_Trap_slot_template+0x590><== NOT EXECUTED
201237c: 30 bf fd ac b,a 2011a2c <rtems_rfs_format+0x224> <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
2012380: 40 00 4d 95 call 20259d4 <strerror> <== NOT EXECUTED
2012384: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012388: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201238c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2012390: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
2012394: 40 00 49 46 call 20248ac <printf> <== NOT EXECUTED
2012398: 90 12 21 20 or %o0, 0x120, %o0 ! 2034920 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
201239c: 81 c7 e0 08 ret <== NOT EXECUTED
20123a0: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
20123a4: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
return -1;
20123a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
20123ac: 40 00 49 40 call 20248ac <printf> <== NOT EXECUTED
20123b0: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
20123b4: 81 c7 e0 08 ret <== NOT EXECUTED
20123b8: 81 e8 00 00 restore <== 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);
20123bc: 90 07 bf 7c add %fp, -132, %o0
20123c0: 40 00 2a 81 call 201cdc4 <rtems_rfs_buffer_handle_release>
20123c4: 92 07 bf 30 add %fp, -208, %o1
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
20123c8: c2 07 bf a0 ld [ %fp + -96 ], %g1
20123cc: b4 06 a0 01 inc %i2
20123d0: 80 a0 40 1a cmp %g1, %i2
20123d4: 04 80 00 15 ble 2012428 <rtems_rfs_format+0xc20> <== ALWAYS TAKEN
20123d8: f8 07 bf a4 ld [ %fp + -92 ], %i4
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
20123dc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20123e0: 7f ff c0 73 call 20025ac <.umul> <== NOT EXECUTED
20123e4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
20123e8: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
20123ec: b6 02 20 01 add %o0, 1, %i3 <== NOT EXECUTED
20123f0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
20123f4: e2 0e 60 14 ldub [ %i1 + 0x14 ], %l1 <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
20123f8: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
20123fc: 08 bf fe e6 bleu 2011f94 <rtems_rfs_format+0x78c> <== NOT EXECUTED
2012400: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2 <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
2012404: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012408: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
201240c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
2012410: 40 00 49 27 call 20248ac <printf> <== NOT EXECUTED
2012414: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
2012418: 81 c7 e0 08 ret <== NOT EXECUTED
201241c: 81 e8 00 00 restore <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
2012420: 10 bf ff f9 b 2012404 <rtems_rfs_format+0xbfc> <== NOT EXECUTED
2012424: b4 10 20 00 clr %i2 <== NOT EXECUTED
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
2012428: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
201242c: 80 a0 60 00 cmp %g1, 0
2012430: 02 80 00 04 be 2012440 <rtems_rfs_format+0xc38> <== ALWAYS TAKEN
2012434: 01 00 00 00 nop
printf ("\n");
2012438: 40 00 49 87 call 2024a54 <putchar> <== NOT EXECUTED
201243c: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
2012440: 40 00 2c 8f call 201d67c <rtems_rfs_buffer_close>
2012444: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
2012448: ba 92 20 00 orcc %o0, 0, %i5
201244c: 14 80 00 43 bg 2012558 <rtems_rfs_format+0xd50> <== NEVER TAKEN
2012450: 92 10 20 00 clr %o1
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
2012454: 90 10 00 18 mov %i0, %o0
2012458: 94 10 20 06 mov 6, %o2
201245c: 96 10 20 00 clr %o3
2012460: 40 00 35 e5 call 201fbf4 <rtems_rfs_fs_open>
2012464: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
2012468: 80 a2 20 00 cmp %o0, 0
201246c: 06 80 00 7b bl 2012658 <rtems_rfs_format+0xe50> <== NEVER TAKEN
2012470: 92 10 20 01 mov 1, %o1
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
2012474: d0 07 bf 28 ld [ %fp + -216 ], %o0
2012478: 40 00 02 8c call 2012ea8 <rtems_rfs_inode_alloc>
201247c: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
2012480: ba 92 20 00 orcc %o0, 0, %i5
2012484: 14 80 00 0c bg 20124b4 <rtems_rfs_format+0xcac> <== NEVER TAKEN
2012488: d2 07 bf 2c ld [ %fp + -212 ], %o1
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
201248c: 80 a2 60 01 cmp %o1, 1
2012490: 02 80 00 1c be 2012500 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
2012494: 11 00 80 d3 sethi %hi(0x2034c00), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
2012498: 40 00 49 05 call 20248ac <printf> <== NOT EXECUTED
201249c: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 2034fb8 <_CPU_Trap_slot_template+0x6c0><== NOT EXECUTED
rtems_rfs_fs_close (fs);
20124a0: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
20124a4: 40 00 38 00 call 20204a4 <rtems_rfs_fs_close> <== NOT EXECUTED
20124a8: b0 10 20 00 clr %i0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
20124ac: 81 c7 e0 08 ret <== NOT EXECUTED
20124b0: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
if (rc > 0)
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
20124b4: 40 00 4d 48 call 20259d4 <strerror> <== NOT EXECUTED
20124b8: 01 00 00 00 nop <== NOT EXECUTED
20124bc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20124c0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20124c4: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
20124c8: 40 00 48 f9 call 20248ac <printf> <== NOT EXECUTED
20124cc: 90 12 23 80 or %o0, 0x380, %o0 ! 2034f80 <_CPU_Trap_slot_template+0x688><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
20124d0: 40 00 37 f5 call 20204a4 <rtems_rfs_fs_close> <== NOT EXECUTED
20124d4: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
20124d8: 40 00 4d 3f call 20259d4 <strerror> <== NOT EXECUTED
20124dc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20124e0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20124e4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
rc, strerror (rc));
return -1;
20124e8: 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",
20124ec: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20124f0: 40 00 48 ef call 20248ac <printf> <== NOT EXECUTED
20124f4: 90 12 20 f8 or %o0, 0xf8, %o0 ! 20350f8 <_CPU_Trap_slot_template+0x800><== NOT EXECUTED
20124f8: 81 c7 e0 08 ret <== NOT EXECUTED
20124fc: 81 e8 00 00 restore <== 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);
2012500: d0 07 bf 28 ld [ %fp + -216 ], %o0
2012504: 92 10 20 01 mov 1, %o1
2012508: 94 07 bf 54 add %fp, -172, %o2
201250c: 40 00 02 a3 call 2012f98 <rtems_rfs_inode_open>
2012510: 96 10 20 01 mov 1, %o3
if (rc > 0)
2012514: ba 92 20 00 orcc %o0, 0, %i5
2012518: 24 80 00 19 ble,a 201257c <rtems_rfs_format+0xd74> <== ALWAYS TAKEN
201251c: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
2012520: 40 00 4d 2d call 20259d4 <strerror> <== NOT EXECUTED
2012524: 01 00 00 00 nop <== NOT EXECUTED
2012528: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201252c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2012530: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
2012534: 40 00 48 de call 20248ac <printf> <== NOT EXECUTED
2012538: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 2034ff0 <_CPU_Trap_slot_template+0x6f8><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
201253c: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
2012540: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
2012544: 40 00 01 a7 call 2012be0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
2012548: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
rtems_rfs_fs_close (fs);
201254c: 40 00 37 d6 call 20204a4 <rtems_rfs_fs_close> <== NOT EXECUTED
2012550: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
2012554: 30 bf ff e1 b,a 20124d8 <rtems_rfs_format+0xcd0> <== NOT EXECUTED
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
2012558: 40 00 4d 1f call 20259d4 <strerror> <== NOT EXECUTED
201255c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012560: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2012564: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2012568: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201256c: 40 00 48 d0 call 20248ac <printf> <== NOT EXECUTED
2012570: 90 12 23 18 or %o0, 0x318, %o0 ! 2034f18 <_CPU_Trap_slot_template+0x620><== NOT EXECUTED
2012574: 81 c7 e0 08 ret <== NOT EXECUTED
2012578: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
201257c: 92 10 20 00 clr %o1
2012580: 96 10 20 00 clr %o3
2012584: 15 00 00 10 sethi %hi(0x4000), %o2
2012588: 98 10 20 00 clr %o4
201258c: 40 00 03 7f call 2013388 <rtems_rfs_inode_initialise>
2012590: 94 12 a1 c9 or %o2, 0x1c9, %o2
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
2012594: ba 92 20 00 orcc %o0, 0, %i5
2012598: 24 80 00 0a ble,a 20125c0 <rtems_rfs_format+0xdb8> <== ALWAYS TAKEN
201259c: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
20125a0: 40 00 4d 0d call 20259d4 <strerror> <== NOT EXECUTED
20125a4: 01 00 00 00 nop <== NOT EXECUTED
20125a8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20125ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20125b0: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20125b4: 40 00 48 be call 20248ac <printf> <== NOT EXECUTED
20125b8: 90 12 20 20 or %o0, 0x20, %o0 ! 2035020 <_CPU_Trap_slot_template+0x728><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
20125bc: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
20125c0: d8 07 bf 2c ld [ %fp + -212 ], %o4
20125c4: 92 07 bf 54 add %fp, -172, %o1
20125c8: 96 10 20 01 mov 1, %o3
20125cc: 15 00 80 ca sethi %hi(0x2032800), %o2
20125d0: 40 00 2d b8 call 201dcb0 <rtems_rfs_dir_add_entry>
20125d4: 94 12 a3 f0 or %o2, 0x3f0, %o2 ! 2032bf0 <flashdisk_ops+0x1c>
if (rc > 0)
20125d8: ba 92 20 00 orcc %o0, 0, %i5
20125dc: 24 80 00 0a ble,a 2012604 <rtems_rfs_format+0xdfc> <== ALWAYS TAKEN
20125e0: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
20125e4: 40 00 4c fc call 20259d4 <strerror> <== NOT EXECUTED
20125e8: 01 00 00 00 nop <== NOT EXECUTED
20125ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20125f0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20125f4: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20125f8: 40 00 48 ad call 20248ac <printf> <== NOT EXECUTED
20125fc: 90 12 20 58 or %o0, 0x58, %o0 ! 2035058 <_CPU_Trap_slot_template+0x760><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
2012600: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
2012604: 40 00 02 dd call 2013178 <rtems_rfs_inode_close>
2012608: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
201260c: ba 92 20 00 orcc %o0, 0, %i5
2012610: 04 80 00 09 ble 2012634 <rtems_rfs_format+0xe2c> <== ALWAYS TAKEN
2012614: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
2012618: 40 00 4c ef call 20259d4 <strerror> <== NOT EXECUTED
201261c: 01 00 00 00 nop <== NOT EXECUTED
2012620: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2012624: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2012628: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
201262c: 40 00 48 a0 call 20248ac <printf> <== NOT EXECUTED
2012630: 90 12 20 90 or %o0, 0x90, %o0 ! 2035090 <_CPU_Trap_slot_template+0x798><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
2012634: 40 00 37 9c call 20204a4 <rtems_rfs_fs_close>
2012638: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
201263c: ba 92 20 00 orcc %o0, 0, %i5
2012640: 06 80 00 12 bl 2012688 <rtems_rfs_format+0xe80> <== NEVER TAKEN
2012644: 80 a7 60 00 cmp %i5, 0
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
2012648: 12 bf ff a4 bne 20124d8 <rtems_rfs_format+0xcd0> <== NEVER TAKEN
201264c: b0 10 20 00 clr %i0
rc, strerror (rc));
return -1;
}
return 0;
}
2012650: 81 c7 e0 08 ret
2012654: 81 e8 00 00 restore
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",
errno, strerror (errno));
2012658: 40 00 43 04 call 2023268 <__errno> <== NOT EXECUTED
201265c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2012660: 40 00 43 02 call 2023268 <__errno> <== NOT EXECUTED
2012664: 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",
2012668: 40 00 4c db call 20259d4 <strerror> <== NOT EXECUTED
201266c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2012670: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2012674: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2012678: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201267c: 40 00 48 8c call 20248ac <printf> <== NOT EXECUTED
2012680: 90 12 23 48 or %o0, 0x348, %o0 ! 2034f48 <_CPU_Trap_slot_template+0x650><== NOT EXECUTED
2012684: 30 bf ff f3 b,a 2012650 <rtems_rfs_format+0xe48> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
2012688: 40 00 42 f8 call 2023268 <__errno> <== NOT EXECUTED
201268c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2012690: 40 00 42 f6 call 2023268 <__errno> <== NOT EXECUTED
2012694: 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",
2012698: 40 00 4c cf call 20259d4 <strerror> <== NOT EXECUTED
201269c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20126a0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20126a4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20126a8: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20126ac: 40 00 48 80 call 20248ac <printf> <== NOT EXECUTED
20126b0: 90 12 20 c0 or %o0, 0xc0, %o0 ! 20350c0 <_CPU_Trap_slot_template+0x7c8><== NOT EXECUTED
20126b4: 30 bf ff e7 b,a 2012650 <rtems_rfs_format+0xe48> <== NOT EXECUTED
20126b8: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
20126bc: 10 bf fc 7e b 20118b4 <rtems_rfs_format+0xac> <== NOT EXECUTED
20126c0: f8 00 60 20 ld [ %g1 + 0x20 ], %i4 <== NOT EXECUTED
020204a4 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
20204a4: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
20204a8: 90 10 20 00 clr %o0
20204ac: 7f ff d1 62 call 2014a34 <rtems_rfs_trace>
20204b0: 92 10 20 02 mov 2, %o1
20204b4: 80 8a 20 ff btst 0xff, %o0
20204b8: 12 80 00 17 bne 2020514 <rtems_rfs_fs_close+0x70> <== NEVER TAKEN
20204bc: 11 00 80 dc sethi %hi(0x2037000), %o0
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
20204c0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
20204c4: b8 10 20 00 clr %i4
20204c8: 80 a0 60 00 cmp %g1, 0
20204cc: 04 80 00 0b ble 20204f8 <rtems_rfs_fs_close+0x54> <== NEVER TAKEN
20204d0: ba 10 20 00 clr %i5
rtems_rfs_group_close (fs, &fs->groups[group]);
20204d4: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
20204d8: 90 10 00 18 mov %i0, %o0
20204dc: 7f ff c9 07 call 20128f8 <rtems_rfs_group_close>
20204e0: 92 02 40 1c add %o1, %i4, %o1
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
20204e4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
20204e8: ba 07 60 01 inc %i5
20204ec: 80 a0 40 1d cmp %g1, %i5
20204f0: 14 bf ff f9 bg 20204d4 <rtems_rfs_fs_close+0x30> <== NEVER TAKEN
20204f4: b8 07 20 50 add %i4, 0x50, %i4
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
20204f8: 7f ff f4 61 call 201d67c <rtems_rfs_buffer_close>
20204fc: 90 10 00 18 mov %i0, %o0
free (fs);
2020500: 90 10 00 18 mov %i0, %o0
2020504: 7f ff a0 c0 call 2008804 <free>
2020508: b0 10 20 00 clr %i0
return 0;
}
202050c: 81 c7 e0 08 ret
2020510: 81 e8 00 00 restore
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
2020514: 40 00 11 7e call 2024b0c <puts> <== NOT EXECUTED
2020518: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
202051c: 10 bf ff ea b 20204c4 <rtems_rfs_fs_close+0x20> <== NOT EXECUTED
2020520: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
0201fbf4 <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)
{
201fbf4: 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))
201fbf8: 90 10 20 00 clr %o0
201fbfc: 7f ff d3 8e call 2014a34 <rtems_rfs_trace>
201fc00: 92 10 20 01 mov 1, %o1
201fc04: 80 8a 20 ff btst 0xff, %o0
201fc08: 12 80 00 82 bne 201fe10 <rtems_rfs_fs_open+0x21c> <== NEVER TAKEN
201fc0c: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
201fc10: 7f ff a4 9a call 2008e78 <malloc>
201fc14: 90 10 20 84 mov 0x84, %o0
if (!*fs)
201fc18: 80 a2 20 00 cmp %o0, 0
201fc1c: 02 80 01 68 be 20201bc <rtems_rfs_fs_open+0x5c8> <== NEVER TAKEN
201fc20: d0 27 00 00 st %o0, [ %i4 ]
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
201fc24: 92 10 20 00 clr %o1
201fc28: 40 00 12 a3 call 20246b4 <memset>
201fc2c: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
201fc30: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
201fc34: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
201fc38: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
201fc3c: 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;
201fc40: 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 );
201fc44: 86 00 60 44 add %g1, 0x44, %g3
201fc48: 84 00 60 48 add %g1, 0x48, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
201fc4c: c6 20 60 4c st %g3, [ %g1 + 0x4c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201fc50: c4 20 60 44 st %g2, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
201fc54: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201fc58: 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 );
201fc5c: 86 00 60 54 add %g1, 0x54, %g3
201fc60: 84 00 60 58 add %g1, 0x58, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
201fc64: c6 20 60 5c st %g3, [ %g1 + 0x5c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201fc68: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
201fc6c: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201fc70: 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 );
201fc74: 86 00 60 64 add %g1, 0x64, %g3
201fc78: 84 00 60 68 add %g1, 0x68, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
201fc7c: c6 20 60 6c st %g3, [ %g1 + 0x6c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201fc80: c4 20 60 64 st %g2, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
201fc84: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201fc88: 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 );
201fc8c: 86 00 60 74 add %g1, 0x74, %g3
201fc90: 84 00 60 78 add %g1, 0x78, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
201fc94: c6 20 60 7c st %g3, [ %g1 + 0x7c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201fc98: c4 20 60 74 st %g2, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
201fc9c: d2 07 00 00 ld [ %i4 ], %o1
201fca0: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
201fca4: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
201fca8: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
201fcac: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
201fcb0: 7f ff f5 77 call 201d28c <rtems_rfs_buffer_open>
201fcb4: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
201fcb8: ba 92 20 00 orcc %o0, 0, %i5
201fcbc: 14 80 00 a9 bg 201ff60 <rtems_rfs_fs_open+0x36c> <== NEVER TAKEN
201fcc0: 94 10 20 00 clr %o2
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
201fcc4: f6 07 00 00 ld [ %i4 ], %i3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201fcc8: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
201fccc: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
201fcd0: c0 27 bf d4 clr [ %fp + -44 ]
printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
201fcd4: 90 10 00 1b mov %i3, %o0
201fcd8: 92 07 bf cc add %fp, -52, %o1
201fcdc: 7f ff f4 b4 call 201cfac <rtems_rfs_buffer_handle_request>
201fce0: 96 10 20 01 mov 1, %o3
if (rc > 0)
201fce4: ba 92 20 00 orcc %o0, 0, %i5
201fce8: 04 80 00 1d ble 201fd5c <rtems_rfs_fs_open+0x168> <== ALWAYS TAKEN
201fcec: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201fcf0: 7f ff d3 51 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201fcf4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201fcf8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201fcfc: 02 80 00 09 be 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
201fd00: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
201fd04: 40 00 17 34 call 20259d4 <strerror> <== NOT EXECUTED
201fd08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201fd0c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201fd10: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201fd14: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201fd18: 40 00 12 e5 call 20248ac <printf> <== NOT EXECUTED
201fd1c: 90 12 22 38 or %o0, 0x238, %o0 ! 2036e38 <CSWTCH.2+0x1124><== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
201fd20: 7f ff f6 57 call 201d67c <rtems_rfs_buffer_close> <== NOT EXECUTED
201fd24: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201fd28: 7f ff a2 b7 call 2008804 <free> <== NOT EXECUTED
201fd2c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201fd30: 90 10 20 00 clr %o0 <== NOT EXECUTED
201fd34: 7f ff d3 40 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201fd38: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201fd3c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201fd40: 12 80 00 2c bne 201fdf0 <rtems_rfs_fs_open+0x1fc> <== NOT EXECUTED
201fd44: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
201fd48: 40 00 0d 48 call 2023268 <__errno> <== NOT EXECUTED
201fd4c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
201fd50: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
201fd54: 81 c7 e0 08 ret <== NOT EXECUTED
201fd58: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
201fd5c: c2 07 bf d4 ld [ %fp + -44 ], %g1
201fd60: 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)
201fd64: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
201fd68: c4 0f 40 00 ldub [ %i5 ], %g2
201fd6c: c8 0f 60 01 ldub [ %i5 + 1 ], %g4
201fd70: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
201fd74: 83 28 60 08 sll %g1, 8, %g1
201fd78: 85 28 a0 18 sll %g2, 0x18, %g2
201fd7c: 89 29 20 10 sll %g4, 0x10, %g4
201fd80: 84 10 80 04 or %g2, %g4, %g2
201fd84: 84 10 80 03 or %g2, %g3, %g2
201fd88: 84 10 80 01 or %g2, %g1, %g2
201fd8c: 03 0a 02 48 sethi %hi(0x28092000), %g1
201fd90: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001>
201fd94: 80 a0 80 01 cmp %g2, %g1
201fd98: 22 80 00 29 be,a 201fe3c <rtems_rfs_fs_open+0x248> <== ALWAYS TAKEN
201fd9c: c6 0f 60 0d ldub [ %i5 + 0xd ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201fda0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201fda4: 7f ff d3 24 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201fda8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201fdac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201fdb0: 32 80 00 1c bne,a 201fe20 <rtems_rfs_fs_open+0x22c> <== NOT EXECUTED
201fdb4: 11 00 80 db sethi %hi(0x2036c00), %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);
201fdb8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201fdbc: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201fdc0: 7f ff f4 01 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201fdc4: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
201fdc8: 7f ff f6 2d call 201d67c <rtems_rfs_buffer_close> <== NOT EXECUTED
201fdcc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201fdd0: 7f ff a2 8d call 2008804 <free> <== NOT EXECUTED
201fdd4: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201fdd8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201fddc: 7f ff d3 16 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201fde0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201fde4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201fde8: 02 bf ff d8 be 201fd48 <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
201fdec: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
201fdf0: 40 00 16 f9 call 20259d4 <strerror> <== NOT EXECUTED
201fdf4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201fdf8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201fdfc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201fe00: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
201fe04: 40 00 12 aa call 20248ac <printf> <== NOT EXECUTED
201fe08: 90 12 20 40 or %o0, 0x40, %o0 ! 2037040 <CSWTCH.2+0x132c> <== NOT EXECUTED
201fe0c: 30 bf ff cf b,a 201fd48 <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
201fe10: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201fe14: 40 00 12 a6 call 20248ac <printf> <== NOT EXECUTED
201fe18: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 2036dc0 <CSWTCH.2+0x10ac><== NOT EXECUTED
201fe1c: 30 bf ff 7d b,a 201fc10 <rtems_rfs_fs_open+0x1c> <== NOT EXECUTED
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
201fe20: 40 00 13 3b call 2024b0c <puts> <== NOT EXECUTED
201fe24: 90 12 22 70 or %o0, 0x270, %o0 <== NOT EXECUTED
201fe28: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201fe2c: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201fe30: 7f ff f3 e5 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201fe34: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
201fe38: 30 bf ff e4 b,a 201fdc8 <rtems_rfs_fs_open+0x1d4> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
201fe3c: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
201fe40: c4 0f 60 0f ldub [ %i5 + 0xf ], %g2
201fe44: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
201fe48: 87 28 e0 10 sll %g3, 0x10, %g3
201fe4c: 83 28 60 08 sll %g1, 8, %g1
201fe50: 97 2a e0 18 sll %o3, 0x18, %o3
201fe54: 96 12 c0 03 or %o3, %g3, %o3
201fe58: 96 12 c0 02 or %o3, %g2, %o3
201fe5c: 96 12 c0 01 or %o3, %g1, %o3
201fe60: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
201fe64: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
201fe68: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
201fe6c: c4 0f 60 0b ldub [ %i5 + 0xb ], %g2
201fe70: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
201fe74: 87 28 e0 10 sll %g3, 0x10, %g3
201fe78: 83 28 60 08 sll %g1, 8, %g1
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
201fe7c: f2 06 e0 10 ld [ %i3 + 0x10 ], %i1
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;
201fe80: 94 10 20 00 clr %o2
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
201fe84: b5 2e a0 18 sll %i2, 0x18, %i2
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;
201fe88: 90 10 20 00 clr %o0
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
201fe8c: b4 16 80 03 or %i2, %g3, %i2
201fe90: b4 16 80 02 or %i2, %g2, %i2
201fe94: b4 16 80 01 or %i2, %g1, %i2
201fe98: f4 26 e0 08 st %i2, [ %i3 + 8 ]
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
201fe9c: 40 00 43 8f call 2030cd8 <__muldi3>
201fea0: 92 10 00 1a mov %i2, %o1
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
201fea4: d6 06 60 1c ld [ %i1 + 0x1c ], %o3
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;
201fea8: a0 10 00 09 mov %o1, %l0
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
201feac: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
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;
201feb0: b0 10 00 08 mov %o0, %i0
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
201feb4: 94 10 20 00 clr %o2
201feb8: 40 00 43 88 call 2030cd8 <__muldi3>
201febc: 90 10 20 00 clr %o0
}
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))
201fec0: 80 a6 00 08 cmp %i0, %o0
201fec4: 38 80 00 3a bgu,a 201ffac <rtems_rfs_fs_open+0x3b8> <== NEVER TAKEN
201fec8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201fecc: 02 80 00 35 be 201ffa0 <rtems_rfs_fs_open+0x3ac> <== ALWAYS TAKEN
201fed0: 80 a4 00 09 cmp %l0, %o1
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)
201fed4: c2 0f 60 24 ldub [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
201fed8: c8 0f 60 25 ldub [ %i5 + 0x25 ], %g4
201fedc: c6 0f 60 27 ldub [ %i5 + 0x27 ], %g3
201fee0: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
201fee4: 83 28 60 18 sll %g1, 0x18, %g1
201fee8: 89 29 20 10 sll %g4, 0x10, %g4
201feec: 85 28 a0 08 sll %g2, 8, %g2
201fef0: 82 10 40 04 or %g1, %g4, %g1
201fef4: 82 10 40 03 or %g1, %g3, %g1
201fef8: 82 10 40 02 or %g1, %g2, %g1
201fefc: 80 a0 60 38 cmp %g1, 0x38
201ff00: 22 80 00 35 be,a 201ffd4 <rtems_rfs_fs_open+0x3e0> <== ALWAYS TAKEN
201ff04: c6 0f 60 13 ldub [ %i5 + 0x13 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201ff08: 90 10 20 00 clr %o0 <== NOT EXECUTED
201ff0c: 7f ff d2 ca call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201ff10: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201ff14: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ff18: 22 bf ff a9 be,a 201fdbc <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
201ff1c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
201ff20: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
201ff24: c2 0f 60 06 ldub [ %i5 + 6 ], %g1 <== NOT EXECUTED
201ff28: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
201ff2c: c4 0f 60 07 ldub [ %i5 + 7 ], %g2 <== NOT EXECUTED
201ff30: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
201ff34: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201ff38: 93 2a 60 18 sll %o1, 0x18, %o1 <== 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",
201ff3c: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
201ff40: 92 12 40 03 or %o1, %g3, %o1 <== 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",
201ff44: 94 10 20 00 clr %o2 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
201ff48: 92 12 40 02 or %o1, %g2, %o1 <== 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",
201ff4c: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
201ff50: 40 00 12 57 call 20248ac <printf> <== NOT EXECUTED
201ff54: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
201ff58: 10 bf ff 99 b 201fdbc <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
201ff5c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
if (rc > 0)
{
free (*fs);
201ff60: 7f ff a2 29 call 2008804 <free> <== NOT EXECUTED
201ff64: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201ff68: 90 10 20 00 clr %o0 <== NOT EXECUTED
201ff6c: 7f ff d2 b2 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201ff70: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201ff74: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ff78: 02 bf ff 74 be 201fd48 <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
201ff7c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
201ff80: 40 00 16 95 call 20259d4 <strerror> <== NOT EXECUTED
201ff84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ff88: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201ff8c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ff90: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201ff94: 40 00 12 46 call 20248ac <printf> <== NOT EXECUTED
201ff98: 90 12 22 08 or %o0, 0x208, %o0 ! 2036e08 <CSWTCH.2+0x10f4><== NOT EXECUTED
201ff9c: 30 bf ff 6b b,a 201fd48 <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
201ffa0: 28 bf ff ce bleu,a 201fed8 <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
201ffa4: c2 0f 60 24 ldub [ %i5 + 0x24 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201ffa8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201ffac: 7f ff d2 a2 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
201ffb0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201ffb4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ffb8: 22 bf ff 81 be,a 201fdbc <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
201ffbc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
201ffc0: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
201ffc4: 40 00 12 d2 call 2024b0c <puts> <== NOT EXECUTED
201ffc8: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 2036eb0 <CSWTCH.2+0x119c><== NOT EXECUTED
201ffcc: 10 bf ff 7c b 201fdbc <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
201ffd0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
201ffd4: c2 0f 60 10 ldub [ %i5 + 0x10 ], %g1
201ffd8: c8 0f 60 11 ldub [ %i5 + 0x11 ], %g4
201ffdc: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
201ffe0: 89 29 20 10 sll %g4, 0x10, %g4
201ffe4: 85 28 a0 08 sll %g2, 8, %g2
201ffe8: 83 28 60 18 sll %g1, 0x18, %g1
201ffec: 82 10 40 04 or %g1, %g4, %g1
201fff0: 82 10 40 03 or %g1, %g3, %g1
201fff4: 82 10 40 02 or %g1, %g2, %g1
201fff8: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
201fffc: c6 0f 60 17 ldub [ %i5 + 0x17 ], %g3
2020000: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
2020004: c8 0f 60 15 ldub [ %i5 + 0x15 ], %g4
2020008: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
202000c: 89 29 20 10 sll %g4, 0x10, %g4
2020010: 85 28 a0 08 sll %g2, 8, %g2
2020014: 83 28 60 18 sll %g1, 0x18, %g1
2020018: 82 10 40 04 or %g1, %g4, %g1
202001c: 82 10 40 03 or %g1, %g3, %g1
2020020: 82 10 40 02 or %g1, %g2, %g1
2020024: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
2020028: c6 0f 60 19 ldub [ %i5 + 0x19 ], %g3
202002c: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
2020030: c4 0f 60 1b ldub [ %i5 + 0x1b ], %g2
2020034: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
2020038: 87 28 e0 10 sll %g3, 0x10, %g3
202003c: 83 28 60 08 sll %g1, 8, %g1
2020040: b1 2e 20 18 sll %i0, 0x18, %i0
2020044: b0 16 00 03 or %i0, %g3, %i0
2020048: b0 16 00 02 or %i0, %g2, %i0
202004c: b0 16 00 01 or %i0, %g1, %i0
2020050: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
2020054: c4 0f 60 1f ldub [ %i5 + 0x1f ], %g2
2020058: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
202005c: c6 0f 60 1d ldub [ %i5 + 0x1d ], %g3
2020060: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
2020064: 87 28 e0 10 sll %g3, 0x10, %g3
2020068: 83 28 60 08 sll %g1, 8, %g1
202006c: b3 2e 60 18 sll %i1, 0x18, %i1
2020070: b2 16 40 03 or %i1, %g3, %i1
2020074: b2 16 40 02 or %i1, %g2, %i1
2020078: b2 16 40 01 or %i1, %g1, %i1
202007c: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
2020080: c4 0f 60 21 ldub [ %i5 + 0x21 ], %g2
2020084: de 0f 60 20 ldub [ %i5 + 0x20 ], %o7
2020088: c6 0f 60 22 ldub [ %i5 + 0x22 ], %g3
202008c: c8 0f 60 23 ldub [ %i5 + 0x23 ], %g4
2020090: 85 28 a0 10 sll %g2, 0x10, %g2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
2020094: 83 36 a0 02 srl %i2, 2, %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);
2020098: bb 2b e0 18 sll %o7, 0x18, %i5
202009c: 87 28 e0 08 sll %g3, 8, %g3
20200a0: ba 17 40 02 or %i5, %g2, %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;
20200a4: 85 28 60 02 sll %g1, 2, %g2
20200a8: 84 00 80 01 add %g2, %g1, %g2
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
20200ac: ba 17 40 04 or %i5, %g4, %i5
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;
20200b0: 92 10 00 01 mov %g1, %o1
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);
20200b4: ba 17 40 03 or %i5, %g3, %i5
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
20200b8: c4 26 e0 38 st %g2, [ %i3 + 0x38 ]
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;
20200bc: 90 10 00 01 mov %g1, %o0
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
20200c0: c2 26 e0 34 st %g1, [ %i3 + 0x34 ]
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;
20200c4: 7f ff 89 3a call 20025ac <.umul>
20200c8: fa 26 e0 2c st %i5, [ %i3 + 0x2c ]
20200cc: 83 2a 20 02 sll %o0, 2, %g1
20200d0: 82 00 40 08 add %g1, %o0, %g1
fs->inodes = fs->group_count * fs->group_inodes;
20200d4: 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 =
20200d8: c2 26 e0 3c st %g1, [ %i3 + 0x3c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
20200dc: 7f ff 89 34 call 20025ac <.umul>
20200e0: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
20200e4: 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;
20200e8: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
20200ec: 7f ff 89 6a call 2002694 <.udiv>
20200f0: 90 10 00 1a mov %i2, %o0
20200f4: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
20200f8: b5 2e a0 03 sll %i2, 3, %i2
20200fc: 92 07 bf cc add %fp, -52, %o1
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
2020100: 80 a6 40 1a cmp %i1, %i2
2020104: 08 80 00 10 bleu 2020144 <rtems_rfs_fs_open+0x550> <== ALWAYS TAKEN
2020108: 90 10 00 1b mov %i3, %o0
202010c: 7f ff f3 2e call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2020110: ba 10 20 05 mov 5, %i5 <== 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))
2020114: 90 10 20 00 clr %o0 <== NOT EXECUTED
2020118: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
202011c: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
2020120: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
2020124: 7f ff d2 44 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2020128: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
202012c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020130: 02 bf fe fc be 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
2020134: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
2020138: 40 00 12 75 call 2024b0c <puts> <== NOT EXECUTED
202013c: 90 12 23 38 or %o0, 0x338, %o0 ! 2036f38 <CSWTCH.2+0x1224><== NOT EXECUTED
2020140: 30 bf fe f8 b,a 201fd20 <rtems_rfs_fs_open+0x12c> <== 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);
2020144: 7f ff f3 20 call 201cdc4 <rtems_rfs_buffer_handle_release>
2020148: 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));
202014c: d2 06 e0 08 ld [ %i3 + 8 ], %o1
handle->dirty = false;
2020150: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
2020154: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
2020158: c0 27 bf d4 clr [ %fp + -44 ]
202015c: 7f ff f4 ff call 201d558 <rtems_rfs_buffer_setblksize>
2020160: 90 10 00 1b mov %i3, %o0
if (rc > 0)
2020164: ba 92 20 00 orcc %o0, 0, %i5
2020168: 04 80 00 23 ble 20201f4 <rtems_rfs_fs_open+0x600> <== ALWAYS TAKEN
202016c: 92 07 bf cc add %fp, -52, %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);
2020170: 7f ff f3 15 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2020174: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2020178: 90 10 20 00 clr %o0 <== NOT EXECUTED
202017c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
2020180: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
2020184: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
2020188: 7f ff d2 2b call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202018c: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
2020190: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020194: 02 bf fe e3 be 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
2020198: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
202019c: 40 00 16 0e call 20259d4 <strerror> <== NOT EXECUTED
20201a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20201a4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20201a8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20201ac: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
20201b0: 40 00 11 bf call 20248ac <printf> <== NOT EXECUTED
20201b4: 90 12 23 80 or %o0, 0x380, %o0 ! 2036f80 <CSWTCH.2+0x126c><== NOT EXECUTED
20201b8: 30 bf fe da b,a 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
if (!*fs)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
20201bc: 90 10 20 00 clr %o0 <== NOT EXECUTED
20201c0: 7f ff d2 1d call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20201c4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20201c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20201cc: 02 80 00 04 be 20201dc <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
20201d0: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
20201d4: 40 00 12 4e call 2024b0c <puts> <== NOT EXECUTED
20201d8: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 2036dd8 <CSWTCH.2+0x10c4><== NOT EXECUTED
errno = ENOMEM;
20201dc: 40 00 0c 23 call 2023268 <__errno> <== NOT EXECUTED
20201e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20201e4: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
20201e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20201ec: 81 c7 e0 08 ret <== NOT EXECUTED
20201f0: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
20201f4: fa 06 e0 24 ld [ %i3 + 0x24 ], %i5
20201f8: 92 10 20 50 mov 0x50, %o1
20201fc: 7f ff a0 85 call 2008410 <calloc>
2020200: 90 10 00 1d mov %i5, %o0
if (!fs->groups)
2020204: 80 a2 20 00 cmp %o0, 0
2020208: 02 80 00 97 be 2020464 <rtems_rfs_fs_open+0x870> <== NEVER TAKEN
202020c: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
/*
* 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++)
2020210: b2 10 20 00 clr %i1
2020214: 80 a7 60 00 cmp %i5, 0
2020218: 14 80 00 08 bg 2020238 <rtems_rfs_fs_open+0x644> <== ALWAYS TAKEN
202021c: b4 10 20 00 clr %i2
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
2020220: 10 80 00 35 b 20202f4 <rtems_rfs_fs_open+0x700> <== NOT EXECUTED
2020224: d0 07 00 00 ld [ %i4 ], %o0 <== 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++)
2020228: b4 06 a0 01 inc %i2
202022c: 80 a6 80 01 cmp %i2, %g1
2020230: 16 80 00 30 bge 20202f0 <rtems_rfs_fs_open+0x6fc> <== ALWAYS TAKEN
2020234: b2 06 60 50 add %i1, 0x50, %i1
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
2020238: fa 06 e0 28 ld [ %i3 + 0x28 ], %i5
202023c: 90 10 00 1a mov %i2, %o0
2020240: 7f ff 88 db call 20025ac <.umul>
2020244: 92 10 00 1d mov %i5, %o1
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
2020248: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
202024c: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
2020250: 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,
2020254: 94 10 00 1d mov %i5, %o2
2020258: 98 03 00 19 add %o4, %i1, %o4
202025c: 7f ff c9 1a call 20126c4 <rtems_rfs_group_open>
2020260: 90 10 00 1b mov %i3, %o0
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
2020264: ba 92 20 00 orcc %o0, 0, %i5
2020268: 24 bf ff f0 ble,a 2020228 <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
202026c: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
{
int g;
for (g = 0; g < group; g++)
2020270: b0 10 20 00 clr %i0 <== NOT EXECUTED
2020274: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2020278: 02 80 00 0a be 20202a0 <rtems_rfs_fs_open+0x6ac> <== NOT EXECUTED
202027c: b2 10 20 00 clr %i1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
2020280: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1 <== NOT EXECUTED
2020284: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2020288: 7f ff c9 9c call 20128f8 <rtems_rfs_group_close> <== NOT EXECUTED
202028c: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
2020290: b2 06 60 01 inc %i1 <== NOT EXECUTED
2020294: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
2020298: 12 bf ff fa bne 2020280 <rtems_rfs_fs_open+0x68c> <== NOT EXECUTED
202029c: b0 06 20 50 add %i0, 0x50, %i0 <== 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);
20202a0: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
20202a4: 7f ff f2 c8 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
20202a8: 90 10 00 1b mov %i3, %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))
20202ac: 90 10 20 00 clr %o0 <== NOT EXECUTED
20202b0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
20202b4: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
20202b8: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
20202bc: 7f ff d1 de call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20202c0: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
20202c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20202c8: 02 bf fe 96 be 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
20202cc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
20202d0: 40 00 15 c1 call 20259d4 <strerror> <== NOT EXECUTED
20202d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20202d8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20202dc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20202e0: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
20202e4: 40 00 11 72 call 20248ac <printf> <== NOT EXECUTED
20202e8: 90 12 20 00 mov %o0, %o0 ! 2037000 <CSWTCH.2+0x12ec> <== NOT EXECUTED
20202ec: 30 bf fe 8d b,a 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
20202f0: d0 07 00 00 ld [ %i4 ], %o0
20202f4: 92 10 20 01 mov 1, %o1
20202f8: 94 07 bf d8 add %fp, -40, %o2
20202fc: 7f ff cb 27 call 2012f98 <rtems_rfs_inode_open>
2020300: 96 10 20 01 mov 1, %o3
if (rc > 0)
2020304: ba 92 20 00 orcc %o0, 0, %i5
2020308: 14 80 00 45 bg 202041c <rtems_rfs_fs_open+0x828> <== NEVER TAKEN
202030c: 01 00 00 00 nop
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
2020310: d0 07 00 00 ld [ %i4 ], %o0
2020314: c2 02 00 00 ld [ %o0 ], %g1
2020318: 80 88 60 04 btst 4, %g1
202031c: 12 80 00 10 bne 202035c <rtems_rfs_fs_open+0x768>
2020320: c2 07 bf e4 ld [ %fp + -28 ], %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);
2020324: c4 08 60 03 ldub [ %g1 + 3 ], %g2
2020328: c6 08 60 02 ldub [ %g1 + 2 ], %g3
202032c: 83 28 e0 08 sll %g3, 8, %g1
2020330: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
2020334: 05 3f ff c0 sethi %hi(0xffff0000), %g2
2020338: 87 28 60 10 sll %g1, 0x10, %g3
202033c: 80 a0 c0 02 cmp %g3, %g2
2020340: 02 80 00 23 be 20203cc <rtems_rfs_fs_open+0x7d8> <== NEVER TAKEN
2020344: 05 00 00 3c sethi %hi(0xf000), %g2
2020348: 82 08 40 02 and %g1, %g2, %g1
202034c: 05 00 00 10 sethi %hi(0x4000), %g2
2020350: 80 a0 40 02 cmp %g1, %g2
2020354: 12 80 00 1e bne 20203cc <rtems_rfs_fs_open+0x7d8> <== NEVER TAKEN
2020358: 01 00 00 00 nop
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
202035c: 7f ff cb 87 call 2013178 <rtems_rfs_inode_close>
2020360: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
2020364: ba 92 20 00 orcc %o0, 0, %i5
2020368: 14 80 00 07 bg 2020384 <rtems_rfs_fs_open+0x790> <== NEVER TAKEN
202036c: 01 00 00 00 nop
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
2020370: 40 00 0b be call 2023268 <__errno>
2020374: b0 10 20 00 clr %i0 ! 0 <PROM_START>
2020378: c0 22 00 00 clr [ %o0 ]
202037c: 81 c7 e0 08 ret
2020380: 81 e8 00 00 restore
}
rc = rtems_rfs_inode_close (*fs, &inode);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
2020384: 7f ff f4 be call 201d67c <rtems_rfs_buffer_close> <== NOT EXECUTED
2020388: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
202038c: 7f ff a1 1e call 2008804 <free> <== NOT EXECUTED
2020390: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2020394: 90 10 20 00 clr %o0 <== NOT EXECUTED
2020398: 7f ff d1 a7 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202039c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20203a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20203a4: 02 bf fe 69 be 201fd48 <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
20203a8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
20203ac: 40 00 15 8a call 20259d4 <strerror> <== NOT EXECUTED
20203b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20203b4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20203b8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20203bc: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
20203c0: 40 00 11 3b call 20248ac <printf> <== NOT EXECUTED
20203c4: 90 12 20 d0 or %o0, 0xd0, %o0 ! 20370d0 <CSWTCH.2+0x13bc> <== NOT EXECUTED
20203c8: 30 bf fe 60 b,a 201fd48 <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
{
rtems_rfs_inode_close (*fs, &inode);
20203cc: 7f ff cb 6b call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
20203d0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
20203d4: 7f ff f4 aa call 201d67c <rtems_rfs_buffer_close> <== NOT EXECUTED
20203d8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
20203dc: 7f ff a1 0a call 2008804 <free> <== NOT EXECUTED
20203e0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
20203e4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20203e8: 7f ff d1 93 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20203ec: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20203f0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20203f4: 02 80 00 04 be 2020404 <rtems_rfs_fs_open+0x810> <== NOT EXECUTED
20203f8: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
20203fc: 40 00 11 c4 call 2024b0c <puts> <== NOT EXECUTED
2020400: 90 12 20 a0 or %o0, 0xa0, %o0 ! 20370a0 <CSWTCH.2+0x138c> <== NOT EXECUTED
errno = EIO;
2020404: 40 00 0b 99 call 2023268 <__errno> <== NOT EXECUTED
2020408: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202040c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2020410: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2020414: 81 c7 e0 08 ret <== NOT EXECUTED
2020418: 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);
202041c: 7f ff f4 98 call 201d67c <rtems_rfs_buffer_close> <== NOT EXECUTED
2020420: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
2020424: 7f ff a0 f8 call 2008804 <free> <== NOT EXECUTED
2020428: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
202042c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2020430: 7f ff d1 81 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2020434: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2020438: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
202043c: 02 bf fe 43 be 201fd48 <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
2020440: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
2020444: 40 00 15 64 call 20259d4 <strerror> <== NOT EXECUTED
2020448: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
202044c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020450: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020454: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020458: 40 00 11 15 call 20248ac <printf> <== NOT EXECUTED
202045c: 90 12 20 70 or %o0, 0x70, %o0 ! 2037070 <CSWTCH.2+0x135c> <== NOT EXECUTED
2020460: 30 bf fe 3a b,a 201fd48 <rtems_rfs_fs_open+0x154> <== 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);
2020464: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
2020468: 7f ff f2 57 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
202046c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2020470: 90 10 20 00 clr %o0 <== NOT EXECUTED
2020474: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
2020478: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
202047c: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
handle->buffer = NULL;
2020480: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
2020484: 7f ff d1 6c call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2020488: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
202048c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020490: 02 bf fe 24 be 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
2020494: 11 00 80 db sethi %hi(0x2036c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
2020498: 40 00 11 9d call 2024b0c <puts> <== NOT EXECUTED
202049c: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 2036fc8 <CSWTCH.2+0x12b4><== NOT EXECUTED
20204a0: 30 bf fe 20 b,a 201fd20 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
0201fba8 <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)
{
201fba8: 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;
201fbac: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
201fbb0: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
201fbb4: 94 10 20 00 clr %o2 <== NOT EXECUTED
201fbb8: 40 00 44 48 call 2030cd8 <__muldi3> <== NOT EXECUTED
201fbbc: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
201fbc0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
201fbc4: 81 c7 e0 08 ret <== NOT EXECUTED
201fbc8: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
020129a4 <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)
{
20129a4: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
20129a8: 80 a6 a0 00 cmp %i2, 0
20129ac: 22 80 00 04 be,a 20129bc <rtems_rfs_group_bitmap_alloc+0x18>
20129b0: e6 06 20 28 ld [ %i0 + 0x28 ], %l3
{
size = fs->group_inodes;
20129b4: e6 06 20 2c ld [ %i0 + 0x2c ], %l3
goal -= RTEMS_RFS_ROOT_INO;
20129b8: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
group_start = goal / size;
20129bc: 90 10 00 19 mov %i1, %o0
20129c0: 7f ff bf 35 call 2002694 <.udiv>
20129c4: 92 10 00 13 mov %l3, %o1
bit = (rtems_rfs_bitmap_bit) (goal % size);
20129c8: 92 10 00 13 mov %l3, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
20129cc: a2 10 00 08 mov %o0, %l1
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
20129d0: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
20129d4: 90 10 00 19 mov %i1, %o0
20129d8: 40 00 78 14 call 2030a28 <.urem>
20129dc: ba 10 00 11 mov %l1, %i5
offset = 0;
updown = true;
20129e0: a0 10 20 01 mov 1, %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
20129e4: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
20129e8: c0 2f bf fb clrb [ %fp + -5 ]
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
20129ec: b2 10 20 00 clr %i1
/*
* 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))
20129f0: 80 a7 60 00 cmp %i5, 0
20129f4: 06 80 00 32 bl 2012abc <rtems_rfs_group_bitmap_alloc+0x118><== NEVER TAKEN
20129f8: 80 8c 20 ff btst 0xff, %l0
20129fc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2012a00: 80 a0 40 1d cmp %g1, %i5
2012a04: 04 80 00 2e ble 2012abc <rtems_rfs_group_bitmap_alloc+0x118>
2012a08: 80 8c 20 ff btst 0xff, %l0
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
2012a0c: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
2012a10: ab 2f 60 04 sll %i5, 4, %l5
2012a14: a9 2f 60 06 sll %i5, 6, %l4
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
2012a18: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
2012a1c: 82 05 40 14 add %l5, %l4, %g1
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
2012a20: 02 80 00 46 be 2012b38 <rtems_rfs_group_bitmap_alloc+0x194>
2012a24: a4 04 80 01 add %l2, %g1, %l2
bitmap = &fs->groups[group].inode_bitmap;
2012a28: a4 04 a0 2c add %l2, 0x2c, %l2
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
2012a2c: d2 07 bf fc ld [ %fp + -4 ], %o1
2012a30: 90 10 00 12 mov %l2, %o0
2012a34: 94 07 bf fb add %fp, -5, %o2
2012a38: 40 00 23 d3 call 201b984 <rtems_rfs_bitmap_map_alloc>
2012a3c: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
2012a40: 80 a2 20 00 cmp %o0, 0
2012a44: 14 80 00 3b bg 2012b30 <rtems_rfs_group_bitmap_alloc+0x18c><== NEVER TAKEN
2012a48: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
2012a4c: c2 06 00 00 ld [ %i0 ], %g1
2012a50: 80 88 60 01 btst 1, %g1
2012a54: 22 80 00 3b be,a 2012b40 <rtems_rfs_group_bitmap_alloc+0x19c><== ALWAYS TAKEN
2012a58: d2 04 80 00 ld [ %l2 ], %o1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
2012a5c: c2 0f bf fb ldub [ %fp + -5 ], %g1 <== NOT EXECUTED
2012a60: 80 a0 60 00 cmp %g1, 0
2012a64: 12 80 00 3b bne 2012b50 <rtems_rfs_group_bitmap_alloc+0x1ac>
2012a68: 80 8c 20 ff btst 0xff, %l0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
2012a6c: 22 80 00 07 be,a 2012a88 <rtems_rfs_group_bitmap_alloc+0xe4><== NEVER TAKEN
2012a70: b2 06 60 01 inc %i1 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
2012a74: 80 a7 20 00 cmp %i4, 0
2012a78: 04 80 00 03 ble 2012a84 <rtems_rfs_group_bitmap_alloc+0xe0><== NEVER TAKEN
2012a7c: b8 10 20 01 mov 1, %i4
2012a80: b8 10 3f ff mov -1, %i4
offset++;
2012a84: b2 06 60 01 inc %i1
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
2012a88: c0 2f bf fb clrb [ %fp + -5 ]
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
2012a8c: 90 10 00 1c mov %i4, %o0
2012a90: 7f ff be c7 call 20025ac <.umul>
2012a94: 92 10 00 19 mov %i1, %o1
if (offset)
bit = direction > 0 ? 0 : size - 1;
2012a98: 82 10 20 00 clr %g1
2012a9c: 80 a7 20 00 cmp %i4, 0
2012aa0: 04 80 00 17 ble 2012afc <rtems_rfs_group_bitmap_alloc+0x158><== ALWAYS TAKEN
2012aa4: ba 02 00 11 add %o0, %l1, %i5
2012aa8: c2 27 bf fc st %g1, [ %fp + -4 ]
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
2012aac: 80 a7 60 00 cmp %i5, 0
2012ab0: 36 bf ff d4 bge,a 2012a00 <rtems_rfs_group_bitmap_alloc+0x5c>
2012ab4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
if (!updown)
2012ab8: 80 8c 20 ff btst 0xff, %l0
2012abc: 02 80 00 13 be 2012b08 <rtems_rfs_group_bitmap_alloc+0x164>
2012ac0: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
2012ac4: 04 80 00 03 ble 2012ad0 <rtems_rfs_group_bitmap_alloc+0x12c><== ALWAYS TAKEN
2012ac8: b8 10 20 01 mov 1, %i4
2012acc: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
2012ad0: c0 2f bf fb clrb [ %fp + -5 ]
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
2012ad4: 90 10 00 1c mov %i4, %o0
2012ad8: 7f ff be b5 call 20025ac <.umul>
2012adc: 92 10 00 19 mov %i1, %o1
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
updown = false;
2012ae0: a0 10 20 00 clr %l0
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
2012ae4: 80 a6 60 00 cmp %i1, 0
2012ae8: 02 bf ff c2 be 20129f0 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
2012aec: ba 02 00 11 add %o0, %l1, %i5
bit = direction > 0 ? 0 : size - 1;
2012af0: 80 a7 20 00 cmp %i4, 0
2012af4: 14 bf ff ed bg 2012aa8 <rtems_rfs_group_bitmap_alloc+0x104><== ALWAYS TAKEN
2012af8: 82 10 20 00 clr %g1
2012afc: 82 04 ff ff add %l3, -1, %g1
2012b00: 10 bf ff eb b 2012aac <rtems_rfs_group_bitmap_alloc+0x108>
2012b04: c2 27 bf fc st %g1, [ %fp + -4 ]
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
2012b08: 90 10 20 00 clr %o0
2012b0c: 40 00 07 ca call 2014a34 <rtems_rfs_trace>
2012b10: 13 00 00 80 sethi %hi(0x20000), %o1
2012b14: 80 8a 20 ff btst 0xff, %o0
2012b18: 22 80 00 06 be,a 2012b30 <rtems_rfs_group_bitmap_alloc+0x18c><== ALWAYS TAKEN
2012b1c: 90 10 20 1c mov 0x1c, %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
2012b20: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2012b24: 40 00 47 fa call 2024b0c <puts> <== NOT EXECUTED
2012b28: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 20352c8 <_CPU_Trap_slot_template+0x9d0><== NOT EXECUTED
return ENOSPC;
2012b2c: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED
}
2012b30: 81 c7 e0 08 ret
2012b34: 91 e8 00 08 restore %g0, %o0, %o0
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
2012b38: 10 bf ff bd b 2012a2c <rtems_rfs_group_bitmap_alloc+0x88>
2012b3c: a4 04 a0 08 add %l2, 8, %l2
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
if (rc > 0)
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2012b40: 40 00 28 a1 call 201cdc4 <rtems_rfs_buffer_handle_release>
2012b44: 90 10 00 18 mov %i0, %o0
if (allocated)
2012b48: 10 bf ff c6 b 2012a60 <rtems_rfs_group_bitmap_alloc+0xbc>
2012b4c: c2 0f bf fb ldub [ %fp + -5 ], %g1
{
if (inode)
2012b50: 80 a6 a0 00 cmp %i2, 0
2012b54: 32 80 00 15 bne,a 2012ba8 <rtems_rfs_group_bitmap_alloc+0x204>
2012b58: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
2012b5c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2012b60: c4 07 bf fc ld [ %fp + -4 ], %g2
2012b64: a8 05 40 14 add %l5, %l4, %l4
2012b68: c2 00 40 14 ld [ %g1 + %l4 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
2012b6c: 90 10 20 00 clr %o0
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
2012b70: 82 00 80 01 add %g2, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
2012b74: 13 00 00 80 sethi %hi(0x20000), %o1
2012b78: 40 00 07 af call 2014a34 <rtems_rfs_trace>
2012b7c: c2 26 c0 00 st %g1, [ %i3 ]
2012b80: 80 8a 20 ff btst 0xff, %o0
2012b84: 02 80 00 07 be 2012ba0 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
2012b88: 13 00 80 d4 sethi %hi(0x2035000), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
2012b8c: 92 12 62 88 or %o1, 0x288, %o1 ! 2035288 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
2012b90: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
2012b94: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2012b98: 40 00 47 45 call 20248ac <printf> <== NOT EXECUTED
2012b9c: 90 12 22 90 or %o0, 0x290, %o0 ! 2035290 <_CPU_Trap_slot_template+0x998><== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
2012ba0: 10 bf ff e4 b 2012b30 <rtems_rfs_group_bitmap_alloc+0x18c>
2012ba4: 90 10 20 00 clr %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
2012ba8: 90 10 00 1d mov %i5, %o0
2012bac: 7f ff be 80 call 20025ac <.umul>
2012bb0: fa 07 bf fc ld [ %fp + -4 ], %i5
2012bb4: ba 07 60 01 inc %i5
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
2012bb8: 13 00 00 80 sethi %hi(0x20000), %o1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
2012bbc: ba 07 40 08 add %i5, %o0, %i5
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
2012bc0: 90 10 20 00 clr %o0
2012bc4: 40 00 07 9c call 2014a34 <rtems_rfs_trace>
2012bc8: fa 26 c0 00 st %i5, [ %i3 ]
2012bcc: 80 8a 20 ff btst 0xff, %o0
2012bd0: 02 bf ff f4 be 2012ba0 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
2012bd4: 13 00 80 d4 sethi %hi(0x2035000), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
2012bd8: 10 bf ff ee b 2012b90 <rtems_rfs_group_bitmap_alloc+0x1ec><== NOT EXECUTED
2012bdc: 92 12 62 80 or %o1, 0x280, %o1 ! 2035280 <_CPU_Trap_slot_template+0x988><== NOT EXECUTED
02012be0 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
2012be0: 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))
2012be4: 90 10 20 00 clr %o0
2012be8: 13 00 00 80 sethi %hi(0x20000), %o1
2012bec: 40 00 07 92 call 2014a34 <rtems_rfs_trace>
2012bf0: ba 10 00 18 mov %i0, %i5
2012bf4: 80 8a 20 ff btst 0xff, %o0
2012bf8: 02 80 00 0b be 2012c24 <rtems_rfs_group_bitmap_free+0x44> <== ALWAYS TAKEN
2012bfc: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
2012c00: 12 80 00 3a bne 2012ce8 <rtems_rfs_group_bitmap_free+0x108><== NOT EXECUTED
2012c04: 13 00 80 d4 sethi %hi(0x2035000), %o1 <== NOT EXECUTED
2012c08: 13 00 80 d4 sethi %hi(0x2035000), %o1 <== NOT EXECUTED
2012c0c: 92 12 62 88 or %o1, 0x288, %o1 ! 2035288 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
2012c10: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2012c14: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2012c18: 40 00 47 25 call 20248ac <printf> <== NOT EXECUTED
2012c1c: 90 12 23 00 or %o0, 0x300, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
2012c20: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2012c24: 22 80 00 1a be,a 2012c8c <rtems_rfs_group_bitmap_free+0xac>
2012c28: f8 07 60 28 ld [ %i5 + 0x28 ], %i4
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
2012c2c: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
{
no -= RTEMS_RFS_ROOT_INO;
2012c30: b4 06 bf ff add %i2, -1, %i2
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
2012c34: 92 10 00 1c mov %i4, %o1
2012c38: 40 00 77 7c call 2030a28 <.urem>
2012c3c: 90 10 00 1a mov %i2, %o0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
2012c40: 92 10 00 1c mov %i4, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
2012c44: b6 10 00 08 mov %o0, %i3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
2012c48: 7f ff be 93 call 2002694 <.udiv>
2012c4c: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
2012c50: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
2012c54: 83 2a 20 04 sll %o0, 4, %g1
2012c58: 91 2a 20 06 sll %o0, 6, %o0
2012c5c: 90 00 40 08 add %g1, %o0, %o0
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2012c60: 92 10 00 1b mov %i3, %o1
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
2012c64: b8 07 00 08 add %i4, %o0, %i4
2012c68: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2012c6c: 40 00 22 b2 call 201b734 <rtems_rfs_bitmap_map_clear>
2012c70: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2012c74: d2 07 00 00 ld [ %i4 ], %o1
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2012c78: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2012c7c: 40 00 28 52 call 201cdc4 <rtems_rfs_buffer_handle_release>
2012c80: 90 10 00 1d mov %i5, %o0
return rc;
}
2012c84: 81 c7 e0 08 ret
2012c88: 81 e8 00 00 restore
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
2012c8c: b4 06 bf ff add %i2, -1, %i2
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
2012c90: 92 10 00 1c mov %i4, %o1
2012c94: 40 00 77 65 call 2030a28 <.urem>
2012c98: 90 10 00 1a mov %i2, %o0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
2012c9c: 92 10 00 1c mov %i4, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
2012ca0: b6 10 00 08 mov %o0, %i3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
2012ca4: 7f ff be 7c call 2002694 <.udiv>
2012ca8: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
2012cac: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
2012cb0: 83 2a 20 04 sll %o0, 4, %g1
2012cb4: 91 2a 20 06 sll %o0, 6, %o0
2012cb8: 90 00 40 08 add %g1, %o0, %o0
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2012cbc: 92 10 00 1b mov %i3, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
2012cc0: b8 07 00 08 add %i4, %o0, %i4
2012cc4: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2012cc8: 40 00 22 9b call 201b734 <rtems_rfs_bitmap_map_clear>
2012ccc: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2012cd0: d2 07 00 00 ld [ %i4 ], %o1
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2012cd4: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2012cd8: 40 00 28 3b call 201cdc4 <rtems_rfs_buffer_handle_release>
2012cdc: 90 10 00 1d mov %i5, %o0
return rc;
}
2012ce0: 81 c7 e0 08 ret
2012ce4: 81 e8 00 00 restore
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
2012ce8: 10 bf ff ca b 2012c10 <rtems_rfs_group_bitmap_free+0x30> <== NOT EXECUTED
2012cec: 92 12 62 80 or %o1, 0x280, %o1 <== NOT EXECUTED
02012cf0 <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)
{
2012cf0: 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))
2012cf4: 90 10 20 00 clr %o0 <== NOT EXECUTED
2012cf8: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
2012cfc: 40 00 07 4e call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2012d00: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
2012d04: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2012d08: 02 80 00 0b be 2012d34 <rtems_rfs_group_bitmap_test+0x44> <== NOT EXECUTED
2012d0c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
2012d10: 12 80 00 2f bne 2012dcc <rtems_rfs_group_bitmap_test+0xdc><== NOT EXECUTED
2012d14: 13 00 80 d4 sethi %hi(0x2035000), %o1 <== NOT EXECUTED
2012d18: 13 00 80 d4 sethi %hi(0x2035000), %o1 <== NOT EXECUTED
2012d1c: 92 12 62 88 or %o1, 0x288, %o1 ! 2035288 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
2012d20: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2012d24: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2012d28: 40 00 46 e1 call 20248ac <printf> <== NOT EXECUTED
2012d2c: 90 12 23 30 or %o0, 0x330, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
2012d30: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2012d34: 22 80 00 0b be,a 2012d60 <rtems_rfs_group_bitmap_test+0x70><== NOT EXECUTED
2012d38: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
2012d3c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2012d40: 04 80 00 06 ble 2012d58 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
2012d44: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
2012d48: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
2012d4c: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2012d50: 28 80 00 21 bleu,a 2012dd4 <rtems_rfs_group_bitmap_test+0xe4><== NOT EXECUTED
2012d54: f8 07 60 2c ld [ %i5 + 0x2c ], %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
}
2012d58: 81 c7 e0 08 ret <== NOT EXECUTED
2012d5c: 81 e8 00 00 restore <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
2012d60: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2012d64: 1a bf ff fd bcc 2012d58 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
2012d68: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
2012d6c: f8 07 60 28 ld [ %i5 + 0x28 ], %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
2012d70: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2012d74: 40 00 77 2d call 2030a28 <.urem> <== NOT EXECUTED
2012d78: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
2012d7c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
2012d80: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
2012d84: 7f ff be 44 call 2002694 <.udiv> <== NOT EXECUTED
2012d88: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
2012d8c: f8 07 60 20 ld [ %i5 + 0x20 ], %i4 <== NOT EXECUTED
2012d90: 83 2a 20 04 sll %o0, 4, %g1 <== NOT EXECUTED
2012d94: 91 2a 20 06 sll %o0, 6, %o0 <== NOT EXECUTED
2012d98: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
2012d9c: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
2012da0: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
2012da4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2012da8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2012dac: 40 00 22 85 call 201b7c0 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
2012db0: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2012db4: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
2012db8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2012dbc: 40 00 28 02 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2012dc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
2012dc4: 81 c7 e0 08 ret <== NOT EXECUTED
2012dc8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
2012dcc: 10 bf ff d5 b 2012d20 <rtems_rfs_group_bitmap_test+0x30> <== NOT EXECUTED
2012dd0: 92 12 62 80 or %o1, 0x280, %o1 <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
2012dd4: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
2012dd8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2012ddc: 40 00 77 13 call 2030a28 <.urem> <== NOT EXECUTED
2012de0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
2012de4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
2012de8: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
2012dec: 7f ff be 2a call 2002694 <.udiv> <== NOT EXECUTED
2012df0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
2012df4: f8 07 60 20 ld [ %i5 + 0x20 ], %i4 <== NOT EXECUTED
2012df8: 83 2a 20 04 sll %o0, 4, %g1 <== NOT EXECUTED
2012dfc: 91 2a 20 06 sll %o0, 6, %o0 <== NOT EXECUTED
2012e00: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
2012e04: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
2012e08: 10 bf ff e7 b 2012da4 <rtems_rfs_group_bitmap_test+0xb4> <== NOT EXECUTED
2012e0c: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
020128f8 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
20128f8: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
20128fc: 90 10 20 00 clr %o0
2012900: 13 00 00 40 sethi %hi(0x10000), %o1
2012904: 40 00 08 4c call 2014a34 <rtems_rfs_trace>
2012908: ba 10 00 18 mov %i0, %i5
201290c: 80 8a 20 ff btst 0xff, %o0
2012910: 32 80 00 17 bne,a 201296c <rtems_rfs_group_close+0x74> <== NEVER TAKEN
2012914: d2 06 40 00 ld [ %i1 ], %o1 <== 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);
2012918: 40 00 24 a3 call 201bba4 <rtems_rfs_bitmap_close>
201291c: 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);
2012920: 92 06 60 44 add %i1, 0x44, %o1
2012924: b8 10 00 08 mov %o0, %i4
2012928: 40 00 29 27 call 201cdc4 <rtems_rfs_buffer_handle_release>
201292c: 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);
2012930: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
2012934: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
2012938: c0 26 60 48 clr [ %i1 + 0x48 ]
201293c: 40 00 24 9a call 201bba4 <rtems_rfs_bitmap_close>
2012940: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
2012944: b0 92 20 00 orcc %o0, 0, %i0
2012948: 04 80 00 0d ble 201297c <rtems_rfs_group_close+0x84> <== ALWAYS TAKEN
201294c: 90 10 00 1d mov %i5, %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);
2012950: 40 00 29 1d call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2012954: 92 06 60 20 add %i1, 0x20, %o1 <== NOT EXECUTED
handle->dirty = false;
2012958: c0 2e 60 20 clrb [ %i1 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
201295c: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
2012960: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
2012964: 81 c7 e0 08 ret <== NOT EXECUTED
2012968: 81 e8 00 00 restore <== NOT EXECUTED
{
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
201296c: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2012970: 40 00 47 cf call 20248ac <printf> <== NOT EXECUTED
2012974: 90 12 22 58 or %o0, 0x258, %o0 ! 2035258 <_CPU_Trap_slot_template+0x960><== NOT EXECUTED
2012978: 30 bf ff e8 b,a 2012918 <rtems_rfs_group_close+0x20> <== NOT EXECUTED
201297c: b0 38 00 1c xnor %g0, %i4, %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);
2012980: 92 06 60 20 add %i1, 0x20, %o1
2012984: 40 00 29 10 call 201cdc4 <rtems_rfs_buffer_handle_release>
2012988: b1 3e 20 1f sra %i0, 0x1f, %i0
201298c: b0 0f 00 18 and %i4, %i0, %i0
handle->dirty = false;
2012990: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
2012994: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
2012998: 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;
}
201299c: 81 c7 e0 08 ret
20129a0: 81 e8 00 00 restore
020126c4 <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)
{
20126c4: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
20126c8: c2 06 20 04 ld [ %i0 + 4 ], %g1
20126cc: 80 a0 40 19 cmp %g1, %i1
20126d0: 08 80 00 44 bleu 20127e0 <rtems_rfs_group_open+0x11c> <== NEVER TAKEN
20126d4: ba 10 00 18 mov %i0, %i5
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
20126d8: 84 06 80 19 add %i2, %i1, %g2
20126dc: 80 a0 40 02 cmp %g1, %g2
20126e0: 28 80 00 02 bleu,a 20126e8 <rtems_rfs_group_open+0x24> <== ALWAYS TAKEN
20126e4: b4 20 40 19 sub %g1, %i1, %i2
20126e8: 80 a6 80 1b cmp %i2, %i3
20126ec: 18 80 00 25 bgu 2012780 <rtems_rfs_group_open+0xbc> <== ALWAYS TAKEN
20126f0: a2 10 00 1a mov %i2, %l1
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
20126f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20126f8: 40 00 08 cf call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20126fc: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
2012700: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2012704: 12 80 00 27 bne 20127a0 <rtems_rfs_group_open+0xdc> <== NOT EXECUTED
2012708: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
201270c: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
2012710: 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;
2012714: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
2012718: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
201271c: 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,
2012720: a0 07 20 08 add %i4, 8, %l0
2012724: b6 07 20 20 add %i4, 0x20, %i3
2012728: 90 10 00 10 mov %l0, %o0
201272c: 92 10 00 1d mov %i5, %o1
2012730: 94 10 00 1b mov %i3, %o2
2012734: 96 10 00 1a mov %i2, %o3
2012738: 40 00 25 0a call 201bb60 <rtems_rfs_bitmap_open>
201273c: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
2012740: b0 92 20 00 orcc %o0, 0, %i0
2012744: 04 80 00 37 ble 2012820 <rtems_rfs_group_open+0x15c> <== ALWAYS TAKEN
2012748: 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);
201274c: 40 00 29 9e call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2012750: 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))
2012754: 90 10 20 00 clr %o0 <== NOT EXECUTED
2012758: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
handle->dirty = false;
201275c: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
2012760: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
2012764: 40 00 08 b4 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2012768: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
201276c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2012770: 12 80 00 13 bne 20127bc <rtems_rfs_group_open+0xf8> <== NOT EXECUTED
2012774: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
2012778: 81 c7 e0 08 ret <== NOT EXECUTED
201277c: 81 e8 00 00 restore <== NOT EXECUTED
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
2012780: 90 10 20 00 clr %o0
2012784: 13 00 00 20 sethi %hi(0x8000), %o1
2012788: 40 00 08 ab call 2014a34 <rtems_rfs_trace>
201278c: a2 10 00 1b mov %i3, %l1
2012790: 80 8a 20 ff btst 0xff, %o0
2012794: 22 bf ff df be,a 2012710 <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
2012798: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
201279c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20127a0: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20127a4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20127a8: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
20127ac: 40 00 48 40 call 20248ac <printf> <== NOT EXECUTED
20127b0: 90 12 21 a0 or %o0, 0x1a0, %o0 <== NOT EXECUTED
base, size, inodes);
group->base = base;
20127b4: 10 bf ff d7 b 2012710 <rtems_rfs_group_open+0x4c> <== NOT EXECUTED
20127b8: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
20127bc: 40 00 4c 86 call 20259d4 <strerror> <== NOT EXECUTED
20127c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20127c4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20127c8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20127cc: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20127d0: 40 00 48 37 call 20248ac <printf> <== NOT EXECUTED
20127d4: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 20351d8 <_CPU_Trap_slot_template+0x8e0><== NOT EXECUTED
20127d8: 81 c7 e0 08 ret <== NOT EXECUTED
20127dc: 81 e8 00 00 restore <== NOT EXECUTED
{
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
20127e0: 90 10 20 00 clr %o0 <== NOT EXECUTED
20127e4: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
20127e8: 40 00 08 93 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20127ec: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
20127f0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20127f4: 02 80 00 3f be 20128f0 <rtems_rfs_group_open+0x22c> <== NOT EXECUTED
20127f8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
20127fc: 40 00 4c 76 call 20259d4 <strerror> <== NOT EXECUTED
2012800: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2012804: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
2012808: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201280c: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2012810: 40 00 48 27 call 20248ac <printf> <== NOT EXECUTED
2012814: 90 12 21 60 or %o0, 0x160, %o0 ! 2035160 <_CPU_Trap_slot_template+0x868><== NOT EXECUTED
2012818: 81 c7 e0 08 ret <== NOT EXECUTED
201281c: 81 e8 00 00 restore <== 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,
2012820: 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;
2012824: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
2012828: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
201282c: c0 27 20 4c clr [ %i4 + 0x4c ]
2012830: b4 07 20 44 add %i4, 0x44, %i2
2012834: 90 07 20 2c add %i4, 0x2c, %o0
2012838: 92 10 00 1d mov %i5, %o1
201283c: 94 10 00 1a mov %i2, %o2
2012840: 96 10 00 11 mov %l1, %o3
2012844: 40 00 24 c7 call 201bb60 <rtems_rfs_bitmap_open>
2012848: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
201284c: b0 92 20 00 orcc %o0, 0, %i0
2012850: 04 80 00 1e ble 20128c8 <rtems_rfs_group_open+0x204> <== ALWAYS TAKEN
2012854: 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);
2012858: 40 00 29 5b call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201285c: 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);
2012860: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
handle->dirty = false;
2012864: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
2012868: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
201286c: 40 00 24 ce call 201bba4 <rtems_rfs_bitmap_close> <== NOT EXECUTED
2012870: 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);
2012874: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2012878: 40 00 29 53 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201287c: 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))
2012880: 90 10 20 00 clr %o0 <== NOT EXECUTED
2012884: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
handle->dirty = false;
2012888: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
201288c: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
2012890: 40 00 08 69 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2012894: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
2012898: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201289c: 02 80 00 15 be 20128f0 <rtems_rfs_group_open+0x22c> <== NOT EXECUTED
20128a0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
20128a4: 40 00 4c 4c call 20259d4 <strerror> <== NOT EXECUTED
20128a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20128ac: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20128b0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20128b4: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20128b8: 40 00 47 fd call 20248ac <printf> <== NOT EXECUTED
20128bc: 90 12 22 18 or %o0, 0x218, %o0 ! 2035218 <_CPU_Trap_slot_template+0x920><== NOT EXECUTED
20128c0: 81 c7 e0 08 ret <== NOT EXECUTED
20128c4: 81 e8 00 00 restore <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
20128c8: c2 07 40 00 ld [ %i5 ], %g1
20128cc: 80 88 60 01 btst 1, %g1
20128d0: 12 bf ff aa bne 2012778 <rtems_rfs_group_open+0xb4> <== NEVER TAKEN
20128d4: b0 10 20 00 clr %i0
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
20128d8: d2 07 20 08 ld [ %i4 + 8 ], %o1
20128dc: 40 00 29 3a call 201cdc4 <rtems_rfs_buffer_handle_release>
20128e0: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
20128e4: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
20128e8: 40 00 29 37 call 201cdc4 <rtems_rfs_buffer_handle_release>
20128ec: 90 10 00 1d mov %i5, %o0
}
return 0;
}
20128f0: 81 c7 e0 08 ret
20128f4: 81 e8 00 00 restore
02012e10 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
2012e10: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
2012e14: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
2012e18: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
2012e1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2012e20: 04 80 00 14 ble 2012e70 <rtems_rfs_group_usage+0x60> <== NOT EXECUTED
2012e24: 84 10 20 00 clr %g2 <== NOT EXECUTED
2012e28: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
2012e2c: da 00 60 14 ld [ %g1 + 0x14 ], %o5 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
2012e30: c8 00 60 18 ld [ %g1 + 0x18 ], %g4 <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
2012e34: c6 02 40 00 ld [ %o1 ], %g3 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
2012e38: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
2012e3c: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
2012e40: 86 20 c0 04 sub %g3, %g4, %g3 <== NOT EXECUTED
2012e44: c6 22 40 00 st %g3, [ %o1 ] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
2012e48: da 00 60 38 ld [ %g1 + 0x38 ], %o5 <== 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 +=
2012e4c: c8 00 60 3c ld [ %g1 + 0x3c ], %g4 <== NOT EXECUTED
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
2012e50: c6 02 80 00 ld [ %o2 ], %g3 <== NOT EXECUTED
2012e54: 86 03 40 03 add %o5, %g3, %g3 <== 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 +=
2012e58: 86 20 c0 04 sub %g3, %g4, %g3 <== NOT EXECUTED
2012e5c: c6 22 80 00 st %g3, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
2012e60: c6 02 20 24 ld [ %o0 + 0x24 ], %g3 <== NOT EXECUTED
2012e64: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
2012e68: 14 bf ff f1 bg 2012e2c <rtems_rfs_group_usage+0x1c> <== NOT EXECUTED
2012e6c: 82 00 60 50 add %g1, 0x50, %g1 <== 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))
2012e70: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
2012e74: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED
2012e78: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2012e7c: 38 80 00 02 bgu,a 2012e84 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
2012e80: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2012e84: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
2012e88: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
2012e8c: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
2012e90: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2012e94: 38 80 00 02 bgu,a 2012e9c <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
2012e98: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2012e9c: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
2012ea0: 81 c3 e0 08 retl <== NOT EXECUTED
2012ea4: 90 10 20 00 clr %o0 <== NOT EXECUTED
02013178 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2013178: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
201317c: 90 10 20 00 clr %o0
2013180: 40 00 06 2d call 2014a34 <rtems_rfs_trace>
2013184: 13 00 02 00 sethi %hi(0x80000), %o1
2013188: 80 8a 20 ff btst 0xff, %o0
201318c: 32 80 00 16 bne,a 20131e4 <rtems_rfs_inode_close+0x6c> <== NEVER TAKEN
2013190: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
rc = rtems_rfs_inode_unload (fs, handle, true);
2013194: 90 10 00 18 mov %i0, %o0
2013198: 92 10 00 19 mov %i1, %o1
201319c: 7f ff ff b6 call 2013074 <rtems_rfs_inode_unload>
20131a0: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
20131a4: b0 92 20 00 orcc %o0, 0, %i0
20131a8: 32 80 00 0d bne,a 20131dc <rtems_rfs_inode_close+0x64> <== NEVER TAKEN
20131ac: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
20131b0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
20131b4: 80 a0 60 00 cmp %g1, 0
20131b8: 04 80 00 08 ble 20131d8 <rtems_rfs_inode_close+0x60> <== ALWAYS TAKEN
20131bc: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
20131c0: 13 00 02 00 sethi %hi(0x80000), %o1 <== NOT EXECUTED
20131c4: 40 00 06 1c call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20131c8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
20131cc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20131d0: 32 80 00 0a bne,a 20131f8 <rtems_rfs_inode_close+0x80> <== NOT EXECUTED
20131d4: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
}
handle->ino = 0;
20131d8: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
20131dc: 81 c7 e0 08 ret
20131e0: 81 e8 00 00 restore
rtems_rfs_inode_handle* handle)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
20131e4: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
20131e8: 40 00 45 b1 call 20248ac <printf> <== NOT EXECUTED
20131ec: 90 12 20 00 mov %o0, %o0 ! 2035400 <_CPU_Trap_slot_template+0xb08><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
20131f0: 10 bf ff ea b 2013198 <rtems_rfs_inode_close+0x20> <== NOT EXECUTED
20131f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ((rc == 0) && (handle->loads > 0))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
20131f8: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
20131fc: 40 00 45 ac call 20248ac <printf> <== NOT EXECUTED
2013200: 90 12 20 28 or %o0, 0x28, %o0 ! 2035428 <_CPU_Trap_slot_template+0xb30><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
2013204: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
return rc;
}
2013208: 81 c7 e0 08 ret <== NOT EXECUTED
201320c: 81 e8 00 00 restore <== NOT EXECUTED
020134e0 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
20134e0: 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))
20134e4: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
20134e8: e4 17 a0 5e lduh [ %fp + 0x5e ], %l2
20134ec: e2 17 a0 62 lduh [ %fp + 0x62 ], %l1
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
20134f0: 13 00 10 00 sethi %hi(0x400000), %o1
20134f4: 40 00 05 50 call 2014a34 <rtems_rfs_trace>
20134f8: a6 0f 30 00 and %i4, -4096, %l3
20134fc: 80 8a 20 ff btst 0xff, %o0
2013500: 22 80 00 28 be,a 20135a0 <rtems_rfs_inode_create+0xc0> <== ALWAYS TAKEN
2013504: a7 2c e0 10 sll %l3, 0x10, %l3
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
2013508: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
201350c: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
2013510: 02 80 00 4f be 201364c <rtems_rfs_inode_create+0x16c> <== NOT EXECUTED
2013514: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
2013518: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
201351c: 02 80 00 52 be 2013664 <rtems_rfs_inode_create+0x184> <== NOT EXECUTED
2013520: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
2013524: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
2013528: 02 80 00 4c be 2013658 <rtems_rfs_inode_create+0x178> <== NOT EXECUTED
201352c: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
2013530: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
2013534: 02 80 00 4f be 2013670 <rtems_rfs_inode_create+0x190> <== NOT EXECUTED
2013538: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
201353c: 29 00 80 d5 sethi %hi(0x2035400), %l4 <== 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))
2013540: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
2013544: 02 80 00 4e be 201367c <rtems_rfs_inode_create+0x19c> <== NOT EXECUTED
2013548: a8 15 20 a0 or %l4, 0xa0, %l4 <== NOT EXECUTED
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
201354c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2013550: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2013554: 40 00 44 d6 call 20248ac <printf> <== NOT EXECUTED
2013558: 90 12 20 b0 or %o0, 0xb0, %o0 ! 20354b0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
for (c = 0; c < length; c++)
201355c: a0 10 20 00 clr %l0 <== NOT EXECUTED
2013560: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
2013564: 02 80 00 08 be 2013584 <rtems_rfs_inode_create+0xa4> <== NOT EXECUTED
2013568: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("%c", name[c]);
201356c: d0 4e 80 01 ldsb [ %i2 + %g1 ], %o0 <== NOT EXECUTED
2013570: 40 00 45 39 call 2024a54 <putchar> <== NOT EXECUTED
2013574: a0 04 20 01 inc %l0 <== 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++)
2013578: 80 a4 00 1b cmp %l0, %i3 <== NOT EXECUTED
201357c: 12 bf ff fc bne 201356c <rtems_rfs_inode_create+0x8c> <== NOT EXECUTED
2013580: 82 10 00 10 mov %l0, %g1 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
2013584: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2013588: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
201358c: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
2013590: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2013594: 40 00 44 c6 call 20248ac <printf> <== NOT EXECUTED
2013598: 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)
201359c: a7 2c e0 10 sll %l3, 0x10, %l3 <== NOT EXECUTED
20135a0: 05 00 00 18 sethi %hi(0x6000), %g2
20135a4: 83 34 e0 10 srl %l3, 0x10, %g1
20135a8: 80 a0 40 02 cmp %g1, %g2
20135ac: 02 80 00 15 be 2013600 <rtems_rfs_inode_create+0x120> <== NEVER TAKEN
20135b0: d4 07 a0 64 ld [ %fp + 0x64 ], %o2
20135b4: 08 80 00 0c bleu 20135e4 <rtems_rfs_inode_create+0x104>
20135b8: 05 00 00 08 sethi %hi(0x2000), %g2
20135bc: 05 00 00 20 sethi %hi(0x8000), %g2
20135c0: 80 a0 40 02 cmp %g1, %g2
20135c4: 02 80 00 0f be 2013600 <rtems_rfs_inode_create+0x120>
20135c8: 05 00 00 28 sethi %hi(0xa000), %g2
20135cc: 80 a0 40 02 cmp %g1, %g2
20135d0: 02 80 00 0d be 2013604 <rtems_rfs_inode_create+0x124> <== ALWAYS TAKEN
20135d4: 90 10 00 18 mov %i0, %o0
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
20135d8: a0 10 20 16 mov 0x16, %l0 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
}
20135dc: 81 c7 e0 08 ret
20135e0: 91 e8 00 10 restore %g0, %l0, %o0
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
20135e4: 80 a0 40 02 cmp %g1, %g2
20135e8: 02 80 00 05 be 20135fc <rtems_rfs_inode_create+0x11c> <== NEVER TAKEN
20135ec: 05 00 00 10 sethi %hi(0x4000), %g2
20135f0: 80 a0 40 02 cmp %g1, %g2
20135f4: 12 bf ff fa bne 20135dc <rtems_rfs_inode_create+0xfc> <== NEVER TAKEN
20135f8: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
20135fc: d4 07 a0 64 ld [ %fp + 0x64 ], %o2
2013600: 90 10 00 18 mov %i0, %o0
2013604: 7f ff fe 29 call 2012ea8 <rtems_rfs_inode_alloc>
2013608: 92 10 00 19 mov %i1, %o1
if (rc > 0)
201360c: a0 92 20 00 orcc %o0, 0, %l0
2013610: 14 bf ff f3 bg 20135dc <rtems_rfs_inode_create+0xfc>
2013614: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
2013618: 90 10 00 18 mov %i0, %o0
201361c: d2 00 40 00 ld [ %g1 ], %o1
2013620: 94 07 bf d8 add %fp, -40, %o2
2013624: 7f ff fe 5d call 2012f98 <rtems_rfs_inode_open>
2013628: 96 10 20 01 mov 1, %o3
if (rc > 0)
201362c: a0 92 20 00 orcc %o0, 0, %l0
2013630: 04 80 00 16 ble 2013688 <rtems_rfs_inode_create+0x1a8> <== ALWAYS TAKEN
2013634: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
2013638: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED
201363c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2013640: 7f ff fe 24 call 2012ed0 <rtems_rfs_inode_free> <== NOT EXECUTED
2013644: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
2013648: 30 bf ff e5 b,a 20135dc <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
201364c: 29 00 80 d5 sethi %hi(0x2035400), %l4 <== NOT EXECUTED
2013650: 10 bf ff bf b 201354c <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
2013654: a8 15 20 88 or %l4, 0x88, %l4 ! 2035488 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
2013658: 29 00 80 d4 sethi %hi(0x2035000), %l4 <== NOT EXECUTED
201365c: 10 bf ff bc b 201354c <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
2013660: a8 15 22 88 or %l4, 0x288, %l4 ! 2035288 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
2013664: 29 00 80 d5 sethi %hi(0x2035400), %l4 <== NOT EXECUTED
2013668: 10 bf ff b9 b 201354c <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
201366c: a8 15 20 90 or %l4, 0x90, %l4 ! 2035490 <_CPU_Trap_slot_template+0xb98><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
2013670: 29 00 80 d5 sethi %hi(0x2035400), %l4 <== NOT EXECUTED
2013674: 10 bf ff b6 b 201354c <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
2013678: a8 15 20 98 or %l4, 0x98, %l4 ! 2035498 <_CPU_Trap_slot_template+0xba0><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
201367c: 29 00 80 d5 sethi %hi(0x2035400), %l4 <== NOT EXECUTED
2013680: 10 bf ff b3 b 201354c <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
2013684: a8 15 20 a8 or %l4, 0xa8, %l4 ! 20354a8 <_CPU_Trap_slot_template+0xbb0><== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
2013688: 92 10 00 1d mov %i5, %o1
201368c: 94 10 00 1c mov %i4, %o2
2013690: 96 10 00 12 mov %l2, %o3
2013694: 7f ff ff 3d call 2013388 <rtems_rfs_inode_initialise>
2013698: 98 10 00 11 mov %l1, %o4
if (rc > 0)
201369c: a0 92 20 00 orcc %o0, 0, %l0
20136a0: 14 80 00 13 bg 20136ec <rtems_rfs_inode_create+0x20c> <== NEVER TAKEN
20136a4: 03 10 00 00 sethi %hi(0x40000000), %g1
/*
* 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))
20136a8: 80 a4 c0 01 cmp %l3, %g1
20136ac: 02 80 00 45 be 20137c0 <rtems_rfs_inode_create+0x2e0>
20136b0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
20136b4: 90 10 00 18 mov %i0, %o0
20136b8: 92 10 00 19 mov %i1, %o1
20136bc: 94 07 bf b0 add %fp, -80, %o2
20136c0: 7f ff fe 36 call 2012f98 <rtems_rfs_inode_open>
20136c4: 96 10 20 01 mov 1, %o3
if (rc > 0)
20136c8: a0 92 20 00 orcc %o0, 0, %l0
20136cc: 04 80 00 10 ble 201370c <rtems_rfs_inode_create+0x22c> <== ALWAYS TAKEN
20136d0: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_delete (fs, &inode);
20136d4: 7f ff fe cf call 2013210 <rtems_rfs_inode_delete> <== NOT EXECUTED
20136d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
20136dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20136e0: 7f ff fe a6 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
20136e4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20136e8: 30 bf ff bd b,a 20135dc <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
20136ec: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20136f0: 7f ff fe a2 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
20136f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
20136f8: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED
20136fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2013700: 7f ff fd f4 call 2012ed0 <rtems_rfs_inode_free> <== NOT EXECUTED
2013704: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
2013708: 30 bf ff b5 b,a 20135dc <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
201370c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
2013710: 90 10 00 18 mov %i0, %o0
2013714: d8 00 40 00 ld [ %g1 ], %o4
2013718: 92 07 bf b0 add %fp, -80, %o1
201371c: 94 10 00 1a mov %i2, %o2
2013720: 40 00 29 64 call 201dcb0 <rtems_rfs_dir_add_entry>
2013724: 96 10 00 1b mov %i3, %o3
if (rc > 0)
2013728: a0 92 20 00 orcc %o0, 0, %l0
201372c: 14 80 00 3c bg 201381c <rtems_rfs_inode_create+0x33c> <== NEVER TAKEN
2013730: 03 10 00 00 sethi %hi(0x40000000), %g1
/*
* 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))
2013734: 80 a4 c0 01 cmp %l3, %g1
2013738: 12 80 00 15 bne 201378c <rtems_rfs_inode_create+0x2ac>
201373c: 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);
2013740: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
links = 0;
2013744: 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);
2013748: c6 08 40 00 ldub [ %g1 ], %g3
201374c: c4 08 60 01 ldub [ %g1 + 1 ], %g2
2013750: 87 28 e0 08 sll %g3, 8, %g3
2013754: 84 10 c0 02 or %g3, %g2, %g2
if (links == 0xffff)
2013758: 87 28 a0 10 sll %g2, 0x10, %g3
201375c: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
2013760: 86 39 00 03 xnor %g4, %g3, %g3
2013764: 80 a0 00 03 cmp %g0, %g3
2013768: 86 60 20 00 subx %g0, 0, %g3
201376c: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
2013770: 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);
2013774: 87 30 a0 08 srl %g2, 8, %g3
2013778: c6 28 40 00 stb %g3, [ %g1 ]
201377c: c2 07 bf bc ld [ %fp + -68 ], %g1
2013780: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013784: 82 10 20 01 mov 1, %g1
2013788: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
201378c: 7f ff fe 7b call 2013178 <rtems_rfs_inode_close>
2013790: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
2013794: 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);
2013798: a0 10 00 08 mov %o0, %l0
if (rc > 0)
201379c: 80 a4 20 00 cmp %l0, 0
20137a0: 04 80 00 29 ble 2013844 <rtems_rfs_inode_create+0x364> <== ALWAYS TAKEN
20137a4: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
20137a8: 7f ff fe 9a call 2013210 <rtems_rfs_inode_delete> <== NOT EXECUTED
20137ac: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
20137b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20137b4: 7f ff fe 71 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
20137b8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20137bc: 30 bf ff 88 b,a 20135dc <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
20137c0: 90 10 00 18 mov %i0, %o0
20137c4: d8 00 40 00 ld [ %g1 ], %o4
20137c8: 92 07 bf d8 add %fp, -40, %o1
20137cc: 96 10 20 01 mov 1, %o3
20137d0: 15 00 80 ca sethi %hi(0x2032800), %o2
20137d4: 40 00 29 37 call 201dcb0 <rtems_rfs_dir_add_entry>
20137d8: 94 12 a3 f0 or %o2, 0x3f0, %o2 ! 2032bf0 <flashdisk_ops+0x1c>
if (rc == 0)
20137dc: a0 92 20 00 orcc %o0, 0, %l0
20137e0: 12 80 00 0b bne 201380c <rtems_rfs_inode_create+0x32c> <== NEVER TAKEN
20137e4: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
20137e8: 90 10 00 18 mov %i0, %o0
20137ec: 92 07 bf d8 add %fp, -40, %o1
20137f0: 96 10 20 02 mov 2, %o3
20137f4: 15 00 80 ca sethi %hi(0x2032800), %o2
20137f8: 98 10 00 19 mov %i1, %o4
20137fc: 40 00 29 2d call 201dcb0 <rtems_rfs_dir_add_entry>
2013800: 94 12 a3 f8 or %o2, 0x3f8, %o2
2013804: a0 10 00 08 mov %o0, %l0
if (rc > 0)
2013808: 80 a4 20 00 cmp %l0, 0
201380c: 04 bf ff ab ble 20136b8 <rtems_rfs_inode_create+0x1d8> <== ALWAYS TAKEN
2013810: 90 10 00 18 mov %i0, %o0
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
2013814: 10 bf ff b0 b 20136d4 <rtems_rfs_inode_create+0x1f4> <== NOT EXECUTED
2013818: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
201381c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2013820: 7f ff fe 7c call 2013210 <rtems_rfs_inode_delete> <== NOT EXECUTED
2013824: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
2013828: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201382c: 7f ff fe 53 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2013830: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
2013834: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2013838: 7f ff fe 50 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
201383c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
2013840: 30 bf ff 67 b,a 20135dc <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
2013844: 7f ff fe 4d call 2013178 <rtems_rfs_inode_close>
2013848: 01 00 00 00 nop
if (rc > 0)
201384c: a0 92 20 00 orcc %o0, 0, %l0
2013850: 14 bf ff 7b bg 201363c <rtems_rfs_inode_create+0x15c> <== NEVER TAKEN
2013854: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
2013858: 10 bf ff 61 b 20135dc <rtems_rfs_inode_create+0xfc>
201385c: a0 10 20 00 clr %l0
02013210 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2013210: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
2013214: 90 10 20 00 clr %o0
2013218: 40 00 06 07 call 2014a34 <rtems_rfs_trace>
201321c: 13 00 20 00 sethi %hi(0x800000), %o1
2013220: 80 8a 20 ff btst 0xff, %o0
2013224: 02 80 00 0b be 2013250 <rtems_rfs_inode_delete+0x40> <== ALWAYS TAKEN
2013228: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
201322c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2013230: 02 80 00 13 be 201327c <rtems_rfs_inode_delete+0x6c> <== NOT EXECUTED
2013234: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2013238: 15 00 80 d4 sethi %hi(0x2035000), %o2 <== NOT EXECUTED
201323c: 94 12 a3 60 or %o2, 0x360, %o2 ! 2035360 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
2013240: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2013244: 40 00 45 9a call 20248ac <printf> <== NOT EXECUTED
2013248: 90 12 20 58 or %o0, 0x58, %o0 ! 2035458 <_CPU_Trap_slot_template+0xb60><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
201324c: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2013250: 80 a0 60 00 cmp %g1, 0
2013254: 02 80 00 08 be 2013274 <rtems_rfs_inode_delete+0x64> <== NEVER TAKEN
2013258: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
201325c: d2 06 60 08 ld [ %i1 + 8 ], %o1
2013260: 7f ff ff 1c call 2012ed0 <rtems_rfs_inode_free>
2013264: 90 10 00 18 mov %i0, %o0
if (rc > 0)
2013268: 80 a2 20 00 cmp %o0, 0
201326c: 24 80 00 07 ble,a 2013288 <rtems_rfs_inode_delete+0x78> <== ALWAYS TAKEN
2013270: 90 10 00 18 mov %i0, %o0
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
2013274: 81 c7 e0 08 ret
2013278: 91 e8 00 08 restore %g0, %o0, %o0
rtems_rfs_inode_handle* handle)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
201327c: 15 00 80 cd sethi %hi(0x2033400), %o2 <== NOT EXECUTED
2013280: 10 bf ff f0 b 2013240 <rtems_rfs_inode_delete+0x30> <== NOT EXECUTED
2013284: 94 12 a1 18 or %o2, 0x118, %o2 ! 2033518 <__FUNCTION__.7127+0x580><== NOT EXECUTED
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
2013288: 92 10 00 19 mov %i1, %o1
201328c: 40 00 23 44 call 201bf9c <rtems_rfs_block_map_open>
2013290: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
2013294: 80 a2 20 00 cmp %o0, 0
2013298: 12 bf ff f7 bne 2013274 <rtems_rfs_inode_delete+0x64> <== NEVER TAKEN
201329c: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
20132a0: 40 00 26 56 call 201cbf8 <rtems_rfs_block_map_free_all>
20132a4: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
20132a8: 92 07 bf b0 add %fp, -80, %o1
20132ac: 40 00 23 9d call 201c120 <rtems_rfs_block_map_close>
20132b0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
20132b4: d0 06 60 0c ld [ %i1 + 0xc ], %o0
20132b8: 92 10 20 ff mov 0xff, %o1
20132bc: 40 00 44 fe call 20246b4 <memset>
20132c0: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20132c4: 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);
20132c8: 90 10 00 18 mov %i0, %o0
20132cc: 92 06 60 10 add %i1, 0x10, %o1
20132d0: 40 00 26 bd call 201cdc4 <rtems_rfs_buffer_handle_release>
20132d4: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
handle->loads = 0;
20132d8: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
20132dc: 10 bf ff e6 b 2013274 <rtems_rfs_inode_delete+0x64>
20132e0: c0 26 60 0c clr [ %i1 + 0xc ]
02012ee4 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2012ee4: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
2012ee8: 90 10 20 00 clr %o0
2012eec: 40 00 06 d2 call 2014a34 <rtems_rfs_trace>
2012ef0: 13 00 04 00 sethi %hi(0x100000), %o1
2012ef4: 80 8a 20 ff btst 0xff, %o0
2012ef8: 02 80 00 0c be 2012f28 <rtems_rfs_inode_load+0x44> <== ALWAYS TAKEN
2012efc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
2012f00: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2012f04: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2012f08: 02 80 00 11 be 2012f4c <rtems_rfs_inode_load+0x68> <== NOT EXECUTED
2012f0c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
2012f10: 17 00 80 d4 sethi %hi(0x2035000), %o3 <== NOT EXECUTED
2012f14: 96 12 e3 60 or %o3, 0x360, %o3 ! 2035360 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
2012f18: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2012f1c: 40 00 46 64 call 20248ac <printf> <== NOT EXECUTED
2012f20: 90 12 23 68 or %o0, 0x368, %o0 ! 2035368 <_CPU_Trap_slot_template+0xa70><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
2012f24: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2012f28: 80 a0 60 00 cmp %g1, 0
2012f2c: 22 80 00 0b be,a 2012f58 <rtems_rfs_inode_load+0x74>
2012f30: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
2012f34: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
2012f38: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
2012f3c: 82 00 60 01 inc %g1
2012f40: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
2012f44: 81 c7 e0 08 ret
2012f48: 81 e8 00 00 restore
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
2012f4c: 17 00 80 cd sethi %hi(0x2033400), %o3 <== NOT EXECUTED
2012f50: 10 bf ff f2 b 2012f18 <rtems_rfs_inode_load+0x34> <== NOT EXECUTED
2012f54: 96 12 e1 18 or %o3, 0x118, %o3 ! 2033518 <__FUNCTION__.7127+0x580><== NOT EXECUTED
if (!rtems_rfs_inode_is_loaded (handle))
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
2012f58: 90 10 00 18 mov %i0, %o0
2012f5c: 92 06 60 10 add %i1, 0x10, %o1
2012f60: 40 00 28 13 call 201cfac <rtems_rfs_buffer_handle_request>
2012f64: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
2012f68: b0 92 20 00 orcc %o0, 0, %i0
2012f6c: 14 bf ff f6 bg 2012f44 <rtems_rfs_inode_load+0x60> <== NEVER TAKEN
2012f70: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
2012f74: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
2012f78: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2012f7c: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
2012f80: 87 28 60 03 sll %g1, 3, %g3
2012f84: 83 28 60 06 sll %g1, 6, %g1
2012f88: 82 20 40 03 sub %g1, %g3, %g1
2012f8c: 82 00 80 01 add %g2, %g1, %g1
2012f90: 10 bf ff e9 b 2012f34 <rtems_rfs_inode_load+0x50>
2012f94: c2 26 60 0c st %g1, [ %i1 + 0xc ]
02012f98 <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)
{
2012f98: 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))
2012f9c: 90 10 20 00 clr %o0
2012fa0: 40 00 06 a5 call 2014a34 <rtems_rfs_trace>
2012fa4: 13 00 01 00 sethi %hi(0x40000), %o1
2012fa8: 80 8a 20 ff btst 0xff, %o0
2012fac: 32 80 00 2d bne,a 2013060 <rtems_rfs_inode_open+0xc8> <== NEVER TAKEN
2012fb0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
2012fb4: 80 a6 60 00 cmp %i1, 0
2012fb8: 12 80 00 04 bne 2012fc8 <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
2012fbc: 82 10 20 16 mov 0x16, %g1
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
2012fc0: 81 c7 e0 08 ret <== NOT EXECUTED
2012fc4: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
2012fc8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
2012fcc: ba 06 7f ff add %i1, -1, %i5
2012fd0: 80 a7 40 02 cmp %i5, %g2
2012fd4: 18 bf ff fb bgu 2012fc0 <rtems_rfs_inode_open+0x28> <== NEVER TAKEN
2012fd8: 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;
2012fdc: e0 06 20 2c ld [ %i0 + 0x2c ], %l0
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
2012fe0: 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;
2012fe4: 92 10 00 10 mov %l0, %o1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
2012fe8: 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;
2012fec: 40 00 76 8f call 2030a28 <.urem>
2012ff0: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
2012ff4: f8 06 20 30 ld [ %i0 + 0x30 ], %i4
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
2012ff8: b2 10 00 08 mov %o0, %i1
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
2012ffc: 40 00 76 8b call 2030a28 <.urem>
2013000: 92 10 00 1c mov %i4, %o1
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
2013004: 92 10 00 10 mov %l0, %o1
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
2013008: 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;
201300c: 7f ff bd a2 call 2002694 <.udiv>
2013010: 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);
2013014: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
2013018: 87 2a 20 04 sll %o0, 4, %g3
201301c: 83 2a 20 06 sll %o0, 6, %g1
2013020: 82 00 c0 01 add %g3, %g1, %g1
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
2013024: fa 00 80 01 ld [ %g2 + %g1 ], %i5
2013028: 90 10 00 19 mov %i1, %o0
201302c: ba 07 60 02 add %i5, 2, %i5
2013030: 7f ff bd 99 call 2002694 <.udiv>
2013034: 92 10 00 1c mov %i4, %o1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2013038: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
201303c: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
2013040: c0 26 a0 14 clr [ %i2 + 0x14 ]
2013044: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
2013048: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
201304c: 80 a6 e0 00 cmp %i3, 0
2013050: 02 bf ff dc be 2012fc0 <rtems_rfs_inode_open+0x28> <== NEVER TAKEN
2013054: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
2013058: 7f ff ff a3 call 2012ee4 <rtems_rfs_inode_load>
201305c: 93 e8 00 1a restore %g0, %i2, %o1
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
2013060: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
2013064: 40 00 46 12 call 20248ac <printf> <== NOT EXECUTED
2013068: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 20353a0 <_CPU_Trap_slot_template+0xaa8><== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
201306c: 10 bf ff d3 b 2012fb8 <rtems_rfs_inode_open+0x20> <== NOT EXECUTED
2013070: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
020132e4 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
20132e4: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
20132e8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
20132ec: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
20132f0: 80 a0 60 00 cmp %g1, 0
20132f4: 02 80 00 23 be 2013380 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
20132f8: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
20132fc: 40 00 55 66 call 2028894 <time>
2013300: 90 10 20 00 clr %o0
if (atime)
2013304: 80 a6 60 00 cmp %i1, 0
2013308: 02 80 00 0f be 2013344 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
201330c: 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);
2013310: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2013314: 85 32 20 18 srl %o0, 0x18, %g2
2013318: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
201331c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2013320: 85 32 20 10 srl %o0, 0x10, %g2
2013324: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
2013328: c2 07 60 0c ld [ %i5 + 0xc ], %g1
201332c: 85 32 20 08 srl %o0, 8, %g2
2013330: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
2013334: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2013338: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201333c: 82 10 20 01 mov 1, %g1
2013340: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
2013344: 02 80 00 0f be 2013380 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
2013348: 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);
201334c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2013350: 85 32 20 18 srl %o0, 0x18, %g2
2013354: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
2013358: c2 07 60 0c ld [ %i5 + 0xc ], %g1
201335c: 85 32 20 10 srl %o0, 0x10, %g2
2013360: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
2013364: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2013368: 85 32 20 08 srl %o0, 8, %g2
201336c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
2013370: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2013374: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013378: 82 10 20 01 mov 1, %g1
201337c: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
2013380: 81 c7 e0 08 ret
2013384: 81 e8 00 00 restore
02013074 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
2013074: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
2013078: 90 10 20 00 clr %o0
201307c: 40 00 06 6e call 2014a34 <rtems_rfs_trace>
2013080: 13 00 08 00 sethi %hi(0x200000), %o1
2013084: 80 8a 20 ff btst 0xff, %o0
2013088: 02 80 00 0c be 20130b8 <rtems_rfs_inode_unload+0x44> <== ALWAYS TAKEN
201308c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
2013090: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2013094: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2013098: 02 80 00 25 be 201312c <rtems_rfs_inode_unload+0xb8> <== NOT EXECUTED
201309c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
20130a0: 17 00 80 d4 sethi %hi(0x2035000), %o3 <== NOT EXECUTED
20130a4: 96 12 e3 60 or %o3, 0x360, %o3 ! 2035360 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
20130a8: 11 00 80 d4 sethi %hi(0x2035000), %o0 <== NOT EXECUTED
20130ac: 40 00 46 00 call 20248ac <printf> <== NOT EXECUTED
20130b0: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20353c8 <_CPU_Trap_slot_template+0xad0><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
20130b4: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
20130b8: 80 a0 60 00 cmp %g1, 0
20130bc: 22 80 00 0d be,a 20130f0 <rtems_rfs_inode_unload+0x7c>
20130c0: 90 10 20 00 clr %o0
{
if (handle->loads == 0)
20130c4: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
20130c8: 80 a0 a0 00 cmp %g2, 0
20130cc: 12 80 00 04 bne 20130dc <rtems_rfs_inode_unload+0x68> <== ALWAYS TAKEN
20130d0: 90 10 20 05 mov 5, %o0
handle->node = NULL;
}
}
return rc;
}
20130d4: 81 c7 e0 08 ret <== NOT EXECUTED
20130d8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
20130dc: 84 00 bf ff add %g2, -1, %g2
if (handle->loads == 0)
20130e0: 80 a0 a0 00 cmp %g2, 0
20130e4: 02 80 00 05 be 20130f8 <rtems_rfs_inode_unload+0x84>
20130e8: c4 26 60 24 st %g2, [ %i1 + 0x24 ]
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
20130ec: 90 10 20 00 clr %o0
handle->node = NULL;
}
}
return rc;
}
20130f0: 81 c7 e0 08 ret
20130f4: 91 e8 00 08 restore %g0, %o0, %o0
if (handle->loads == 0)
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
20130f8: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
20130fc: 80 a0 60 00 cmp %g1, 0
2013100: 02 80 00 06 be 2013118 <rtems_rfs_inode_unload+0xa4>
2013104: 90 10 00 18 mov %i0, %o0
2013108: 80 a6 a0 00 cmp %i2, 0
201310c: 12 80 00 0b bne 2013138 <rtems_rfs_inode_unload+0xc4> <== ALWAYS TAKEN
2013110: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
2013114: 90 10 00 18 mov %i0, %o0
2013118: 40 00 27 2b call 201cdc4 <rtems_rfs_buffer_handle_release>
201311c: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
2013120: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
2013124: 81 c7 e0 08 ret
2013128: 91 e8 00 08 restore %g0, %o0, %o0
bool update_ctime)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
201312c: 17 00 80 cd sethi %hi(0x2033400), %o3 <== NOT EXECUTED
2013130: 10 bf ff de b 20130a8 <rtems_rfs_inode_unload+0x34> <== NOT EXECUTED
2013134: 96 12 e1 18 or %o3, 0x118, %o3 ! 2033518 <__FUNCTION__.7127+0x580><== NOT EXECUTED
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
rtems_rfs_inode_set_ctime (handle, time (NULL));
2013138: 40 00 55 d7 call 2028894 <time>
201313c: 90 10 20 00 clr %o0
*/
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);
2013140: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2013144: 85 32 20 18 srl %o0, 0x18, %g2
2013148: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
201314c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2013150: 85 32 20 10 srl %o0, 0x10, %g2
2013154: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
2013158: c2 06 60 0c ld [ %i1 + 0xc ], %g1
201315c: 85 32 20 08 srl %o0, 8, %g2
2013160: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
2013164: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2013168: d0 28 60 1b stb %o0, [ %g1 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201316c: 82 10 20 01 mov 1, %g1
2013170: 10 bf ff e9 b 2013114 <rtems_rfs_inode_unload+0xa0>
2013174: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
02020524 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
2020524: 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))
2020528: 90 10 20 00 clr %o0
202052c: 13 00 40 00 sethi %hi(0x1000000), %o1
2020530: 7f ff d1 41 call 2014a34 <rtems_rfs_trace>
2020534: a2 10 00 18 mov %i0, %l1
2020538: 80 8a 20 ff btst 0xff, %o0
202053c: 12 80 00 52 bne 2020684 <rtems_rfs_link+0x160> <== NEVER TAKEN
2020540: 92 10 00 1b mov %i3, %o1
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
2020544: 90 10 00 11 mov %l1, %o0
2020548: 92 10 00 1c mov %i4, %o1
202054c: 94 07 bf d8 add %fp, -40, %o2
2020550: 7f ff ca 92 call 2012f98 <rtems_rfs_inode_open>
2020554: 96 10 20 01 mov 1, %o3
if (rc)
2020558: b0 92 20 00 orcc %o0, 0, %i0
202055c: 12 80 00 3d bne 2020650 <rtems_rfs_link+0x12c> <== NEVER TAKEN
2020560: 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)))
2020564: 12 80 00 0b bne 2020590 <rtems_rfs_link+0x6c> <== NEVER TAKEN
2020568: 90 10 00 11 mov %l1, %o0
202056c: c2 07 bf e4 ld [ %fp + -28 ], %g1
2020570: c4 08 60 02 ldub [ %g1 + 2 ], %g2
2020574: 03 00 00 3c sethi %hi(0xf000), %g1
2020578: 85 28 a0 08 sll %g2, 8, %g2
202057c: 84 08 80 01 and %g2, %g1, %g2
2020580: 03 00 00 10 sethi %hi(0x4000), %g1
2020584: 80 a0 80 01 cmp %g2, %g1
2020588: 02 80 00 55 be 20206dc <rtems_rfs_link+0x1b8> <== NEVER TAKEN
202058c: b0 10 20 86 mov 0x86, %i0
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
2020590: 92 10 00 1b mov %i3, %o1
2020594: 94 07 bf b0 add %fp, -80, %o2
2020598: 7f ff ca 80 call 2012f98 <rtems_rfs_inode_open>
202059c: 96 10 20 01 mov 1, %o3
20205a0: b0 10 00 08 mov %o0, %i0
if (rc)
20205a4: 80 a6 20 00 cmp %i0, 0
20205a8: 12 80 00 27 bne 2020644 <rtems_rfs_link+0x120> <== NEVER TAKEN
20205ac: 90 10 00 11 mov %l1, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
20205b0: 92 07 bf b0 add %fp, -80, %o1
20205b4: 94 10 00 19 mov %i1, %o2
20205b8: 96 10 00 1a mov %i2, %o3
20205bc: 7f ff f5 bd call 201dcb0 <rtems_rfs_dir_add_entry>
20205c0: 98 10 00 1c mov %i4, %o4
if (rc > 0)
20205c4: b0 92 20 00 orcc %o0, 0, %i0
20205c8: 14 80 00 42 bg 20206d0 <rtems_rfs_link+0x1ac> <== NEVER TAKEN
20205cc: c2 07 bf e4 ld [ %fp + -28 ], %g1
*/
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);
20205d0: c6 08 60 01 ldub [ %g1 + 1 ], %g3
20205d4: c4 08 40 00 ldub [ %g1 ], %g2
20205d8: 85 28 a0 08 sll %g2, 8, %g2
20205dc: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
20205e0: 07 3f ff c0 sethi %hi(0xffff0000), %g3
20205e4: 89 28 a0 10 sll %g2, 0x10, %g4
20205e8: 80 a1 00 03 cmp %g4, %g3
20205ec: 22 80 00 40 be,a 20206ec <rtems_rfs_link+0x1c8> <== NEVER TAKEN
20205f0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
20205f4: 84 00 a0 01 inc %g2
20205f8: 87 28 a0 10 sll %g2, 0x10, %g3
20205fc: 87 30 e0 18 srl %g3, 0x18, %g3
* @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);
2020600: c6 28 40 00 stb %g3, [ %g1 ]
2020604: c2 07 bf e4 ld [ %fp + -28 ], %g1
}
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);
2020608: 92 10 20 01 mov 1, %o1
202060c: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2020610: 82 10 20 01 mov 1, %g1
2020614: 90 07 bf b0 add %fp, -80, %o0
2020618: c2 2f bf e8 stb %g1, [ %fp + -24 ]
202061c: 7f ff cb 32 call 20132e4 <rtems_rfs_inode_time_stamp_now>
2020620: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
2020624: 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);
2020628: b0 10 00 08 mov %o0, %i0
if (rc > 0)
202062c: 80 a6 20 00 cmp %i0, 0
2020630: 04 80 00 0a ble 2020658 <rtems_rfs_link+0x134> <== ALWAYS TAKEN
2020634: 90 10 00 11 mov %l1, %o0
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
2020638: 7f ff ca d0 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
202063c: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
2020640: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2020644: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2020648: 7f ff ca cc call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
202064c: 01 00 00 00 nop <== NOT EXECUTED
2020650: 81 c7 e0 08 ret <== NOT EXECUTED
2020654: 81 e8 00 00 restore <== 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);
2020658: 7f ff ca c8 call 2013178 <rtems_rfs_inode_close>
202065c: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
2020660: 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);
2020664: b0 10 00 08 mov %o0, %i0
if (rc > 0)
2020668: 80 a6 20 00 cmp %i0, 0
202066c: 14 bf ff f7 bg 2020648 <rtems_rfs_link+0x124> <== NEVER TAKEN
2020670: 90 10 00 11 mov %l1, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
2020674: 7f ff ca c1 call 2013178 <rtems_rfs_inode_close>
2020678: 01 00 00 00 nop
return rc;
}
202067c: 81 c7 e0 08 ret
2020680: 91 e8 00 08 restore %g0, %o0, %o0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
2020684: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020688: 40 00 10 89 call 20248ac <printf> <== NOT EXECUTED
202068c: 90 12 21 18 or %o0, 0x118, %o0 ! 2037118 <CSWTCH.2+0x1404><== NOT EXECUTED
2020690: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
2020694: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2020698: 04 80 00 08 ble 20206b8 <rtems_rfs_link+0x194> <== NOT EXECUTED
202069c: b0 06 40 1a add %i1, %i2, %i0 <== NOT EXECUTED
printf ("%c", name[c]);
20206a0: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
20206a4: 40 00 10 ec call 2024a54 <putchar> <== NOT EXECUTED
20206a8: 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++)
20206ac: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED
20206b0: 32 bf ff fd bne,a 20206a4 <rtems_rfs_link+0x180> <== NOT EXECUTED
20206b4: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
20206b8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20206bc: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
20206c0: 40 00 10 7b call 20248ac <printf> <== NOT EXECUTED
20206c4: 90 12 21 40 or %o0, 0x140, %o0 ! 2037140 <CSWTCH.2+0x142c><== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
20206c8: 10 bf ff a0 b 2020548 <rtems_rfs_link+0x24> <== NOT EXECUTED
20206cc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
20206d0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
20206d4: 10 bf ff d9 b 2020638 <rtems_rfs_link+0x114> <== NOT EXECUTED
20206d8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
20206dc: 7f ff ca a7 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
20206e0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20206e4: 81 c7 e0 08 ret <== NOT EXECUTED
20206e8: 81 e8 00 00 restore <== 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)
20206ec: 10 bf ff c5 b 2020600 <rtems_rfs_link+0xdc> <== NOT EXECUTED
20206f0: 86 10 20 00 clr %g3 <== NOT EXECUTED
02020f58 <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
2020f58: 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'),
2020f5c: 92 10 20 01 mov 1, %o1
2020f60: 98 10 00 18 mov %i0, %o4
2020f64: 11 14 91 94 sethi %hi(0x52465000), %o0
2020f68: 94 10 20 54 mov 0x54, %o2
2020f6c: 90 12 23 6d or %o0, 0x36d, %o0
2020f70: 96 10 20 00 clr %o3
2020f74: 7f ff b1 16 call 200d3cc <rtems_semaphore_create>
2020f78: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
2020f7c: 80 a2 20 00 cmp %o0, 0
2020f80: 02 80 00 0f be 2020fbc <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
2020f84: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2020f88: 90 10 20 00 clr %o0 <== NOT EXECUTED
2020f8c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2020f90: 7f ff ce a9 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2020f94: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2020f98: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020f9c: 02 80 00 08 be 2020fbc <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
2020fa0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
2020fa4: 7f ff 9d 7e call 200859c <rtems_status_text> <== NOT EXECUTED
2020fa8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020fac: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2020fb0: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020fb4: 40 00 0e 3e call 20248ac <printf> <== NOT EXECUTED
2020fb8: 90 12 23 70 or %o0, 0x370, %o0 ! 2037370 <CSWTCH.2+0x165c><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
2020fbc: 81 c7 e0 08 ret
2020fc0: 81 e8 00 00 restore
02020fc4 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
2020fc4: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
2020fc8: d0 06 00 00 ld [ %i0 ], %o0
2020fcc: 7f ff b1 71 call 200d590 <rtems_semaphore_delete>
2020fd0: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2020fd4: ba 92 20 00 orcc %o0, 0, %i5
2020fd8: 02 80 00 0e be 2021010 <rtems_rfs_mutex_destroy+0x4c> <== ALWAYS TAKEN
2020fdc: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2020fe0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2020fe4: 7f ff ce 94 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2020fe8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2020fec: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020ff0: 02 80 00 08 be 2021010 <rtems_rfs_mutex_destroy+0x4c> <== NOT EXECUTED
2020ff4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
2020ff8: 7f ff 9d 69 call 200859c <rtems_status_text> <== NOT EXECUTED
2020ffc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021000: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021004: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2021008: 40 00 0e 29 call 20248ac <printf> <== NOT EXECUTED
202100c: 90 12 23 98 or %o0, 0x398, %o0 ! 2037398 <CSWTCH.2+0x1684><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
2021010: 81 c7 e0 08 ret
2021014: 81 e8 00 00 restore
0201cc08 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
201cc08: 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))
201cc0c: 90 10 20 00 clr %o0
201cc10: 92 10 20 80 mov 0x80, %o1
201cc14: 7f ff df 88 call 2014a34 <rtems_rfs_trace>
201cc18: ba 10 00 18 mov %i0, %i5
201cc1c: 80 8a 20 ff btst 0xff, %o0
201cc20: 32 80 00 1c bne,a 201cc90 <rtems_rfs_release_chain+0x88> <== NEVER TAKEN
201cc24: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
201cc28: b0 10 20 00 clr %i0
201cc2c: b8 07 60 04 add %i5, 4, %i4
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))
201cc30: c2 07 40 00 ld [ %i5 ], %g1
201cc34: 80 a0 40 1c cmp %g1, %i4
201cc38: 02 80 00 14 be 201cc88 <rtems_rfs_release_chain+0x80>
201cc3c: 90 10 00 1d mov %i5, %o0
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
201cc40: 7f ff c5 79 call 200e224 <_Chain_Get>
201cc44: 01 00 00 00 nop
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
201cc48: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
201cc4c: 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)--;
201cc50: 82 00 7f ff add %g1, -1, %g1
201cc54: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
201cc58: 40 00 18 67 call 2022df4 <rtems_rfs_buffer_bdbuf_release>
201cc5c: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
201cc60: 80 a2 20 00 cmp %o0, 0
201cc64: 04 bf ff f4 ble 201cc34 <rtems_rfs_release_chain+0x2c> <== ALWAYS TAKEN
201cc68: c2 07 40 00 ld [ %i5 ], %g1
201cc6c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201cc70: 12 bf ff f1 bne 201cc34 <rtems_rfs_release_chain+0x2c> <== NOT EXECUTED
201cc74: 01 00 00 00 nop <== NOT EXECUTED
201cc78: 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))
201cc7c: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
201cc80: 12 bf ff f0 bne 201cc40 <rtems_rfs_release_chain+0x38> <== NOT EXECUTED
201cc84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
201cc88: 81 c7 e0 08 ret
201cc8c: 81 e8 00 00 restore
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
201cc90: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201cc94: 40 00 1f 06 call 20248ac <printf> <== NOT EXECUTED
201cc98: 90 12 22 20 or %o0, 0x220, %o0 ! 2035e20 <CSWTCH.2+0x10c> <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
201cc9c: 10 bf ff e4 b 201cc2c <rtems_rfs_release_chain+0x24> <== NOT EXECUTED
201cca0: b0 10 20 00 clr %i0 <== NOT EXECUTED
02013c60 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
2013c60: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013c64: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2013c68: 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);
2013c6c: f8 00 60 08 ld [ %g1 + 8 ], %i4
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);
2013c70: 94 07 bf d8 add %fp, -40, %o2
2013c74: 90 10 00 1c mov %i4, %o0
2013c78: 7f ff fc c8 call 2012f98 <rtems_rfs_inode_open>
2013c7c: 96 10 20 01 mov 1, %o3
if (rc > 0)
2013c80: ba 92 20 00 orcc %o0, 0, %i5
2013c84: 04 80 00 07 ble 2013ca0 <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
2013c88: 01 00 00 00 nop
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
2013c8c: 40 00 3d 77 call 2023268 <__errno> <== NOT EXECUTED
2013c90: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2013c94: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2013c98: 81 c7 e0 08 ret <== NOT EXECUTED
2013c9c: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
2013ca0: 40 00 12 2b call 201854c <geteuid>
2013ca4: 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;
2013ca8: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
2013cac: 91 2a 20 10 sll %o0, 0x10, %o0
2013cb0: c4 08 60 06 ldub [ %g1 + 6 ], %g2
2013cb4: c6 08 60 07 ldub [ %g1 + 7 ], %g3
2013cb8: 85 28 a0 08 sll %g2, 8, %g2
2013cbc: 84 10 80 03 or %g2, %g3, %g2
2013cc0: 85 28 a0 10 sll %g2, 0x10, %g2
2013cc4: 80 a0 80 08 cmp %g2, %o0
2013cc8: 02 80 00 05 be 2013cdc <rtems_rfs_rtems_chown+0x7c> <== ALWAYS TAKEN
2013ccc: 89 32 20 10 srl %o0, 0x10, %g4
2013cd0: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
2013cd4: 12 80 00 19 bne 2013d38 <rtems_rfs_rtems_chown+0xd8> <== NOT EXECUTED
2013cd8: 92 07 bf d8 add %fp, -40, %o1 <== 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);
2013cdc: b5 2e a0 10 sll %i2, 0x10, %i2
2013ce0: b4 16 80 19 or %i2, %i1, %i2
2013ce4: 85 36 a0 18 srl %i2, 0x18, %g2
2013ce8: c4 28 60 04 stb %g2, [ %g1 + 4 ]
2013cec: c2 07 bf e4 ld [ %fp + -28 ], %g1
2013cf0: 85 36 a0 10 srl %i2, 0x10, %g2
2013cf4: c4 28 60 05 stb %g2, [ %g1 + 5 ]
2013cf8: c2 07 bf e4 ld [ %fp + -28 ], %g1
2013cfc: b5 36 a0 08 srl %i2, 8, %i2
2013d00: f4 28 60 06 stb %i2, [ %g1 + 6 ]
2013d04: 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);
2013d08: 90 10 00 1c mov %i4, %o0
2013d0c: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013d10: 82 10 20 01 mov 1, %g1
2013d14: 92 07 bf d8 add %fp, -40, %o1
2013d18: c2 2f bf e8 stb %g1, [ %fp + -24 ]
2013d1c: 7f ff fd 17 call 2013178 <rtems_rfs_inode_close>
2013d20: b0 10 20 00 clr %i0
if (rc)
2013d24: 80 a2 20 00 cmp %o0, 0
2013d28: 12 bf ff d9 bne 2013c8c <rtems_rfs_rtems_chown+0x2c> <== NEVER TAKEN
2013d2c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
}
return 0;
}
2013d30: 81 c7 e0 08 ret
2013d34: 81 e8 00 00 restore
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
{
rtems_rfs_inode_close (fs, &inode);
2013d38: 7f ff fd 10 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2013d3c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
2013d40: 40 00 3d 4a call 2023268 <__errno> <== NOT EXECUTED
2013d44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013d48: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2013d4c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013d50: 81 c7 e0 08 ret <== NOT EXECUTED
2013d54: 81 e8 00 00 restore <== NOT EXECUTED
0202105c <rtems_rfs_rtems_device_close>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_close (iop, major, minor);
202105c: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
2021060: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
2021064: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2021068: 40 00 05 03 call 2022474 <rtems_deviceio_close> <== NOT EXECUTED
202106c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02021018 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
2021018: 81 c3 e0 08 retl <== NOT EXECUTED
202101c: 90 10 20 00 clr %o0 <== NOT EXECUTED
02021020 <rtems_rfs_rtems_device_ioctl>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_control (iop, command, buffer, major, minor);
2021020: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
2021024: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
2021028: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
202102c: 40 00 05 54 call 202257c <rtems_deviceio_control> <== NOT EXECUTED
2021030: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02021070 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
2021070: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
2021074: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
2021078: e0 06 20 1c ld [ %i0 + 0x1c ], %l0 <== NOT EXECUTED
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
202107c: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2021080: 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
};
2021084: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
2021088: 94 10 20 00 clr %o2 <== NOT EXECUTED
202108c: 7f ff b1 78 call 200d66c <rtems_semaphore_obtain> <== NOT EXECUTED
2021090: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2021094: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2021098: 12 80 00 17 bne 20210f4 <rtems_rfs_rtems_device_open+0x84><== NOT EXECUTED
202109c: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20210a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20210a4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20210a8: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
20210ac: 7f ff c7 bb call 2012f98 <rtems_rfs_inode_open> <== NOT EXECUTED
20210b0: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
20210b4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20210b8: 04 80 00 23 ble 2021144 <rtems_rfs_rtems_device_open+0xd4><== NOT EXECUTED
20210bc: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== 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);
20210c0: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
20210c4: 7f ff f1 04 call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
20210c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
20210cc: 7f ff b1 b7 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
20210d0: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20210d4: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
20210d8: 12 80 00 4c bne 2021208 <rtems_rfs_rtems_device_open+0x198><== NOT EXECUTED
20210dc: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
20210e0: 40 00 08 62 call 2023268 <__errno> <== NOT EXECUTED
20210e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20210e8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20210ec: 81 c7 e0 08 ret <== NOT EXECUTED
20210f0: 81 e8 00 00 restore <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20210f4: 7f ff ce 50 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20210f8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20210fc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021100: 22 bf ff e9 be,a 20210a4 <rtems_rfs_rtems_device_open+0x34><== NOT EXECUTED
2021104: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021108: 7f ff 9d 25 call 200859c <rtems_status_text> <== NOT EXECUTED
202110c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2021110: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021114: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021118: 40 00 0d e5 call 20248ac <printf> <== NOT EXECUTED
202111c: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2021120: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021124: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2021128: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
202112c: 7f ff c7 9b call 2012f98 <rtems_rfs_inode_open> <== NOT EXECUTED
2021130: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2021134: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2021138: 34 bf ff e3 bg,a 20210c4 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
202113c: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
2021140: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
rc = rtems_rfs_inode_close (fs, &inode);
2021144: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021148: ec 08 60 1c ldub [ %g1 + 0x1c ], %l6 <== NOT EXECUTED
202114c: ea 08 60 1d ldub [ %g1 + 0x1d ], %l5 <== NOT EXECUTED
2021150: e6 08 60 1e ldub [ %g1 + 0x1e ], %l3 <== NOT EXECUTED
2021154: e8 08 60 1f ldub [ %g1 + 0x1f ], %l4 <== NOT EXECUTED
2021158: e4 08 60 20 ldub [ %g1 + 0x20 ], %l2 <== NOT EXECUTED
202115c: e2 08 60 21 ldub [ %g1 + 0x21 ], %l1 <== NOT EXECUTED
2021160: e0 08 60 22 ldub [ %g1 + 0x22 ], %l0 <== NOT EXECUTED
2021164: ee 08 60 23 ldub [ %g1 + 0x23 ], %l7 <== NOT EXECUTED
2021168: 7f ff c8 04 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
202116c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
if (rc > 0)
2021170: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2021174: 34 bf ff d4 bg,a 20210c4 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
2021178: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== 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);
202117c: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
2021180: 7f ff f0 d5 call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
2021184: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021188: 7f ff b1 88 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
202118c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2021190: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2021194: 12 80 00 2d bne 2021248 <rtems_rfs_rtems_device_open+0x1d8><== NOT EXECUTED
2021198: 90 10 20 00 clr %o0 <== NOT EXECUTED
202119c: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
20211a0: a8 0d 20 ff and %l4, 0xff, %l4 <== NOT EXECUTED
20211a4: a5 2c a0 18 sll %l2, 0x18, %l2 <== NOT EXECUTED
20211a8: ae 0d e0 ff and %l7, 0xff, %l7 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
20211ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20211b0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20211b4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20211b8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
20211bc: aa 0d 60 ff and %l5, 0xff, %l5 <== NOT EXECUTED
20211c0: a6 0c e0 ff and %l3, 0xff, %l3 <== NOT EXECUTED
20211c4: ab 2d 60 10 sll %l5, 0x10, %l5 <== NOT EXECUTED
20211c8: a7 2c e0 08 sll %l3, 8, %l3 <== NOT EXECUTED
20211cc: 9a 15 80 15 or %l6, %l5, %o5 <== NOT EXECUTED
20211d0: a2 0c 60 ff and %l1, 0xff, %l1 <== NOT EXECUTED
20211d4: 9a 13 40 14 or %o5, %l4, %o5 <== NOT EXECUTED
20211d8: a3 2c 60 10 sll %l1, 0x10, %l1 <== NOT EXECUTED
20211dc: 9a 13 40 13 or %o5, %l3, %o5 <== NOT EXECUTED
20211e0: 98 14 80 11 or %l2, %l1, %o4 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
20211e4: da 26 20 2c st %o5, [ %i0 + 0x2c ] <== NOT EXECUTED
20211e8: 98 13 00 17 or %o4, %l7, %o4 <== NOT EXECUTED
20211ec: a0 0c 20 ff and %l0, 0xff, %l0 <== NOT EXECUTED
20211f0: a1 2c 20 08 sll %l0, 8, %l0 <== NOT EXECUTED
20211f4: 98 13 00 10 or %o4, %l0, %o4 <== NOT EXECUTED
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
20211f8: 40 00 04 92 call 2022440 <rtems_deviceio_open> <== NOT EXECUTED
20211fc: d8 26 20 30 st %o4, [ %i0 + 0x30 ] <== NOT EXECUTED
}
2021200: 81 c7 e0 08 ret <== NOT EXECUTED
2021204: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021208: 7f ff ce 0b call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202120c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021210: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021214: 02 bf ff b3 be 20210e0 <rtems_rfs_rtems_device_open+0x70> <== NOT EXECUTED
2021218: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
202121c: 7f ff 9c e0 call 200859c <rtems_status_text> <== NOT EXECUTED
2021220: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021224: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021228: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
202122c: 40 00 0d a0 call 20248ac <printf> <== NOT EXECUTED
2021230: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
2021234: 40 00 08 0d call 2023268 <__errno> <== NOT EXECUTED
2021238: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202123c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2021240: 81 c7 e0 08 ret <== NOT EXECUTED
2021244: 81 e8 00 00 restore <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021248: 7f ff cd fb call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202124c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021250: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021254: 22 bf ff d3 be,a 20211a0 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
2021258: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
202125c: 7f ff 9c d0 call 200859c <rtems_status_text> <== NOT EXECUTED
2021260: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021264: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021268: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
202126c: 40 00 0d 90 call 20248ac <printf> <== NOT EXECUTED
2021270: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2021274: 10 bf ff cb b 20211a0 <rtems_rfs_rtems_device_open+0x130> <== NOT EXECUTED
2021278: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
02021048 <rtems_rfs_rtems_device_read>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_read (iop, buffer, count, major, minor);
2021048: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
202104c: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
2021050: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2021054: 40 00 05 14 call 20224a4 <rtems_deviceio_read> <== NOT EXECUTED
2021058: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02021034 <rtems_rfs_rtems_device_write>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_write (iop, buffer, count, major, minor);
2021034: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
2021038: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
202103c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2021040: 40 00 05 34 call 2022510 <rtems_deviceio_write> <== NOT EXECUTED
2021044: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02021284 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
2021284: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
2021288: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
202128c: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
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);
2021290: fa 00 60 08 ld [ %g1 + 8 ], %i5
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2021294: 92 10 20 00 clr %o1
.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
};
2021298: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
202129c: 94 10 20 00 clr %o2
20212a0: 7f ff b0 f3 call 200d66c <rtems_semaphore_obtain>
20212a4: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20212a8: b8 92 20 00 orcc %o0, 0, %i4
20212ac: 12 80 00 2d bne 2021360 <rtems_rfs_rtems_dir_open+0xdc> <== NEVER TAKEN
20212b0: 90 10 20 00 clr %o0
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20212b4: 90 10 00 1d mov %i5, %o0
20212b8: 92 10 00 1b mov %i3, %o1
20212bc: 94 07 bf d8 add %fp, -40, %o2
20212c0: 7f ff c7 36 call 2012f98 <rtems_rfs_inode_open>
20212c4: 96 10 20 01 mov 1, %o3
if (rc)
20212c8: b8 92 20 00 orcc %o0, 0, %i4
20212cc: 32 80 00 39 bne,a 20213b0 <rtems_rfs_rtems_dir_open+0x12c><== NEVER TAKEN
20212d0: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== 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);
20212d4: c2 07 bf e4 ld [ %fp + -28 ], %g1
20212d8: c4 08 60 02 ldub [ %g1 + 2 ], %g2
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
20212dc: 03 00 00 3c sethi %hi(0xf000), %g1
20212e0: 85 28 a0 08 sll %g2, 8, %g2
20212e4: 84 08 80 01 and %g2, %g1, %g2
20212e8: 03 00 00 10 sethi %hi(0x4000), %g1
20212ec: 80 a0 80 01 cmp %g2, %g1
20212f0: 12 80 00 48 bne 2021410 <rtems_rfs_rtems_dir_open+0x18c> <== NEVER TAKEN
20212f4: 92 07 bf d8 add %fp, -40, %o1
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
rtems_rfs_inode_close (fs, &inode);
20212f8: 90 10 00 1d mov %i5, %o0
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
20212fc: c0 26 20 08 clr [ %i0 + 8 ]
rtems_rfs_inode_close (fs, &inode);
2021300: 7f ff c7 9e call 2013178 <rtems_rfs_inode_close>
2021304: c0 26 20 0c clr [ %i0 + 0xc ]
* 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);
2021308: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
202130c: 7f ff f0 72 call 201d4d4 <rtems_rfs_buffers_release>
2021310: 90 10 00 1d mov %i5, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021314: 7f ff b1 25 call 200d7a8 <rtems_semaphore_release>
2021318: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
202131c: ba 92 20 00 orcc %o0, 0, %i5
2021320: 12 80 00 04 bne 2021330 <rtems_rfs_rtems_dir_open+0xac> <== NEVER TAKEN
2021324: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
}
2021328: 81 c7 e0 08 ret
202132c: 91 e8 20 00 restore %g0, 0, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021330: 7f ff cd c1 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021334: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021338: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
202133c: 02 bf ff fb be 2021328 <rtems_rfs_rtems_dir_open+0xa4> <== NOT EXECUTED
2021340: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021344: 7f ff 9c 96 call 200859c <rtems_status_text> <== NOT EXECUTED
2021348: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
202134c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021350: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021354: 40 00 0d 56 call 20248ac <printf> <== NOT EXECUTED
2021358: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
202135c: 30 bf ff f3 b,a 2021328 <rtems_rfs_rtems_dir_open+0xa4> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021360: 7f ff cd b5 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021364: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021368: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
202136c: 22 bf ff d3 be,a 20212b8 <rtems_rfs_rtems_dir_open+0x34> <== NOT EXECUTED
2021370: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021374: 7f ff 9c 8a call 200859c <rtems_status_text> <== NOT EXECUTED
2021378: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
202137c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021380: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021384: 40 00 0d 4a call 20248ac <printf> <== NOT EXECUTED
2021388: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
202138c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021390: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2021394: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
2021398: 7f ff c7 00 call 2012f98 <rtems_rfs_inode_open> <== NOT EXECUTED
202139c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
20213a0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20213a4: 02 bf ff cd be 20212d8 <rtems_rfs_rtems_dir_open+0x54> <== NOT EXECUTED
20213a8: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== 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);
20213ac: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
20213b0: 7f ff f0 49 call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
20213b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
20213b8: 7f ff b0 fc call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
20213bc: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20213c0: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
20213c4: 12 80 00 07 bne 20213e0 <rtems_rfs_rtems_dir_open+0x15c> <== NOT EXECUTED
20213c8: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
20213cc: 40 00 07 a7 call 2023268 <__errno> <== NOT EXECUTED
20213d0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20213d4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20213d8: 81 c7 e0 08 ret <== NOT EXECUTED
20213dc: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20213e0: 7f ff cd 95 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20213e4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20213e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20213ec: 02 bf ff f8 be 20213cc <rtems_rfs_rtems_dir_open+0x148> <== NOT EXECUTED
20213f0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
20213f4: 7f ff 9c 6a call 200859c <rtems_status_text> <== NOT EXECUTED
20213f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20213fc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021400: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021404: 40 00 0d 2a call 20248ac <printf> <== NOT EXECUTED
2021408: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
202140c: 30 bf ff f0 b,a 20213cc <rtems_rfs_rtems_dir_open+0x148> <== NOT EXECUTED
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
2021410: 7f ff c7 5a call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2021414: 90 10 00 1d mov %i5, %o0 <== 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);
2021418: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
202141c: 7f ff f0 2e call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
2021420: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021424: 7f ff b0 e1 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
2021428: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
202142c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2021430: 12 80 00 08 bne 2021450 <rtems_rfs_rtems_dir_open+0x1cc> <== NOT EXECUTED
2021434: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
2021438: 40 00 07 8c call 2023268 <__errno> <== NOT EXECUTED
202143c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021440: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
2021444: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2021448: 81 c7 e0 08 ret <== NOT EXECUTED
202144c: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021450: 7f ff cd 79 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021454: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021458: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
202145c: 02 bf ff f7 be 2021438 <rtems_rfs_rtems_dir_open+0x1b4> <== NOT EXECUTED
2021460: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021464: 7f ff 9c 4e call 200859c <rtems_status_text> <== NOT EXECUTED
2021468: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
202146c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021470: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021474: 40 00 0d 0e call 20248ac <printf> <== NOT EXECUTED
2021478: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
202147c: 30 bf ff ef b,a 2021438 <rtems_rfs_rtems_dir_open+0x1b4> <== NOT EXECUTED
02021480 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
2021480: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
2021484: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
2021488: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
202148c: e0 00 60 08 ld [ %g1 + 8 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2021490: 92 10 20 00 clr %o1
.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
};
2021494: c2 04 20 80 ld [ %l0 + 0x80 ], %g1
2021498: 94 10 20 00 clr %o2
202149c: 7f ff b0 74 call 200d66c <rtems_semaphore_obtain>
20214a0: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20214a4: ba 92 20 00 orcc %o0, 0, %i5
20214a8: 12 80 00 41 bne 20215ac <rtems_rfs_rtems_dir_read+0x12c> <== NEVER TAKEN
20214ac: 90 10 20 00 clr %o0
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20214b0: 92 10 00 1c mov %i4, %o1
20214b4: 90 10 00 10 mov %l0, %o0
20214b8: 94 07 bf d8 add %fp, -40, %o2
20214bc: 7f ff c6 b7 call 2012f98 <rtems_rfs_inode_open>
20214c0: 96 10 20 01 mov 1, %o3
if (rc)
20214c4: b8 92 20 00 orcc %o0, 0, %i4
20214c8: 32 80 00 4d bne,a 20215fc <rtems_rfs_rtems_dir_read+0x17c><== NEVER TAKEN
20214cc: fa 04 20 80 ld [ %l0 + 0x80 ], %i5 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
20214d0: 90 10 00 1a mov %i2, %o0
20214d4: 92 10 21 18 mov 0x118, %o1
20214d8: 7f ff 84 6f call 2002694 <.udiv>
20214dc: ba 10 20 00 clr %i5
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
20214e0: b4 92 20 00 orcc %o0, 0, %i2
20214e4: 02 80 00 1a be 202154c <rtems_rfs_rtems_dir_read+0xcc> <== NEVER TAKEN
20214e8: 92 07 bf d8 add %fp, -40, %o1
20214ec: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
* 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,
20214f0: b6 10 20 00 clr %i3
20214f4: 10 80 00 0d b 2021528 <rtems_rfs_rtems_dir_read+0xa8>
20214f8: ba 10 20 00 clr %i5
if (rc == ENOENT)
{
rc = 0;
break;
}
if (rc > 0)
20214fc: 80 a2 20 00 cmp %o0, 0
2021500: 14 80 00 4b bg 202162c <rtems_rfs_rtems_dir_read+0x1ac> <== NEVER TAKEN
2021504: d4 07 bf d4 ld [ %fp + -44 ], %o2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
2021508: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
202150c: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
2021510: 96 80 c0 0a addcc %g3, %o2, %o3
2021514: 94 40 a0 00 addx %g2, 0, %o2
2021518: d4 3e 20 08 std %o2, [ %i0 + 8 ]
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
202151c: 80 a6 c0 1a cmp %i3, %i2
2021520: 02 80 00 0a be 2021548 <rtems_rfs_rtems_dir_read+0xc8> <== ALWAYS TAKEN
2021524: ba 07 61 18 add %i5, 0x118, %i5
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
2021528: 98 06 40 1d add %i1, %i5, %o4
202152c: 90 10 00 10 mov %l0, %o0
2021530: 92 07 bf d8 add %fp, -40, %o1
2021534: 7f ff f3 fe call 201e52c <rtems_rfs_dir_read>
2021538: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
202153c: 80 a2 20 02 cmp %o0, 2
2021540: 12 bf ff ef bne 20214fc <rtems_rfs_rtems_dir_read+0x7c>
2021544: b8 10 00 08 mov %o0, %i4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
2021548: 92 07 bf d8 add %fp, -40, %o1
202154c: 7f ff c7 0b call 2013178 <rtems_rfs_inode_close>
2021550: 90 10 00 10 mov %l0, %o0
* 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);
2021554: f8 04 20 80 ld [ %l0 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
2021558: 7f ff ef df call 201d4d4 <rtems_rfs_buffers_release>
202155c: 90 10 00 10 mov %l0, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021560: 7f ff b0 92 call 200d7a8 <rtems_semaphore_release>
2021564: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021568: b8 92 20 00 orcc %o0, 0, %i4
202156c: 12 80 00 04 bne 202157c <rtems_rfs_rtems_dir_read+0xfc> <== NEVER TAKEN
2021570: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
2021574: 81 c7 e0 08 ret
2021578: 91 e8 00 1d restore %g0, %i5, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
202157c: 7f ff cd 2e call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021580: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021584: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021588: 02 bf ff fb be 2021574 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
202158c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021590: 7f ff 9c 03 call 200859c <rtems_status_text> <== NOT EXECUTED
2021594: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2021598: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
202159c: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
20215a0: 40 00 0c c3 call 20248ac <printf> <== NOT EXECUTED
20215a4: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
20215a8: 30 bf ff f3 b,a 2021574 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20215ac: 7f ff cd 22 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20215b0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20215b4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20215b8: 02 bf ff bf be 20214b4 <rtems_rfs_rtems_dir_read+0x34> <== NOT EXECUTED
20215bc: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
20215c0: 7f ff 9b f7 call 200859c <rtems_status_text> <== NOT EXECUTED
20215c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20215c8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
20215cc: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
20215d0: 40 00 0c b7 call 20248ac <printf> <== NOT EXECUTED
20215d4: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20215d8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20215dc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20215e0: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
20215e4: 7f ff c6 6d call 2012f98 <rtems_rfs_inode_open> <== NOT EXECUTED
20215e8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
20215ec: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20215f0: 02 bf ff b9 be 20214d4 <rtems_rfs_rtems_dir_read+0x54> <== NOT EXECUTED
20215f4: 90 10 00 1a mov %i2, %o0 <== 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);
20215f8: fa 04 20 80 ld [ %l0 + 0x80 ], %i5 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
20215fc: 7f ff ef b6 call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
2021600: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021604: 7f ff b0 69 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
2021608: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
202160c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2021610: 12 80 00 16 bne 2021668 <rtems_rfs_rtems_dir_read+0x1e8> <== NOT EXECUTED
2021614: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
2021618: 40 00 07 14 call 2023268 <__errno> <== NOT EXECUTED
202161c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
2021620: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
2021624: 81 c7 e0 08 ret <== NOT EXECUTED
2021628: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
202162c: 40 00 07 0f call 2023268 <__errno> <== NOT EXECUTED
2021630: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
2021634: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
2021638: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
202163c: 7f ff c6 cf call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2021640: 90 10 00 10 mov %l0, %o0 <== 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);
2021644: f8 04 20 80 ld [ %l0 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
2021648: 7f ff ef a3 call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
202164c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021650: 7f ff b0 56 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
2021654: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2021658: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
202165c: 02 bf ff c6 be 2021574 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
2021660: 90 10 20 00 clr %o0 <== NOT EXECUTED
2021664: 30 bf ff c6 b,a 202157c <rtems_rfs_rtems_dir_read+0xfc> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021668: 7f ff cc f3 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202166c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021670: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021674: 02 bf ff e9 be 2021618 <rtems_rfs_rtems_dir_read+0x198> <== NOT EXECUTED
2021678: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
202167c: 7f ff 9b c8 call 200859c <rtems_status_text> <== NOT EXECUTED
2021680: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021684: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021688: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
202168c: 40 00 0c 88 call 20248ac <printf> <== NOT EXECUTED
2021690: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2021694: 30 bf ff e1 b,a 2021618 <rtems_rfs_rtems_dir_read+0x198> <== NOT EXECUTED
02014018 <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)
{
2014018: 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);
201401c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (currentloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2014020: 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);
2014024: fa 00 60 08 ld [ %g1 + 8 ], %i5
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (currentloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2014028: 94 07 bf d8 add %fp, -40, %o2
201402c: 90 10 00 1d mov %i5, %o0
2014030: 7f ff fb da call 2012f98 <rtems_rfs_inode_open>
2014034: 96 10 20 01 mov 1, %o3
if (rc == 0) {
2014038: b8 92 20 00 orcc %o0, 0, %i4
201403c: 12 80 00 0e bne 2014074 <rtems_rfs_rtems_eval_path+0x5c> <== NEVER TAKEN
2014040: 92 07 bf d8 add %fp, -40, %o1
rtems_filesystem_eval_path_generic (
2014044: 90 10 00 18 mov %i0, %o0
2014048: 15 00 80 d5 sethi %hi(0x2035400), %o2
201404c: 40 00 12 4d call 2018980 <rtems_filesystem_eval_path_generic>
2014050: 94 12 a2 10 or %o2, 0x210, %o2 ! 2035610 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
2014054: 90 10 00 1d mov %i5, %o0
2014058: 7f ff fc 48 call 2013178 <rtems_rfs_inode_close>
201405c: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
2014060: ba 92 20 00 orcc %o0, 0, %i5
2014064: 12 80 00 0c bne 2014094 <rtems_rfs_rtems_eval_path+0x7c> <== NEVER TAKEN
2014068: 01 00 00 00 nop
201406c: 81 c7 e0 08 ret
2014070: 81 e8 00 00 restore
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
2014074: 40 00 3c 7d call 2023268 <__errno> <== NOT EXECUTED
2014078: 01 00 00 00 nop <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
201407c: 92 10 3f ff mov -1, %o1 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
2014080: 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 (
2014084: 7f ff d7 ba call 2009f6c <rtems_filesystem_eval_path_error><== NOT EXECUTED
2014088: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201408c: 81 c7 e0 08 ret <== NOT EXECUTED
2014090: 81 e8 00 00 restore <== NOT EXECUTED
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
2014094: 40 00 3c 75 call 2023268 <__errno> <== NOT EXECUTED
2014098: 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 (
201409c: 92 10 3f ff mov -1, %o1 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
20140a0: 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 (
20140a4: 7f ff d7 b2 call 2009f6c <rtems_filesystem_eval_path_error><== NOT EXECUTED
20140a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20140ac: 81 c7 e0 08 ret <== NOT EXECUTED
20140b0: 81 e8 00 00 restore <== NOT EXECUTED
020143c0 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
20143c0: 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);
20143c4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
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(
20143c8: 90 10 00 18 mov %i0, %o0
* @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;
20143cc: c6 08 60 06 ldub [ %g1 + 6 ], %g3
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
20143d0: c4 08 60 05 ldub [ %g1 + 5 ], %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);
20143d4: c8 08 60 02 ldub [ %g1 + 2 ], %g4
* @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;
20143d8: d6 08 60 07 ldub [ %g1 + 7 ], %o3
20143dc: d4 08 60 03 ldub [ %g1 + 3 ], %o2
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
20143e0: d8 08 60 04 ldub [ %g1 + 4 ], %o4
* @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;
20143e4: 87 28 e0 08 sll %g3, 8, %g3
* @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);
20143e8: 83 29 20 08 sll %g4, 8, %g1
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
20143ec: 85 28 a0 10 sll %g2, 0x10, %g2
* @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;
20143f0: 96 10 c0 0b or %g3, %o3, %o3
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
20143f4: ba 10 00 18 mov %i0, %i5
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
20143f8: 99 2b 20 18 sll %o4, 0x18, %o4
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(
20143fc: 97 2a e0 10 sll %o3, 0x10, %o3
2014400: 98 13 00 02 or %o4, %g2, %o4
2014404: 92 10 20 01 mov 1, %o1
2014408: 94 12 80 01 or %o2, %g1, %o2
201440c: 97 32 e0 10 srl %o3, 0x10, %o3
2014410: 99 33 20 10 srl %o4, 0x10, %o4
2014414: 40 00 11 4e call 201894c <rtems_filesystem_eval_path_check_access>
2014418: 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) {
201441c: 80 8a 20 ff btst 0xff, %o0
2014420: 02 80 00 39 be 2014504 <rtems_rfs_rtems_eval_token+0x144>
2014424: 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] == '.';
2014428: 22 80 00 39 be,a 201450c <rtems_rfs_rtems_eval_token+0x14c>
201442c: c2 4e 80 00 ldsb [ %i2 ], %g1
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);
2014430: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
2014434: 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);
2014438: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
201443c: 94 10 00 1a mov %i2, %o2
2014440: 90 10 00 1c mov %i4, %o0
2014444: 96 10 00 1b mov %i3, %o3
2014448: 98 07 bf f4 add %fp, -12, %o4
201444c: 40 00 24 ca call 201d774 <rtems_rfs_dir_lookup_ino>
2014450: 9a 07 bf f8 add %fp, -8, %o5
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
2014454: 80 a2 20 00 cmp %o0, 0
2014458: 12 80 00 2b bne 2014504 <rtems_rfs_rtems_eval_token+0x144>
201445c: b0 10 20 02 mov 2, %i0
rc = rtems_rfs_inode_close (fs, inode);
2014460: 90 10 00 1c mov %i4, %o0
2014464: 7f ff fb 45 call 2013178 <rtems_rfs_inode_close>
2014468: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
201446c: 80 a2 20 00 cmp %o0, 0
2014470: 12 80 00 2d bne 2014524 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
2014474: 90 10 00 19 mov %i1, %o0
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
2014478: d2 07 bf f4 ld [ %fp + -12 ], %o1
201447c: 90 10 00 1c mov %i4, %o0
2014480: 94 10 00 19 mov %i1, %o2
2014484: 7f ff fa c5 call 2012f98 <rtems_rfs_inode_open>
2014488: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
201448c: 80 a2 20 00 cmp %o0, 0
2014490: 12 80 00 25 bne 2014524 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
2014494: 90 10 00 19 mov %i1, %o0
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)
2014498: 7f ff fd 0a call 20138c0 <rtems_rfs_rtems_node_type_by_inode>
201449c: 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);
20144a0: c2 07 60 04 ld [ %i5 + 4 ], %g1
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
== RTEMS_FILESYSTEM_SYM_LINK;
int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
20144a4: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
20144a8: 80 a0 00 01 cmp %g0, %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
20144ac: c0 27 60 0c clr [ %i5 + 0xc ]
20144b0: 82 60 3f ff subx %g0, -1, %g1
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
== RTEMS_FILESYSTEM_SYM_LINK;
int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
20144b4: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
20144b8: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
20144bc: 80 a2 20 03 cmp %o0, 3
20144c0: 12 80 00 07 bne 20144dc <rtems_rfs_rtems_eval_token+0x11c>
20144c4: 84 08 a0 01 and %g2, 1, %g2
20144c8: 80 a0 60 00 cmp %g1, 0
20144cc: 02 80 00 25 be 2014560 <rtems_rfs_rtems_eval_token+0x1a0>
20144d0: 80 88 a0 ff btst 0xff, %g2
20144d4: 12 80 00 24 bne 2014564 <rtems_rfs_rtems_eval_token+0x1a4>
20144d8: 82 10 24 00 mov 0x400, %g1
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
20144dc: 90 07 60 18 add %i5, 0x18, %o0
20144e0: 40 00 01 16 call 2014938 <rtems_rfs_rtems_set_handlers>
20144e4: 92 10 00 19 mov %i1, %o1
20144e8: 80 8a 20 ff btst 0xff, %o0
20144ec: 02 80 00 14 be 201453c <rtems_rfs_rtems_eval_token+0x17c> <== NEVER TAKEN
20144f0: c2 07 bf f4 ld [ %fp + -12 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20144f4: 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);
20144f8: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
20144fc: c2 07 bf f8 ld [ %fp + -8 ], %g1
2014500: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
2014504: 81 c7 e0 08 ret
2014508: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
201450c: 80 a0 60 2e cmp %g1, 0x2e
2014510: 32 bf ff c9 bne,a 2014434 <rtems_rfs_rtems_eval_token+0x74>
2014514: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
2014518: c0 27 60 0c clr [ %i5 + 0xc ]
201451c: 81 c7 e0 08 ret
2014520: 81 e8 00 00 restore
if (rc != 0) {
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
2014524: 92 10 20 00 clr %o1 <== NOT EXECUTED
2014528: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
201452c: 40 00 40 62 call 20246b4 <memset> <== NOT EXECUTED
2014530: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2014534: 81 c7 e0 08 ret <== NOT EXECUTED
2014538: 81 e8 00 00 restore <== NOT EXECUTED
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
201453c: 40 00 3b 4b call 2023268 <__errno> <== NOT EXECUTED
2014540: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2014544: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
2014548: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
201454c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
2014550: 7f ff d6 87 call 2009f6c <rtems_filesystem_eval_path_error><== NOT EXECUTED
2014554: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2014558: 81 c7 e0 08 ret <== NOT EXECUTED
201455c: 81 e8 00 00 restore <== NOT EXECUTED
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
2014560: 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);
2014564: f4 07 bf f4 ld [ %fp + -12 ], %i2
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
char *link = malloc(len + 1);
2014568: 90 10 24 01 mov 0x401, %o0
201456c: 7f ff d2 43 call 2008e78 <malloc>
2014570: c2 27 bf fc st %g1, [ %fp + -4 ]
if (link != NULL) {
2014574: b6 92 20 00 orcc %o0, 0, %i3
2014578: 02 80 00 14 be 20145c8 <rtems_rfs_rtems_eval_token+0x208> <== NEVER TAKEN
201457c: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
2014580: 92 10 00 1a mov %i2, %o1
2014584: 94 10 00 1b mov %i3, %o2
2014588: 96 10 24 00 mov 0x400, %o3
201458c: 40 00 32 01 call 2020d90 <rtems_rfs_symlink_read>
2014590: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
2014594: 80 a2 20 00 cmp %o0, 0
2014598: 12 80 00 09 bne 20145bc <rtems_rfs_rtems_eval_token+0x1fc><== NEVER TAKEN
201459c: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
20145a0: d4 07 bf fc ld [ %fp + -4 ], %o2
20145a4: 7f ff d7 9a call 200a40c <rtems_filesystem_eval_path_recursive>
20145a8: 92 10 00 1b mov %i3, %o1
} else {
rtems_filesystem_eval_path_error (ctx, 0);
}
free(link);
20145ac: 7f ff d0 96 call 2008804 <free>
20145b0: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20145b4: 81 c7 e0 08 ret
20145b8: 91 e8 20 01 restore %g0, 1, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
if (rc == 0) {
rtems_filesystem_eval_path_recursive (ctx, link, len);
} else {
rtems_filesystem_eval_path_error (ctx, 0);
20145bc: 7f ff d6 6c call 2009f6c <rtems_filesystem_eval_path_error><== NOT EXECUTED
20145c0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20145c4: 30 bf ff fa b,a 20145ac <rtems_rfs_rtems_eval_token+0x1ec><== NOT EXECUTED
}
free(link);
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
20145c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20145cc: 7f ff d6 68 call 2009f6c <rtems_filesystem_eval_path_error><== NOT EXECUTED
20145d0: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
20145d4: 30 bf ff f8 b,a 20145b4 <rtems_rfs_rtems_eval_token+0x1f4><== NOT EXECUTED
02013d58 <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
2013d58: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013d5c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2013d60: 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);
2013d64: f8 00 60 08 ld [ %g1 + 8 ], %i4
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);
2013d68: 94 07 bf d8 add %fp, -40, %o2
2013d6c: 90 10 00 1c mov %i4, %o0
2013d70: 7f ff fc 8a call 2012f98 <rtems_rfs_inode_open>
2013d74: 96 10 20 01 mov 1, %o3
if (rc)
2013d78: ba 92 20 00 orcc %o0, 0, %i5
2013d7c: 12 80 00 24 bne 2013e0c <rtems_rfs_rtems_fchmod+0xb4> <== NEVER TAKEN
2013d80: c2 07 bf e4 ld [ %fp + -28 ], %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);
2013d84: c4 08 60 02 ldub [ %g1 + 2 ], %g2
2013d88: c2 08 60 03 ldub [ %g1 + 3 ], %g1
2013d8c: 85 28 a0 08 sll %g2, 8, %g2
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
2013d90: 40 00 11 ef call 201854c <geteuid>
2013d94: ba 10 80 01 or %g2, %g1, %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;
2013d98: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
2013d9c: 91 2a 20 10 sll %o0, 0x10, %o0
2013da0: c4 08 60 06 ldub [ %g1 + 6 ], %g2
2013da4: c6 08 60 07 ldub [ %g1 + 7 ], %g3
2013da8: 85 28 a0 08 sll %g2, 8, %g2
2013dac: 84 10 80 03 or %g2, %g3, %g2
2013db0: 85 28 a0 10 sll %g2, 0x10, %g2
2013db4: 80 a0 80 08 cmp %g2, %o0
2013db8: 02 80 00 05 be 2013dcc <rtems_rfs_rtems_fchmod+0x74> <== ALWAYS TAKEN
2013dbc: 89 32 20 10 srl %o0, 0x10, %g4
2013dc0: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
2013dc4: 12 80 00 17 bne 2013e20 <rtems_rfs_rtems_fchmod+0xc8> <== NOT EXECUTED
2013dc8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
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);
2013dcc: ba 0f 70 00 and %i5, -4096, %i5
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
2013dd0: b2 0e 6f ff and %i1, 0xfff, %i1
2013dd4: b2 17 40 19 or %i5, %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);
2013dd8: 85 36 60 08 srl %i1, 8, %g2
2013ddc: c4 28 60 02 stb %g2, [ %g1 + 2 ]
2013de0: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
2013de4: 90 10 00 1c mov %i4, %o0
2013de8: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013dec: 82 10 20 01 mov 1, %g1
2013df0: 92 07 bf d8 add %fp, -40, %o1
2013df4: c2 2f bf e8 stb %g1, [ %fp + -24 ]
2013df8: 7f ff fc e0 call 2013178 <rtems_rfs_inode_close>
2013dfc: b0 10 20 00 clr %i0
if (rc > 0)
2013e00: 80 a2 20 00 cmp %o0, 0
2013e04: 04 80 00 05 ble 2013e18 <rtems_rfs_rtems_fchmod+0xc0> <== ALWAYS TAKEN
2013e08: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
2013e0c: 40 00 3d 17 call 2023268 <__errno> <== NOT EXECUTED
2013e10: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013e14: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2013e18: 81 c7 e0 08 ret
2013e1c: 81 e8 00 00 restore
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
{
rtems_rfs_inode_close (fs, &inode);
2013e20: 7f ff fc d6 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2013e24: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
2013e28: 40 00 3d 10 call 2023268 <__errno> <== NOT EXECUTED
2013e2c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013e30: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2013e34: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013e38: 81 c7 e0 08 ret <== NOT EXECUTED
2013e3c: 81 e8 00 00 restore <== NOT EXECUTED
02014904 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
2014904: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
2014908: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
201490c: 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));
2014910: 40 00 22 cb call 201d43c <rtems_rfs_buffer_sync> <== NOT EXECUTED
2014914: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
2014918: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201491c: 02 80 00 05 be 2014930 <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
2014920: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
2014924: 40 00 3a 51 call 2023268 <__errno> <== NOT EXECUTED
2014928: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201492c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
2014930: 81 c7 e0 08 ret <== NOT EXECUTED
2014934: 81 e8 00 00 restore <== NOT EXECUTED
02021884 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
2021884: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
2021888: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
202188c: 92 10 20 00 clr %o1
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
2021890: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
2021894: 94 10 20 00 clr %o2
2021898: fa 00 60 98 ld [ %g1 + 0x98 ], %i5
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
202189c: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
20218a0: 7f ff af 73 call 200d66c <rtems_semaphore_obtain>
20218a4: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20218a8: b6 92 20 00 orcc %o0, 0, %i3
20218ac: 12 80 00 21 bne 2021930 <rtems_rfs_rtems_file_close+0xac> <== NEVER TAKEN
20218b0: 90 10 20 00 clr %o0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
20218b4: 90 10 00 1d mov %i5, %o0
20218b8: 7f ff f5 7e call 201eeb0 <rtems_rfs_file_close>
20218bc: 92 10 00 1c mov %i4, %o1
if (rc > 0)
20218c0: b0 92 20 00 orcc %o0, 0, %i0
20218c4: 24 80 00 07 ble,a 20218e0 <rtems_rfs_rtems_file_close+0x5c><== ALWAYS TAKEN
20218c8: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
20218cc: 40 00 06 67 call 2023268 <__errno> <== NOT EXECUTED
20218d0: 01 00 00 00 nop <== NOT EXECUTED
20218d4: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
20218d8: b0 10 3f ff mov -1, %i0 <== 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);
20218dc: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
20218e0: 7f ff ee fd call 201d4d4 <rtems_rfs_buffers_release>
20218e4: 90 10 00 1d mov %i5, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
20218e8: 7f ff af b0 call 200d7a8 <rtems_semaphore_release>
20218ec: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20218f0: ba 92 20 00 orcc %o0, 0, %i5
20218f4: 02 80 00 0d be 2021928 <rtems_rfs_rtems_file_close+0xa4> <== ALWAYS TAKEN
20218f8: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20218fc: 7f ff cc 4e call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021900: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021904: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021908: 02 80 00 08 be 2021928 <rtems_rfs_rtems_file_close+0xa4> <== NOT EXECUTED
202190c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021910: 7f ff 9b 23 call 200859c <rtems_status_text> <== NOT EXECUTED
2021914: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021918: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
202191c: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021920: 40 00 0b e3 call 20248ac <printf> <== NOT EXECUTED
2021924: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rc;
}
2021928: 81 c7 e0 08 ret
202192c: 81 e8 00 00 restore
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021930: 7f ff cc 41 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021934: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021938: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
202193c: 22 bf ff df be,a 20218b8 <rtems_rfs_rtems_file_close+0x34><== NOT EXECUTED
2021940: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021944: 7f ff 9b 16 call 200859c <rtems_status_text> <== NOT EXECUTED
2021948: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
202194c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021950: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021954: 40 00 0b d6 call 20248ac <printf> <== NOT EXECUTED
2021958: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
202195c: 10 bf ff d7 b 20218b8 <rtems_rfs_rtems_file_close+0x34> <== NOT EXECUTED
2021960: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
02021964 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
2021964: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
2021968: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
202196c: 92 10 20 00 clr %o1
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));
2021970: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
2021974: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2021978: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
202197c: ba 10 00 1a mov %i2, %i5
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
2021980: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
2021984: b8 10 00 19 mov %i1, %i4
2021988: 7f ff af 39 call 200d66c <rtems_semaphore_obtain>
202198c: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021990: b4 92 20 00 orcc %o0, 0, %i2
2021994: 12 80 00 23 bne 2021a20 <rtems_rfs_rtems_file_ftruncate+0xbc><== NEVER TAKEN
2021998: 90 10 20 00 clr %o0
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));
rc = rtems_rfs_file_set_size (file, length);
202199c: 90 10 00 1b mov %i3, %o0
20219a0: 92 10 00 1c mov %i4, %o1
20219a4: 7f ff f7 93 call 201f7f0 <rtems_rfs_file_set_size>
20219a8: 94 10 00 1d mov %i5, %o2
if (rc)
20219ac: b0 92 20 00 orcc %o0, 0, %i0
20219b0: 22 80 00 07 be,a 20219cc <rtems_rfs_rtems_file_ftruncate+0x68><== ALWAYS TAKEN
20219b4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
20219b8: 40 00 06 2c call 2023268 <__errno> <== NOT EXECUTED
20219bc: 01 00 00 00 nop <== NOT EXECUTED
20219c0: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
20219c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
20219c8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
20219cc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
20219d0: 7f ff ee c1 call 201d4d4 <rtems_rfs_buffers_release>
20219d4: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
20219d8: 7f ff af 74 call 200d7a8 <rtems_semaphore_release>
20219dc: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20219e0: ba 92 20 00 orcc %o0, 0, %i5
20219e4: 02 80 00 0d be 2021a18 <rtems_rfs_rtems_file_ftruncate+0xb4><== ALWAYS TAKEN
20219e8: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20219ec: 7f ff cc 12 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20219f0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20219f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20219f8: 02 80 00 08 be 2021a18 <rtems_rfs_rtems_file_ftruncate+0xb4><== NOT EXECUTED
20219fc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021a00: 7f ff 9a e7 call 200859c <rtems_status_text> <== NOT EXECUTED
2021a04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021a08: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021a0c: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021a10: 40 00 0b a7 call 20248ac <printf> <== NOT EXECUTED
2021a14: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
return rc;
}
2021a18: 81 c7 e0 08 ret
2021a1c: 81 e8 00 00 restore
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021a20: 7f ff cc 05 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021a24: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021a28: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021a2c: 22 bf ff dd be,a 20219a0 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
2021a30: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021a34: 7f ff 9a da call 200859c <rtems_status_text> <== NOT EXECUTED
2021a38: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2021a3c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021a40: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021a44: 40 00 0b 9a call 20248ac <printf> <== NOT EXECUTED
2021a48: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
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));
rc = rtems_rfs_file_set_size (file, length);
2021a4c: 10 bf ff d5 b 20219a0 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
2021a50: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
02021a54 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
2021a54: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
2021a58: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2021a5c: 92 10 20 00 clr %o1
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
2021a60: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2021a64: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2021a68: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
2021a6c: b8 10 00 19 mov %i1, %i4
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
2021a70: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
2021a74: ba 10 00 1a mov %i2, %i5
2021a78: d0 00 40 00 ld [ %g1 ], %o0
2021a7c: 7f ff ae fc call 200d66c <rtems_semaphore_obtain>
2021a80: b2 10 00 1b mov %i3, %i1
if (sc != RTEMS_SUCCESSFUL)
2021a84: b4 92 20 00 orcc %o0, 0, %i2
2021a88: 12 80 00 22 bne 2021b10 <rtems_rfs_rtems_file_lseek+0xbc> <== NEVER TAKEN
2021a8c: 90 10 20 00 clr %o0
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
2021a90: 92 10 00 1c mov %i4, %o1
2021a94: 94 10 00 1d mov %i5, %o2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
2021a98: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
2021a9c: 90 10 00 18 mov %i0, %o0
2021aa0: 40 00 01 99 call 2022104 <rtems_filesystem_default_lseek_file>
2021aa4: 96 10 00 19 mov %i1, %o3
2021aa8: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
2021aac: 80 a7 3f ff cmp %i4, -1
2021ab0: 02 80 00 2d be 2021b64 <rtems_rfs_rtems_file_lseek+0x110>
2021ab4: ba 10 00 09 mov %o1, %i5
{
rtems_rfs_pos pos = iop->offset;
2021ab8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
2021abc: 90 10 00 10 mov %l0, %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
if (new_offset != -1)
{
rtems_rfs_pos pos = iop->offset;
2021ac0: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
2021ac4: 92 10 00 02 mov %g2, %o1
2021ac8: 94 10 00 03 mov %g3, %o2
2021acc: 7f ff f7 06 call 201f6e4 <rtems_rfs_file_seek>
2021ad0: 96 07 bf f8 add %fp, -8, %o3
if (rc)
2021ad4: b2 92 20 00 orcc %o0, 0, %i1
2021ad8: 12 80 00 30 bne 2021b98 <rtems_rfs_rtems_file_lseek+0x144><== NEVER TAKEN
2021adc: 01 00 00 00 nop
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021ae0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2021ae4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
2021ae8: 7f ff ee 7b call 201d4d4 <rtems_rfs_buffers_release>
2021aec: f6 02 20 80 ld [ %o0 + 0x80 ], %i3
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021af0: 7f ff af 2e call 200d7a8 <rtems_semaphore_release>
2021af4: d0 06 c0 00 ld [ %i3 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021af8: b6 92 20 00 orcc %o0, 0, %i3
2021afc: 12 80 00 36 bne 2021bd4 <rtems_rfs_rtems_file_lseek+0x180><== NEVER TAKEN
2021b00: 90 10 20 00 clr %o0
return new_offset;
}
2021b04: b0 10 00 1c mov %i4, %i0
2021b08: 81 c7 e0 08 ret
2021b0c: 93 e8 00 1d restore %g0, %i5, %o1
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021b10: 7f ff cb c9 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021b14: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021b18: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021b1c: 02 bf ff de be 2021a94 <rtems_rfs_rtems_file_lseek+0x40> <== NOT EXECUTED
2021b20: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021b24: 7f ff 9a 9e call 200859c <rtems_status_text> <== NOT EXECUTED
2021b28: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2021b2c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021b30: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021b34: 40 00 0b 5e call 20248ac <printf> <== NOT EXECUTED
2021b38: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
2021b3c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2021b40: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
2021b44: f4 1e 20 08 ldd [ %i0 + 8 ], %i2 <== NOT EXECUTED
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
2021b48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021b4c: 40 00 01 6e call 2022104 <rtems_filesystem_default_lseek_file><== NOT EXECUTED
2021b50: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2021b54: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
if (new_offset != -1)
2021b58: 80 a7 3f ff cmp %i4, -1 <== NOT EXECUTED
2021b5c: 12 bf ff d7 bne 2021ab8 <rtems_rfs_rtems_file_lseek+0x64> <== NOT EXECUTED
2021b60: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
2021b64: 80 a2 7f ff cmp %o1, -1
2021b68: 22 bf ff df be,a 2021ae4 <rtems_rfs_rtems_file_lseek+0x90><== ALWAYS TAKEN
2021b6c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
2021b70: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
2021b74: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
if (new_offset != -1)
{
rtems_rfs_pos pos = iop->offset;
2021b78: c4 3f bf f8 std %g2, [ %fp + -8 ] <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
2021b7c: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2021b80: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2021b84: 7f ff f6 d8 call 201f6e4 <rtems_rfs_file_seek> <== NOT EXECUTED
2021b88: 96 07 bf f8 add %fp, -8, %o3 <== NOT EXECUTED
if (rc)
2021b8c: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2021b90: 22 bf ff d5 be,a 2021ae4 <rtems_rfs_rtems_file_lseek+0x90><== NOT EXECUTED
2021b94: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
2021b98: 40 00 05 b4 call 2023268 <__errno> <== NOT EXECUTED
2021b9c: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021ba0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
rtems_rfs_pos pos = iop->offset;
int rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
2021ba4: f2 22 00 00 st %i1, [ %o0 ] <== NOT EXECUTED
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021ba8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
iop->offset = old_offset;
2021bac: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
2021bb0: 7f ff ee 49 call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
2021bb4: f6 02 20 80 ld [ %o0 + 0x80 ], %i3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021bb8: 7f ff ae fc call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
2021bbc: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
new_offset = -1;
2021bc0: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2021bc4: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
2021bc8: 02 bf ff cf be 2021b04 <rtems_rfs_rtems_file_lseek+0xb0> <== NOT EXECUTED
2021bcc: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021bd0: 90 10 20 00 clr %o0 <== NOT EXECUTED
2021bd4: 7f ff cb 98 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021bd8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021bdc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021be0: 22 bf ff ca be,a 2021b08 <rtems_rfs_rtems_file_lseek+0xb4><== NOT EXECUTED
2021be4: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021be8: 7f ff 9a 6d call 200859c <rtems_status_text> <== NOT EXECUTED
2021bec: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return new_offset;
}
2021bf0: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
2021bf4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021bf8: b2 10 00 1d mov %i5, %i1 <== NOT EXECUTED
2021bfc: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021c00: 40 00 0b 2b call 20248ac <printf> <== NOT EXECUTED
2021c04: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2021c08: 81 c7 e0 08 ret <== NOT EXECUTED
2021c0c: 81 e8 00 00 restore <== NOT EXECUTED
02021c10 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
2021c10: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
2021c14: c2 06 20 28 ld [ %i0 + 0x28 ], %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);
2021c18: 92 10 20 00 clr %o1
2021c1c: fa 00 60 08 ld [ %g1 + 8 ], %i5
2021c20: 94 10 20 00 clr %o2
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
2021c24: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2021c28: 7f ff ae 91 call 200d66c <rtems_semaphore_obtain>
2021c2c: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021c30: b8 92 20 00 orcc %o0, 0, %i4
2021c34: 12 80 00 23 bne 2021cc0 <rtems_rfs_rtems_file_open+0xb0> <== NEVER TAKEN
2021c38: 90 10 20 00 clr %o0
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
2021c3c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
2021c40: 90 10 00 1d mov %i5, %o0
2021c44: 94 10 20 00 clr %o2
2021c48: 7f ff f3 c9 call 201eb6c <rtems_rfs_file_open>
2021c4c: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
2021c50: b8 92 20 00 orcc %o0, 0, %i4
2021c54: 04 80 00 2f ble 2021d10 <rtems_rfs_rtems_file_open+0x100> <== ALWAYS TAKEN
2021c58: c2 07 bf fc ld [ %fp + -4 ], %g1
* 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);
2021c5c: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
2021c60: 7f ff ee 1d call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
2021c64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021c68: 7f ff ae d0 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
2021c6c: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2021c70: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2021c74: 12 80 00 07 bne 2021c90 <rtems_rfs_rtems_file_open+0x80> <== NOT EXECUTED
2021c78: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("file-open: open", rc);
2021c7c: 40 00 05 7b call 2023268 <__errno> <== NOT EXECUTED
2021c80: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021c84: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2021c88: 81 c7 e0 08 ret <== NOT EXECUTED
2021c8c: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021c90: 7f ff cb 69 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021c94: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021c98: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021c9c: 02 bf ff f8 be 2021c7c <rtems_rfs_rtems_file_open+0x6c> <== NOT EXECUTED
2021ca0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021ca4: 7f ff 9a 3e call 200859c <rtems_status_text> <== NOT EXECUTED
2021ca8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021cac: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021cb0: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021cb4: 40 00 0a fe call 20248ac <printf> <== NOT EXECUTED
2021cb8: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2021cbc: 30 bf ff f0 b,a 2021c7c <rtems_rfs_rtems_file_open+0x6c> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021cc0: 7f ff cb 5d call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021cc4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021cc8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021ccc: 22 bf ff dd be,a 2021c40 <rtems_rfs_rtems_file_open+0x30><== NOT EXECUTED
2021cd0: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021cd4: 7f ff 9a 32 call 200859c <rtems_status_text> <== NOT EXECUTED
2021cd8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2021cdc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021ce0: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021ce4: 40 00 0a f2 call 20248ac <printf> <== NOT EXECUTED
2021ce8: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
2021cec: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
2021cf0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021cf4: 94 10 20 00 clr %o2 <== NOT EXECUTED
2021cf8: 7f ff f3 9d call 201eb6c <rtems_rfs_file_open> <== NOT EXECUTED
2021cfc: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
if (rc > 0)
2021d00: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2021d04: 34 bf ff d7 bg,a 2021c60 <rtems_rfs_rtems_file_open+0x50><== NOT EXECUTED
2021d08: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
2021d0c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== 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);
2021d10: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
2021d14: 90 10 00 1d mov %i5, %o0
2021d18: 7f ff ed ef call 201d4d4 <rtems_rfs_buffers_release>
2021d1c: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021d20: 7f ff ae a2 call 200d7a8 <rtems_semaphore_release>
2021d24: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021d28: ba 92 20 00 orcc %o0, 0, %i5
2021d2c: 12 80 00 04 bne 2021d3c <rtems_rfs_rtems_file_open+0x12c> <== NEVER TAKEN
2021d30: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
}
2021d34: 81 c7 e0 08 ret
2021d38: 91 e8 20 00 restore %g0, 0, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021d3c: 7f ff cb 3e call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021d40: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021d44: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021d48: 02 bf ff fb be 2021d34 <rtems_rfs_rtems_file_open+0x124> <== NOT EXECUTED
2021d4c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021d50: 7f ff 9a 13 call 200859c <rtems_status_text> <== NOT EXECUTED
2021d54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021d58: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021d5c: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021d60: 40 00 0a d3 call 20248ac <printf> <== NOT EXECUTED
2021d64: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2021d68: 30 bf ff f3 b,a 2021d34 <rtems_rfs_rtems_file_open+0x124><== NOT EXECUTED
02021698 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
2021698: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
202169c: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
20216a0: 92 10 20 00 clr %o1
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));
20216a4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
20216a8: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
20216ac: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
20216b0: a2 10 00 18 mov %i0, %l1
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
20216b4: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
20216b8: 7f ff af ed call 200d66c <rtems_semaphore_obtain>
20216bc: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20216c0: ba 92 20 00 orcc %o0, 0, %i5
20216c4: 12 80 00 5b bne 2021830 <rtems_rfs_rtems_file_read+0x198> <== NEVER TAKEN
20216c8: 90 10 20 00 clr %o0
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
20216cc: d2 04 20 1c ld [ %l0 + 0x1c ], %o1
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
20216d0: f8 1c 60 08 ldd [ %l1 + 8 ], %i4
20216d4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
20216d8: 7f ff ea 1b call 201bf44 <rtems_rfs_block_get_size>
20216dc: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
20216e0: 80 a2 00 1c cmp %o0, %i4
20216e4: 18 80 00 19 bgu 2021748 <rtems_rfs_rtems_file_read+0xb0> <== NEVER TAKEN
20216e8: 80 a6 a0 00 cmp %i2, 0
20216ec: 80 a2 00 1c cmp %o0, %i4
20216f0: 02 80 00 13 be 202173c <rtems_rfs_rtems_file_read+0xa4> <== ALWAYS TAKEN
20216f4: 80 a2 40 1d cmp %o1, %i5
{
while (count)
20216f8: 84 10 20 00 clr %g2 <== NOT EXECUTED
20216fc: 86 10 20 00 clr %g3
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;
2021700: b0 10 20 00 clr %i0
}
}
}
if (read >= 0)
iop->offset = pos + read;
2021704: b6 80 c0 1d addcc %g3, %i5, %i3
2021708: b4 40 80 1c addx %g2, %i4, %i2
202170c: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021710: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2021714: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
2021718: 7f ff ef 6f call 201d4d4 <rtems_rfs_buffers_release>
202171c: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021720: 7f ff b0 22 call 200d7a8 <rtems_semaphore_release>
2021724: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021728: ba 92 20 00 orcc %o0, 0, %i5
202172c: 12 80 00 2f bne 20217e8 <rtems_rfs_rtems_file_read+0x150> <== NEVER TAKEN
2021730: 90 10 20 00 clr %o0
return read;
}
2021734: 81 c7 e0 08 ret
2021738: 81 e8 00 00 restore
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
202173c: 08 bf ff f0 bleu 20216fc <rtems_rfs_rtems_file_read+0x64>
2021740: 84 10 20 00 clr %g2
{
while (count)
2021744: 80 a6 a0 00 cmp %i2, 0
2021748: 02 bf ff ec be 20216f8 <rtems_rfs_rtems_file_read+0x60> <== NEVER TAKEN
202174c: b0 10 20 00 clr %i0
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
2021750: 10 80 00 16 b 20217a8 <rtems_rfs_rtems_file_read+0x110>
2021754: 92 07 bf fc add %fp, -4, %o1
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
2021758: c4 04 20 0c ld [ %l0 + 0xc ], %g2
202175c: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
2021760: d2 00 a0 1c ld [ %g2 + 0x1c ], %o1
2021764: 90 10 00 19 mov %i1, %o0
2021768: 92 02 40 01 add %o1, %g1, %o1
202176c: 40 00 0b 43 call 2024478 <memcpy>
2021770: 94 10 00 1b mov %i3, %o2
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
2021774: 90 10 00 10 mov %l0, %o0
2021778: 92 10 00 1b mov %i3, %o1
202177c: 94 10 20 01 mov 1, %o2
2021780: 7f ff f7 1f call 201f3fc <rtems_rfs_file_io_end>
2021784: b2 06 40 1b add %i1, %i3, %i1
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
2021788: b0 06 c0 18 add %i3, %i0, %i0
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
202178c: 80 a2 20 00 cmp %o0, 0
2021790: 14 80 00 39 bg 2021874 <rtems_rfs_rtems_file_read+0x1dc> <== NEVER TAKEN
2021794: a4 10 00 08 mov %o0, %l2
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
2021798: 80 a6 a0 00 cmp %i2, 0
202179c: 02 80 00 21 be 2021820 <rtems_rfs_rtems_file_read+0x188>
20217a0: 80 a6 20 00 cmp %i0, 0
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
20217a4: 92 07 bf fc add %fp, -4, %o1
20217a8: 94 10 20 01 mov 1, %o2
20217ac: 7f ff f6 83 call 201f1b8 <rtems_rfs_file_io_start>
20217b0: 90 10 00 10 mov %l0, %o0
if (rc > 0)
20217b4: b6 92 20 00 orcc %o0, 0, %i3
20217b8: 14 80 00 2b bg 2021864 <rtems_rfs_rtems_file_read+0x1cc> <== NEVER TAKEN
20217bc: 01 00 00 00 nop
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
20217c0: f6 07 bf fc ld [ %fp + -4 ], %i3
20217c4: 80 a6 e0 00 cmp %i3, 0
20217c8: 02 80 00 15 be 202181c <rtems_rfs_rtems_file_read+0x184>
20217cc: 80 a6 c0 1a cmp %i3, %i2
break;
if (size > count)
20217d0: 28 bf ff e2 bleu,a 2021758 <rtems_rfs_rtems_file_read+0xc0>
20217d4: b4 26 80 1b sub %i2, %i3, %i2
size = count;
20217d8: b6 10 00 1a mov %i2, %i3
20217dc: f4 27 bf fc st %i2, [ %fp + -4 ]
20217e0: 10 bf ff de b 2021758 <rtems_rfs_rtems_file_read+0xc0>
20217e4: b4 10 20 00 clr %i2
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20217e8: 7f ff cc 93 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20217ec: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20217f0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20217f4: 02 80 00 08 be 2021814 <rtems_rfs_rtems_file_read+0x17c> <== NOT EXECUTED
20217f8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
20217fc: 7f ff 9b 68 call 200859c <rtems_status_text> <== NOT EXECUTED
2021800: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021804: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021808: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
202180c: 40 00 0c 28 call 20248ac <printf> <== NOT EXECUTED
2021810: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
iop->offset = pos + read;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return read;
}
2021814: 81 c7 e0 08 ret <== NOT EXECUTED
2021818: 81 e8 00 00 restore <== NOT EXECUTED
break;
}
}
}
if (read >= 0)
202181c: 80 a6 20 00 cmp %i0, 0
2021820: 06 bf ff bc bl 2021710 <rtems_rfs_rtems_file_read+0x78> <== NEVER TAKEN
2021824: 86 10 00 18 mov %i0, %g3
2021828: 10 bf ff b7 b 2021704 <rtems_rfs_rtems_file_read+0x6c>
202182c: 85 3e 20 1f sra %i0, 0x1f, %g2
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021830: 7f ff cc 81 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021834: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021838: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
202183c: 22 bf ff a5 be,a 20216d0 <rtems_rfs_rtems_file_read+0x38><== NOT EXECUTED
2021840: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021844: 7f ff 9b 56 call 200859c <rtems_status_text> <== NOT EXECUTED
2021848: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
202184c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021850: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021854: 40 00 0c 16 call 20248ac <printf> <== NOT EXECUTED
2021858: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
202185c: 10 bf ff 9d b 20216d0 <rtems_rfs_rtems_file_read+0x38> <== NOT EXECUTED
2021860: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
2021864: 40 00 06 81 call 2023268 <__errno> <== NOT EXECUTED
2021868: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202186c: 10 bf ff a9 b 2021710 <rtems_rfs_rtems_file_read+0x78> <== NOT EXECUTED
2021870: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
2021874: 40 00 06 7d call 2023268 <__errno> <== NOT EXECUTED
2021878: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202187c: 10 bf ff a5 b 2021710 <rtems_rfs_rtems_file_read+0x78> <== NOT EXECUTED
2021880: e4 22 00 00 st %l2, [ %o0 ] <== NOT EXECUTED
02021d6c <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
2021d6c: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
2021d70: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2021d74: 92 10 20 00 clr %o1
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));
2021d78: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2021d7c: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2021d80: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
2021d84: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
2021d88: 7f ff ae 39 call 200d66c <rtems_semaphore_obtain>
2021d8c: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021d90: ba 92 20 00 orcc %o0, 0, %i5
2021d94: 12 80 00 70 bne 2021f54 <rtems_rfs_rtems_file_write+0x1e8><== NEVER TAKEN
2021d98: 90 10 20 00 clr %o0
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
2021d9c: 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;
2021da0: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
2021da4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
2021da8: c4 3f bf f8 std %g2, [ %fp + -8 ]
2021dac: 7f ff e8 66 call 201bf44 <rtems_rfs_block_get_size>
2021db0: 92 02 60 84 add %o1, 0x84, %o1
2021db4: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
2021db8: d2 07 bf f8 ld [ %fp + -8 ], %o1
2021dbc: 84 10 00 08 mov %o0, %g2
2021dc0: 80 a2 40 02 cmp %o1, %g2
2021dc4: 18 80 00 7b bgu 2021fb0 <rtems_rfs_rtems_file_write+0x244><== NEVER TAKEN
2021dc8: d4 07 bf fc ld [ %fp + -4 ], %o2
2021dcc: 80 a2 40 02 cmp %o1, %g2
2021dd0: 02 80 00 8b be 2021ffc <rtems_rfs_rtems_file_write+0x290> <== ALWAYS TAKEN
2021dd4: 80 a2 80 03 cmp %o2, %g3
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
2021dd8: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED
2021ddc: 08 80 00 3b bleu 2021ec8 <rtems_rfs_rtems_file_write+0x15c><== ALWAYS TAKEN
2021de0: 01 00 00 00 nop
2021de4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
2021de8: 80 88 62 00 btst 0x200, %g1
2021dec: 32 80 00 8d bne,a 2022020 <rtems_rfs_rtems_file_write+0x2b4>
2021df0: c4 3f bf f8 std %g2, [ %fp + -8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
2021df4: a2 10 20 00 clr %l1
2021df8: 84 10 20 00 clr %g2
2021dfc: 80 a6 a0 00 cmp %i2, 0
2021e00: 12 80 00 1b bne 2021e6c <rtems_rfs_rtems_file_write+0x100><== ALWAYS TAKEN
2021e04: 86 10 20 00 clr %g3
}
if (write >= 0)
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021e08: 10 80 00 3b b 2021ef4 <rtems_rfs_rtems_file_write+0x188> <== NOT EXECUTED
2021e0c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
2021e10: d4 07 bf f4 ld [ %fp + -12 ], %o2
2021e14: 80 a2 80 1a cmp %o2, %i2
2021e18: 28 80 00 05 bleu,a 2021e2c <rtems_rfs_rtems_file_write+0xc0>
2021e1c: c4 04 20 0c ld [ %l0 + 0xc ], %g2
size = count;
2021e20: f4 27 bf f4 st %i2, [ %fp + -12 ]
2021e24: 94 10 00 1a mov %i2, %o2
memcpy (rtems_rfs_file_data (file), data, size);
2021e28: c4 04 20 0c ld [ %l0 + 0xc ], %g2
2021e2c: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
2021e30: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
2021e34: 40 00 09 91 call 2024478 <memcpy>
2021e38: 90 02 00 01 add %o0, %g1, %o0
data += size;
2021e3c: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
2021e40: 90 10 00 10 mov %l0, %o0
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
count -= size;
2021e44: b4 26 80 09 sub %i2, %o1, %i2
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
2021e48: b2 06 40 09 add %i1, %o1, %i1
count -= size;
write += size;
2021e4c: a2 04 40 09 add %l1, %o1, %l1
rc = rtems_rfs_file_io_end (file, size, false);
2021e50: 7f ff f5 6b call 201f3fc <rtems_rfs_file_io_end>
2021e54: 94 10 20 00 clr %o2
if (rc)
2021e58: ba 92 20 00 orcc %o0, 0, %i5
2021e5c: 12 80 00 0d bne 2021e90 <rtems_rfs_rtems_file_write+0x124><== NEVER TAKEN
2021e60: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
2021e64: 02 80 00 20 be 2021ee4 <rtems_rfs_rtems_file_write+0x178>
2021e68: 86 10 00 11 mov %l1, %g3
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
2021e6c: 92 07 bf f4 add %fp, -12, %o1
}
}
while (count)
{
size_t size = count;
2021e70: f4 27 bf f4 st %i2, [ %fp + -12 ]
rc = rtems_rfs_file_io_start (file, &size, false);
2021e74: 94 10 20 00 clr %o2
2021e78: 7f ff f4 d0 call 201f1b8 <rtems_rfs_file_io_start>
2021e7c: 90 10 00 10 mov %l0, %o0
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
2021e80: 92 10 00 19 mov %i1, %o1
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
2021e84: 80 a2 20 00 cmp %o0, 0
2021e88: 02 bf ff e2 be 2021e10 <rtems_rfs_rtems_file_write+0xa4>
2021e8c: ba 10 00 08 mov %o0, %i5
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
if (rc)
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
2021e90: 40 00 04 f6 call 2023268 <__errno>
2021e94: a2 10 3f ff mov -1, %l1
2021e98: fa 22 00 00 st %i5, [ %o0 ]
}
if (write >= 0)
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021e9c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2021ea0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
2021ea4: 7f ff ed 8c call 201d4d4 <rtems_rfs_buffers_release>
2021ea8: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021eac: 7f ff ae 3f call 200d7a8 <rtems_semaphore_release>
2021eb0: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021eb4: ba 92 20 00 orcc %o0, 0, %i5
2021eb8: 12 80 00 1b bne 2021f24 <rtems_rfs_rtems_file_write+0x1b8><== NEVER TAKEN
2021ebc: 90 10 20 00 clr %o0
return write;
}
2021ec0: 81 c7 e0 08 ret
2021ec4: 91 e8 00 11 restore %g0, %l1, %o0
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
2021ec8: 12 bf ff cc bne 2021df8 <rtems_rfs_rtems_file_write+0x8c> <== NEVER TAKEN
2021ecc: a2 10 20 00 clr %l1
2021ed0: 80 a0 c0 0a cmp %g3, %o2
2021ed4: 28 bf ff ca bleu,a 2021dfc <rtems_rfs_rtems_file_write+0x90>
2021ed8: 84 10 20 00 clr %g2
2021edc: 10 bf ff c3 b 2021de8 <rtems_rfs_rtems_file_write+0x7c>
2021ee0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
2021ee4: 80 a4 60 00 cmp %l1, 0
2021ee8: 06 bf ff ed bl 2021e9c <rtems_rfs_rtems_file_write+0x130> <== NEVER TAKEN
2021eec: 85 3c 60 1f sra %l1, 0x1f, %g2
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021ef0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
break;
}
}
if (write >= 0)
iop->offset = pos + write;
2021ef4: f8 1f bf f8 ldd [ %fp + -8 ], %i4
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021ef8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
break;
}
}
if (write >= 0)
iop->offset = pos + write;
2021efc: b6 80 c0 1d addcc %g3, %i5, %i3
* 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);
2021f00: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
2021f04: b4 40 80 1c addx %g2, %i4, %i2
rtems_rfs_buffers_release (fs);
2021f08: 7f ff ed 73 call 201d4d4 <rtems_rfs_buffers_release>
2021f0c: f4 3e 20 08 std %i2, [ %i0 + 8 ]
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021f10: 7f ff ae 26 call 200d7a8 <rtems_semaphore_release>
2021f14: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2021f18: ba 92 20 00 orcc %o0, 0, %i5
2021f1c: 02 bf ff e9 be 2021ec0 <rtems_rfs_rtems_file_write+0x154> <== ALWAYS TAKEN
2021f20: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021f24: 7f ff ca c4 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021f28: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021f2c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021f30: 02 bf ff e4 be 2021ec0 <rtems_rfs_rtems_file_write+0x154> <== NOT EXECUTED
2021f34: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021f38: 7f ff 99 99 call 200859c <rtems_status_text> <== NOT EXECUTED
2021f3c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021f40: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021f44: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021f48: 40 00 0a 59 call 20248ac <printf> <== NOT EXECUTED
2021f4c: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2021f50: 30 bf ff dc b,a 2021ec0 <rtems_rfs_rtems_file_write+0x154><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021f54: 7f ff ca b8 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2021f58: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021f5c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021f60: 22 bf ff 90 be,a 2021da0 <rtems_rfs_rtems_file_write+0x34><== NOT EXECUTED
2021f64: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021f68: 7f ff 99 8d call 200859c <rtems_status_text> <== NOT EXECUTED
2021f6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021f70: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021f74: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2021f78: 40 00 0a 4d call 20248ac <printf> <== NOT EXECUTED
2021f7c: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
2021f80: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
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;
2021f84: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
2021f88: d0 02 60 98 ld [ %o1 + 0x98 ], %o0 <== NOT EXECUTED
2021f8c: c4 3f bf f8 std %g2, [ %fp + -8 ] <== NOT EXECUTED
2021f90: 7f ff e7 ed call 201bf44 <rtems_rfs_block_get_size> <== NOT EXECUTED
2021f94: 92 02 60 84 add %o1, 0x84, %o1 <== NOT EXECUTED
2021f98: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
2021f9c: d2 07 bf f8 ld [ %fp + -8 ], %o1 <== NOT EXECUTED
2021fa0: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2021fa4: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED
2021fa8: 08 bf ff 8a bleu 2021dd0 <rtems_rfs_rtems_file_write+0x64><== NOT EXECUTED
2021fac: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
2021fb0: 7f ff f6 10 call 201f7f0 <rtems_rfs_file_set_size>
2021fb4: 90 10 00 10 mov %l0, %o0
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2021fb8: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
2021fbc: ba 10 00 08 mov %o0, %i5
if (rc)
2021fc0: 80 a7 60 00 cmp %i5, 0
2021fc4: 02 80 00 11 be 2022008 <rtems_rfs_rtems_file_write+0x29c> <== ALWAYS TAKEN
2021fc8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
2021fcc: 7f ff ed 42 call 201d4d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
2021fd0: f8 02 20 80 ld [ %o0 + 0x80 ], %i4 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021fd4: 7f ff ad f5 call 200d7a8 <rtems_semaphore_release> <== NOT EXECUTED
2021fd8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2021fdc: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2021fe0: 12 80 00 1b bne 202204c <rtems_rfs_rtems_file_write+0x2e0><== NOT EXECUTED
2021fe4: 90 10 20 00 clr %o0 <== NOT EXECUTED
pos = file_size;
rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
2021fe8: 40 00 04 a0 call 2023268 <__errno> <== NOT EXECUTED
2021fec: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
2021ff0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
2021ff4: 81 c7 e0 08 ret <== NOT EXECUTED
2021ff8: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
2021ffc: 08 bf ff 78 bleu 2021ddc <rtems_rfs_rtems_file_write+0x70>
2022000: 80 a0 80 09 cmp %g2, %o1
2022004: 30 bf ff eb b,a 2021fb0 <rtems_rfs_rtems_file_write+0x244>
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
2022008: d2 07 bf f8 ld [ %fp + -8 ], %o1
202200c: d4 07 bf fc ld [ %fp + -4 ], %o2
2022010: 7f ff e7 9e call 201be88 <rtems_rfs_block_get_bpos>
2022014: 96 04 20 10 add %l0, 0x10, %o3
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
2022018: 10 bf ff 78 b 2021df8 <rtems_rfs_rtems_file_write+0x8c>
202201c: a2 10 20 00 clr %l1
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
{
pos = file_size;
rc = rtems_rfs_file_seek (file, pos, &pos);
2022020: 90 10 00 10 mov %l0, %o0
2022024: 92 10 00 02 mov %g2, %o1
2022028: 94 10 00 03 mov %g3, %o2
202202c: 7f ff f5 ae call 201f6e4 <rtems_rfs_file_seek>
2022030: 96 07 bf f8 add %fp, -8, %o3
if (rc)
2022034: ba 92 20 00 orcc %o0, 0, %i5
2022038: 02 bf ff 70 be 2021df8 <rtems_rfs_rtems_file_write+0x8c> <== ALWAYS TAKEN
202203c: a2 10 20 00 clr %l1
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
2022040: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
2022044: 10 bf ff e2 b 2021fcc <rtems_rfs_rtems_file_write+0x260> <== NOT EXECUTED
2022048: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
202204c: 7f ff ca 7a call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2022050: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2022054: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2022058: 02 bf ff e4 be 2021fe8 <rtems_rfs_rtems_file_write+0x27c> <== NOT EXECUTED
202205c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2022060: 7f ff 99 4f call 200859c <rtems_status_text> <== NOT EXECUTED
2022064: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2022068: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
202206c: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2022070: 40 00 0a 0f call 20248ac <printf> <== NOT EXECUTED
2022074: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2022078: 30 bf ff dc b,a 2021fe8 <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
020140d4 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
20140d4: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20140d8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20140dc: 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);
20140e0: fa 00 60 08 ld [ %g1 + 8 ], %i5
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20140e4: 94 07 bf d8 add %fp, -40, %o2
20140e8: 90 10 00 1d mov %i5, %o0
20140ec: 7f ff fb ab call 2012f98 <rtems_rfs_inode_open>
20140f0: 96 10 20 01 mov 1, %o3
if (rc)
20140f4: b8 92 20 00 orcc %o0, 0, %i4
20140f8: 12 80 00 6f bne 20142b4 <rtems_rfs_rtems_fstat+0x1e0> <== NEVER TAKEN
20140fc: c2 07 bf e4 ld [ %fp + -28 ], %g1
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
2014100: 09 3f ff ec sethi %hi(0xffffb000), %g4
* @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);
2014104: c4 08 60 02 ldub [ %g1 + 2 ], %g2
2014108: d0 08 60 03 ldub [ %g1 + 3 ], %o0
201410c: 85 28 a0 08 sll %g2, 8, %g2
2014110: 07 00 00 08 sethi %hi(0x2000), %g3
2014114: 88 08 80 04 and %g2, %g4, %g4
2014118: 80 a1 00 03 cmp %g4, %g3
201411c: 02 80 00 4b be 2014248 <rtems_rfs_rtems_fstat+0x174> <== NEVER TAKEN
2014120: 84 10 80 08 or %g2, %o0, %g2
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);
2014124: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
2014128: 91 28 a0 10 sll %g2, 0x10, %o0
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
201412c: 87 38 60 1f sra %g1, 0x1f, %g3
2014130: c2 26 60 04 st %g1, [ %i1 + 4 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
2014134: c2 07 bf e0 ld [ %fp + -32 ], %g1
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);
2014138: c6 26 40 00 st %g3, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
201413c: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = rtems_rfs_rtems_mode (mode);
2014140: 40 00 02 3b call 2014a2c <rtems_rfs_rtems_mode>
2014144: 91 32 20 10 srl %o0, 0x10, %o0
*/
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);
2014148: c2 07 bf e4 ld [ %fp + -28 ], %g1
201414c: d0 26 60 0c st %o0, [ %i1 + 0xc ]
2014150: c6 08 60 01 ldub [ %g1 + 1 ], %g3
2014154: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
links = 0;
2014158: 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);
201415c: 85 28 a0 08 sll %g2, 8, %g2
2014160: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
2014164: 87 28 a0 10 sll %g2, 0x10, %g3
2014168: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
201416c: 86 39 00 03 xnor %g4, %g3, %g3
2014170: 80 a0 00 03 cmp %g0, %g3
2014174: 86 60 20 00 subx %g0, 0, %g3
2014178: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
201417c: 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;
2014180: c4 08 60 06 ldub [ %g1 + 6 ], %g2
2014184: c6 08 60 07 ldub [ %g1 + 7 ], %g3
2014188: 85 28 a0 08 sll %g2, 8, %g2
201418c: 84 10 80 03 or %g2, %g3, %g2
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
2014190: c4 36 60 12 sth %g2, [ %i1 + 0x12 ]
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
2014194: c4 08 60 04 ldub [ %g1 + 4 ], %g2
2014198: c2 08 60 05 ldub [ %g1 + 5 ], %g1
/*
* 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));
201419c: d2 07 bf e0 ld [ %fp + -32 ], %o1
20141a0: 85 28 a0 18 sll %g2, 0x18, %g2
20141a4: 83 28 60 10 sll %g1, 0x10, %g1
20141a8: 82 10 80 01 or %g2, %g1, %g1
20141ac: 83 30 60 10 srl %g1, 0x10, %g1
20141b0: 90 10 00 1d mov %i5, %o0
20141b4: 40 00 2e 6b call 201fb60 <rtems_rfs_file_get_shared>
20141b8: c2 36 60 14 sth %g1, [ %i1 + 0x14 ]
if (shared)
20141bc: 92 92 20 00 orcc %o0, 0, %o1
20141c0: 02 80 00 42 be 20142c8 <rtems_rfs_rtems_fstat+0x1f4>
20141c4: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
20141c8: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
20141cc: f8 02 60 8c ld [ %o1 + 0x8c ], %i4
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
20141d0: c8 02 60 90 ld [ %o1 + 0x90 ], %g4
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
20141d4: c6 02 60 94 ld [ %o1 + 0x94 ], %g3
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
20141d8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
20141dc: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
20141e0: f8 26 60 28 st %i4, [ %i1 + 0x28 ]
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))
20141e4: 03 00 00 3c sethi %hi(0xf000), %g1
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
20141e8: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
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))
20141ec: 84 08 80 01 and %g2, %g1, %g2
20141f0: 03 00 00 28 sethi %hi(0xa000), %g1
20141f4: 80 a0 80 01 cmp %g2, %g1
20141f8: 02 80 00 2b be 20142a4 <rtems_rfs_rtems_fstat+0x1d0> <== NEVER TAKEN
20141fc: c6 26 60 38 st %g3, [ %i1 + 0x38 ]
*/
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);
2014200: 90 10 00 1d mov %i5, %o0
2014204: 40 00 1f 50 call 201bf44 <rtems_rfs_block_get_size>
2014208: 92 02 60 84 add %o1, 0x84, %o1
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
201420c: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
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);
2014210: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
2014214: 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);
2014218: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
201421c: 92 07 bf d8 add %fp, -40, %o1
2014220: 7f ff fb d6 call 2013178 <rtems_rfs_inode_close>
2014224: b0 10 20 00 clr %i0
if (rc > 0)
2014228: 80 a2 20 00 cmp %o0, 0
201422c: 04 80 00 05 ble 2014240 <rtems_rfs_rtems_fstat+0x16c> <== ALWAYS TAKEN
2014230: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
2014234: 40 00 3c 0d call 2023268 <__errno> <== NOT EXECUTED
2014238: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201423c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2014240: 81 c7 e0 08 ret
2014244: 81 e8 00 00 restore
* @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]);
2014248: da 08 60 21 ldub [ %g1 + 0x21 ], %o5 <== NOT EXECUTED
201424c: c8 08 60 20 ldub [ %g1 + 0x20 ], %g4 <== NOT EXECUTED
2014250: de 08 60 23 ldub [ %g1 + 0x23 ], %o7 <== NOT EXECUTED
2014254: f4 08 60 22 ldub [ %g1 + 0x22 ], %i2 <== NOT EXECUTED
2014258: f6 08 60 1c ldub [ %g1 + 0x1c ], %i3 <== NOT EXECUTED
201425c: f0 08 60 1d ldub [ %g1 + 0x1d ], %i0 <== NOT EXECUTED
2014260: f8 08 60 1f ldub [ %g1 + 0x1f ], %i4 <== NOT EXECUTED
2014264: c6 08 60 1e ldub [ %g1 + 0x1e ], %g3 <== NOT EXECUTED
2014268: 83 2b 60 10 sll %o5, 0x10, %g1 <== NOT EXECUTED
201426c: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
2014270: b5 2e a0 08 sll %i2, 8, %i2 <== NOT EXECUTED
2014274: 88 11 00 01 or %g4, %g1, %g4 <== NOT EXECUTED
2014278: b7 2e e0 18 sll %i3, 0x18, %i3 <== NOT EXECUTED
201427c: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED
2014280: 83 2e 20 10 sll %i0, 0x10, %g1 <== NOT EXECUTED
2014284: 88 11 00 1a or %g4, %i2, %g4 <== NOT EXECUTED
2014288: 82 16 c0 01 or %i3, %g1, %g1 <== NOT EXECUTED
201428c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2014290: 82 10 40 1c or %g1, %i4, %g1 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
2014294: c8 26 60 1c st %g4, [ %i1 + 0x1c ] <== NOT EXECUTED
2014298: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED
201429c: 10 bf ff a2 b 2014124 <rtems_rfs_rtems_fstat+0x50> <== NOT EXECUTED
20142a0: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
20142a4: c2 12 60 8a lduh [ %o1 + 0x8a ], %g1 <== NOT EXECUTED
20142a8: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
20142ac: 10 bf ff d9 b 2014210 <rtems_rfs_rtems_fstat+0x13c> <== NOT EXECUTED
20142b0: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
20142b4: 40 00 3b ed call 2023268 <__errno> <== NOT EXECUTED
20142b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20142bc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20142c0: 81 c7 e0 08 ret <== NOT EXECUTED
20142c4: 81 e8 00 00 restore <== NOT EXECUTED
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);
if (S_ISLNK (buf->st_mode))
20142c8: c6 06 60 0c ld [ %i1 + 0xc ], %g3
* @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);
20142cc: f8 08 60 13 ldub [ %g1 + 0x13 ], %i4
20142d0: c4 08 60 10 ldub [ %g1 + 0x10 ], %g2
20142d4: f6 08 60 11 ldub [ %g1 + 0x11 ], %i3
20142d8: c8 08 60 12 ldub [ %g1 + 0x12 ], %g4
20142dc: b7 2e e0 10 sll %i3, 0x10, %i3
20142e0: 89 29 20 08 sll %g4, 8, %g4
20142e4: 85 28 a0 18 sll %g2, 0x18, %g2
20142e8: 84 10 80 1b or %g2, %i3, %g2
20142ec: 84 10 80 1c or %g2, %i4, %g2
20142f0: 84 10 80 04 or %g2, %g4, %g2
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
20142f4: 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);
20142f8: f8 08 60 17 ldub [ %g1 + 0x17 ], %i4
20142fc: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
2014300: f6 08 60 15 ldub [ %g1 + 0x15 ], %i3
2014304: c8 08 60 16 ldub [ %g1 + 0x16 ], %g4
2014308: b7 2e e0 10 sll %i3, 0x10, %i3
201430c: 89 29 20 08 sll %g4, 8, %g4
2014310: 85 28 a0 18 sll %g2, 0x18, %g2
2014314: 84 10 80 1b or %g2, %i3, %g2
2014318: 84 10 80 1c or %g2, %i4, %g2
201431c: 84 10 80 04 or %g2, %g4, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
2014320: 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);
2014324: f8 08 60 1b ldub [ %g1 + 0x1b ], %i4
2014328: c4 08 60 18 ldub [ %g1 + 0x18 ], %g2
201432c: f6 08 60 19 ldub [ %g1 + 0x19 ], %i3
2014330: c8 08 60 1a ldub [ %g1 + 0x1a ], %g4
2014334: b7 2e e0 10 sll %i3, 0x10, %i3
2014338: 89 29 20 08 sll %g4, 8, %g4
201433c: 85 28 a0 18 sll %g2, 0x18, %g2
2014340: 84 10 80 1b or %g2, %i3, %g2
2014344: 84 10 80 1c or %g2, %i4, %g2
2014348: 84 10 80 04 or %g2, %g4, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
201434c: 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);
2014350: c4 08 60 0c ldub [ %g1 + 0xc ], %g2
2014354: f6 08 60 0d ldub [ %g1 + 0xd ], %i3
2014358: f8 08 60 0f ldub [ %g1 + 0xf ], %i4
201435c: c8 08 60 0e ldub [ %g1 + 0xe ], %g4
2014360: 85 28 a0 18 sll %g2, 0x18, %g2
2014364: b7 2e e0 10 sll %i3, 0x10, %i3
2014368: 89 29 20 08 sll %g4, 8, %g4
201436c: 84 10 80 1b or %g2, %i3, %g2
2014370: 84 10 80 1c or %g2, %i4, %g2
2014374: 84 10 80 04 or %g2, %g4, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
2014378: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
201437c: 05 00 00 3c sethi %hi(0xf000), %g2
2014380: 86 08 c0 02 and %g3, %g2, %g3
2014384: 05 00 00 28 sethi %hi(0xa000), %g2
2014388: 80 a0 c0 02 cmp %g3, %g2
201438c: 12 80 00 09 bne 20143b0 <rtems_rfs_rtems_fstat+0x2dc>
2014390: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
2014394: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
* @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);
2014398: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
201439c: c0 26 60 20 clr [ %i1 + 0x20 ]
20143a0: 83 28 e0 08 sll %g3, 8, %g1
20143a4: 82 10 80 01 or %g2, %g1, %g1
20143a8: 10 bf ff 9a b 2014210 <rtems_rfs_rtems_fstat+0x13c>
20143ac: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
20143b0: 7f ff fd 2c call 2013860 <rtems_rfs_inode_get_size>
20143b4: 92 07 bf d8 add %fp, -40, %o1
20143b8: 10 bf ff 96 b 2014210 <rtems_rfs_rtems_fstat+0x13c>
20143bc: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
0201462c <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
201462c: 9d e3 bf 98 save %sp, -104, %sp
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2014630: a2 10 20 05 mov 5, %l1
2014634: 80 a6 60 00 cmp %i1, 0
2014638: 02 80 00 1f be 20146b4 <rtems_rfs_rtems_initialise+0x88> <== ALWAYS TAKEN
201463c: ba 10 20 00 clr %i5
{
printf ("options=%s\n", options);
2014640: 37 00 80 d5 sethi %hi(0x2035400), %i3 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
2014644: 39 00 80 d5 sethi %hi(0x2035400), %i4 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2014648: 35 00 80 d5 sethi %hi(0x2035400), %i2 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
201464c: 21 00 80 d5 sethi %hi(0x2035400), %l0 <== NOT EXECUTED
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2014650: b6 16 e1 28 or %i3, 0x128, %i3 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
2014654: b8 17 21 38 or %i4, 0x138, %i4 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2014658: b4 16 a1 48 or %i2, 0x148, %i2 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
201465c: a0 14 21 58 or %l0, 0x158, %l0 <== NOT EXECUTED
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2014660: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2014664: 40 00 40 92 call 20248ac <printf> <== NOT EXECUTED
2014668: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
201466c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2014670: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2014674: 40 00 45 31 call 2025b38 <strncmp> <== NOT EXECUTED
2014678: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
201467c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014680: 12 80 00 1e bne 20146f8 <rtems_rfs_rtems_initialise+0xcc> <== NOT EXECUTED
2014684: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
2014688: ba 17 60 01 or %i5, 1, %i5 <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
201468c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2014690: 40 00 42 b0 call 2025150 <strchr> <== NOT EXECUTED
2014694: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
2014698: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201469c: 02 80 00 06 be 20146b4 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
20146a0: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
20146a4: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
20146a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20146ac: 12 80 00 1b bne 2014718 <rtems_rfs_rtems_initialise+0xec> <== NOT EXECUTED
20146b0: b2 82 20 01 addcc %o0, 1, %i1 <== NOT EXECUTED
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
20146b4: 7f ff d1 f1 call 2008e78 <malloc>
20146b8: 90 10 20 04 mov 4, %o0
if (!rtems)
20146bc: b8 92 20 00 orcc %o0, 0, %i4
20146c0: 02 80 00 75 be 2014894 <rtems_rfs_rtems_initialise+0x268> <== NEVER TAKEN
20146c4: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
20146c8: 40 00 32 24 call 2020f58 <rtems_rfs_mutex_create>
20146cc: c0 27 00 00 clr [ %i4 ]
if (rc > 0)
20146d0: b6 92 20 00 orcc %o0, 0, %i3
20146d4: 24 80 00 1f ble,a 2014750 <rtems_rfs_rtems_initialise+0x124><== ALWAYS TAKEN
20146d8: d0 07 00 00 ld [ %i4 ], %o0
{
free (rtems);
20146dc: 7f ff d0 4a call 2008804 <free> <== NOT EXECUTED
20146e0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
20146e4: 40 00 3a e1 call 2023268 <__errno> <== NOT EXECUTED
20146e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20146ec: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
20146f0: 81 c7 e0 08 ret <== NOT EXECUTED
20146f4: 81 e8 00 00 restore <== NOT EXECUTED
{
printf ("options=%s\n", options);
if (strncmp (options, "hold-bitmaps",
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
20146f8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20146fc: 40 00 45 0f call 2025b38 <strncmp> <== NOT EXECUTED
2014700: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
2014704: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014708: 12 80 00 07 bne 2014724 <rtems_rfs_rtems_initialise+0xf8> <== NOT EXECUTED
201470c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
2014710: 10 bf ff df b 201468c <rtems_rfs_rtems_initialise+0x60> <== NOT EXECUTED
2014714: ba 17 60 02 or %i5, 2, %i5 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2014718: 12 bf ff d3 bne 2014664 <rtems_rfs_rtems_initialise+0x38> <== NOT EXECUTED
201471c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2014720: 30 bf ff e5 b,a 20146b4 <rtems_rfs_rtems_initialise+0x88><== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
2014724: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2014728: 40 00 45 04 call 2025b38 <strncmp> <== NOT EXECUTED
201472c: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
2014730: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014734: 12 80 00 2c bne 20147e4 <rtems_rfs_rtems_initialise+0x1b8><== NOT EXECUTED
2014738: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
201473c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2014740: 40 00 45 dd call 2025eb4 <strtoul> <== NOT EXECUTED
2014744: 94 10 20 00 clr %o2 <== NOT EXECUTED
2014748: 10 bf ff d1 b 201468c <rtems_rfs_rtems_initialise+0x60> <== NOT EXECUTED
201474c: a2 10 00 08 mov %o0, %l1 <== 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);
2014750: 92 10 20 00 clr %o1
2014754: 7f ff e3 c6 call 200d66c <rtems_semaphore_obtain>
2014758: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
201475c: b6 92 20 00 orcc %o0, 0, %i3
2014760: 12 80 00 11 bne 20147a4 <rtems_rfs_rtems_initialise+0x178><== NEVER TAKEN
2014764: 94 10 00 1d mov %i5, %o2
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
2014768: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
201476c: 92 10 00 1c mov %i4, %o1
2014770: 96 10 00 11 mov %l1, %o3
2014774: 40 00 2d 20 call 201fbf4 <rtems_rfs_fs_open>
2014778: 98 07 bf fc add %fp, -4, %o4
if (rc)
201477c: ba 92 20 00 orcc %o0, 0, %i5
2014780: 02 80 00 1f be 20147fc <rtems_rfs_rtems_initialise+0x1d0> <== ALWAYS TAKEN
2014784: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
2014788: 7f ff d0 1f call 2008804 <free> <== NOT EXECUTED
201478c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
2014790: 40 00 3a b6 call 2023268 <__errno> <== NOT EXECUTED
2014794: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2014798: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
201479c: 81 c7 e0 08 ret <== NOT EXECUTED
20147a0: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20147a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20147a8: 40 00 00 a3 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20147ac: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20147b0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20147b4: 12 80 00 25 bne 2014848 <rtems_rfs_rtems_initialise+0x21c><== NOT EXECUTED
20147b8: 01 00 00 00 nop <== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
if (rc > 0)
{
rtems_rfs_mutex_destroy (&rtems->access);
20147bc: 40 00 32 02 call 2020fc4 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
20147c0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free (rtems);
20147c4: 7f ff d0 10 call 2008804 <free> <== NOT EXECUTED
20147c8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
20147cc: 40 00 3a a7 call 2023268 <__errno> <== NOT EXECUTED
20147d0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20147d4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20147d8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
rtems_rfs_rtems_unlock (fs);
return 0;
}
20147dc: 81 c7 e0 08 ret <== NOT EXECUTED
20147e0: 81 e8 00 00 restore <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
20147e4: 40 00 3a a1 call 2023268 <__errno> <== NOT EXECUTED
20147e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20147ec: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20147f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20147f4: 81 c7 e0 08 ret <== NOT EXECUTED
20147f8: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
20147fc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
2014800: 05 00 80 d5 sethi %hi(0x2035400), %g2
2014804: 84 10 a1 90 or %g2, 0x190, %g2 ! 2035590 <rtems_rfs_ops>
* 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);
2014808: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
201480c: d0 26 20 08 st %o0, [ %i0 + 8 ]
mt_entry->ops = &rtems_rfs_ops;
2014810: c4 26 20 0c st %g2, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
2014814: 84 10 20 01 mov 1, %g2
2014818: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
201481c: 05 00 80 dc sethi %hi(0x2037000), %g2
2014820: 84 10 a3 e8 or %g2, 0x3e8, %g2 ! 20373e8 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
2014824: 40 00 23 2c call 201d4d4 <rtems_rfs_buffers_release>
2014828: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
201482c: 7f ff e3 df call 200d7a8 <rtems_semaphore_release>
2014830: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2014834: ba 92 20 00 orcc %o0, 0, %i5
2014838: 12 80 00 0b bne 2014864 <rtems_rfs_rtems_initialise+0x238><== NEVER TAKEN
201483c: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
2014840: 81 c7 e0 08 ret
2014844: 91 e8 20 00 restore %g0, 0, %o0
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2014848: 7f ff cf 55 call 200859c <rtems_status_text> <== NOT EXECUTED
201484c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2014850: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2014854: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2014858: 40 00 40 15 call 20248ac <printf> <== NOT EXECUTED
201485c: 90 12 21 68 or %o0, 0x168, %o0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
2014860: 30 bf ff d7 b,a 20147bc <rtems_rfs_rtems_initialise+0x190><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2014864: 40 00 00 74 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2014868: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201486c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2014870: 02 bf ff f4 be 2014840 <rtems_rfs_rtems_initialise+0x214> <== NOT EXECUTED
2014874: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2014878: 7f ff cf 49 call 200859c <rtems_status_text> <== NOT EXECUTED
201487c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2014880: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2014884: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2014888: 40 00 40 09 call 20248ac <printf> <== NOT EXECUTED
201488c: 90 12 21 00 or %o0, 0x100, %o0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2014890: 30 bf ff ec b,a 2014840 <rtems_rfs_rtems_initialise+0x214><== NOT EXECUTED
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
2014894: 40 00 3a 75 call 2023268 <__errno> <== NOT EXECUTED
2014898: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201489c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
20148a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20148a4: 81 c7 e0 08 ret <== NOT EXECUTED
20148a8: 81 e8 00 00 restore <== NOT EXECUTED
020139d8 <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)
{
20139d8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
20139dc: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rc = rtems_rfs_link (fs, name, namelen, parent, target, false);
20139e0: d6 06 20 08 ld [ %i0 + 8 ], %o3
20139e4: d0 00 60 08 ld [ %g1 + 8 ], %o0
20139e8: d8 06 60 08 ld [ %i1 + 8 ], %o4
20139ec: 92 10 00 1a mov %i2, %o1
20139f0: 94 10 00 1b mov %i3, %o2
20139f4: 9a 10 20 00 clr %o5
20139f8: 40 00 32 cb call 2020524 <rtems_rfs_link>
20139fc: b0 10 20 00 clr %i0
if (rc)
2013a00: 80 a2 20 00 cmp %o0, 0
2013a04: 02 80 00 05 be 2013a18 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
2013a08: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
2013a0c: 40 00 3e 17 call 2023268 <__errno> <== NOT EXECUTED
2013a10: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013a14: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2013a18: 81 c7 e0 08 ret
2013a1c: 81 e8 00 00 restore
020148ac <rtems_rfs_rtems_lock_by_mt_entry>:
static void
rtems_rfs_rtems_lock_by_mt_entry (
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
20148ac: 9d e3 bf a0 save %sp, -96, %sp
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
20148b0: c2 06 20 08 ld [ %i0 + 8 ], %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);
20148b4: 92 10 20 00 clr %o1
/* FIXME: Return value? */
rtems_rfs_fs_close(fs);
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
}
20148b8: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
20148bc: 94 10 20 00 clr %o2
20148c0: 7f ff e3 6b call 200d66c <rtems_semaphore_obtain>
20148c4: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20148c8: ba 92 20 00 orcc %o0, 0, %i5
20148cc: 12 80 00 04 bne 20148dc <rtems_rfs_rtems_lock_by_mt_entry+0x30><== NEVER TAKEN
20148d0: 90 10 20 00 clr %o0
20148d4: 81 c7 e0 08 ret
20148d8: 81 e8 00 00 restore
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20148dc: 40 00 00 56 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20148e0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20148e4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20148e8: 02 bf ff fb be 20148d4 <rtems_rfs_rtems_lock_by_mt_entry+0x28><== NOT EXECUTED
20148ec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
20148f0: 7f ff cf 2b call 200859c <rtems_status_text> <== NOT EXECUTED
20148f4: 31 00 80 d5 sethi %hi(0x2035400), %i0 <== NOT EXECUTED
20148f8: b0 16 21 68 or %i0, 0x168, %i0 ! 2035568 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
20148fc: 40 00 3f ec call 20248ac <printf> <== NOT EXECUTED
2014900: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
02013eac <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)
{
2013eac: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
2013eb0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
2013eb4: e0 06 20 08 ld [ %i0 + 8 ], %l0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
2013eb8: 40 00 11 a5 call 201854c <geteuid>
2013ebc: f0 00 60 08 ld [ %g1 + 8 ], %i0
gid = getegid ();
2013ec0: 40 00 11 9f call 201853c <getegid>
2013ec4: a2 10 00 08 mov %o0, %l1
2013ec8: a4 10 00 08 mov %o0, %l2
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
2013ecc: 40 00 02 d5 call 2014a20 <rtems_rfs_rtems_imode>
2013ed0: 90 10 00 1b mov %i3, %o0
2013ed4: 82 07 bf d4 add %fp, -44, %g1
2013ed8: 99 2a 20 10 sll %o0, 0x10, %o4
2013edc: 96 10 00 1a mov %i2, %o3
2013ee0: a3 2c 60 10 sll %l1, 0x10, %l1
2013ee4: a5 2c a0 10 sll %l2, 0x10, %l2
2013ee8: a3 34 60 10 srl %l1, 0x10, %l1
2013eec: a5 34 a0 10 srl %l2, 0x10, %l2
2013ef0: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
2013ef4: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
2013ef8: 90 10 00 18 mov %i0, %o0
2013efc: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2013f00: 92 10 00 10 mov %l0, %o1
2013f04: 94 10 00 19 mov %i1, %o2
2013f08: 99 33 20 10 srl %o4, 0x10, %o4
2013f0c: 7f ff fd 75 call 20134e0 <rtems_rfs_inode_create>
2013f10: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
2013f14: b4 92 20 00 orcc %o0, 0, %i2
2013f18: 04 80 00 07 ble 2013f34 <rtems_rfs_rtems_mknod+0x88>
2013f1c: d2 07 bf d4 ld [ %fp + -44 ], %o1
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
2013f20: 40 00 3c d2 call 2023268 <__errno>
2013f24: b0 10 3f ff mov -1, %i0
2013f28: f4 22 00 00 st %i2, [ %o0 ]
2013f2c: 81 c7 e0 08 ret
2013f30: 81 e8 00 00 restore
if (rc > 0)
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2013f34: 90 10 00 18 mov %i0, %o0
2013f38: 94 07 bf d8 add %fp, -40, %o2
2013f3c: 7f ff fc 17 call 2012f98 <rtems_rfs_inode_open>
2013f40: 96 10 20 01 mov 1, %o3
if (rc > 0)
2013f44: b4 92 20 00 orcc %o0, 0, %i2
2013f48: 14 bf ff f6 bg 2013f20 <rtems_rfs_rtems_mknod+0x74> <== NEVER TAKEN
2013f4c: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
}
if (S_ISDIR(mode) || S_ISREG(mode))
2013f50: 05 00 00 20 sethi %hi(0x8000), %g2
2013f54: 82 0e c0 01 and %i3, %g1, %g1
2013f58: 80 a0 40 02 cmp %g1, %g2
2013f5c: 02 80 00 1a be 2013fc4 <rtems_rfs_rtems_mknod+0x118>
2013f60: 05 00 00 10 sethi %hi(0x4000), %g2
2013f64: 80 a0 40 02 cmp %g1, %g2
2013f68: 02 80 00 17 be 2013fc4 <rtems_rfs_rtems_mknod+0x118> <== ALWAYS TAKEN
2013f6c: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
2013f70: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
2013f74: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
2013f78: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2013f7c: 12 80 00 1e bne 2013ff4 <rtems_rfs_rtems_mknod+0x148> <== NOT EXECUTED
2013f80: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
2013f84: b3 37 20 18 srl %i4, 0x18, %i1 <== NOT EXECUTED
2013f88: b5 37 20 10 srl %i4, 0x10, %i2 <== NOT EXECUTED
2013f8c: b7 37 20 08 srl %i4, 8, %i3 <== NOT EXECUTED
2013f90: 89 37 60 18 srl %i5, 0x18, %g4 <== NOT EXECUTED
2013f94: 87 37 60 10 srl %i5, 0x10, %g3 <== NOT EXECUTED
2013f98: 85 37 60 08 srl %i5, 8, %g2 <== NOT EXECUTED
2013f9c: f8 28 60 1f stb %i4, [ %g1 + 0x1f ] <== NOT EXECUTED
2013fa0: f2 28 60 1c stb %i1, [ %g1 + 0x1c ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013fa4: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
2013fa8: f4 28 60 1d stb %i2, [ %g1 + 0x1d ] <== NOT EXECUTED
2013fac: f6 28 60 1e stb %i3, [ %g1 + 0x1e ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013fb0: f8 2f bf e8 stb %i4, [ %fp + -24 ] <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
2013fb4: c8 28 60 20 stb %g4, [ %g1 + 0x20 ] <== NOT EXECUTED
2013fb8: c6 28 60 21 stb %g3, [ %g1 + 0x21 ] <== NOT EXECUTED
2013fbc: c4 28 60 22 stb %g2, [ %g1 + 0x22 ] <== NOT EXECUTED
2013fc0: fa 28 60 23 stb %i5, [ %g1 + 0x23 ] <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
2013fc4: 90 10 00 18 mov %i0, %o0
2013fc8: 92 07 bf d8 add %fp, -40, %o1
2013fcc: 7f ff fc 6b call 2013178 <rtems_rfs_inode_close>
2013fd0: b0 10 20 00 clr %i0
if (rc > 0)
2013fd4: 80 a2 20 00 cmp %o0, 0
2013fd8: 04 bf ff d5 ble 2013f2c <rtems_rfs_rtems_mknod+0x80> <== ALWAYS TAKEN
2013fdc: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
2013fe0: 40 00 3c a2 call 2023268 <__errno> <== NOT EXECUTED
2013fe4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013fe8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2013fec: 81 c7 e0 08 ret <== NOT EXECUTED
2013ff0: 81 e8 00 00 restore <== 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);
2013ff4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2013ff8: 7f ff fc 60 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2013ffc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
2014000: 40 00 3c 9a call 2023268 <__errno> <== NOT EXECUTED
2014004: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2014008: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201400c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014010: 81 c7 e0 08 ret <== NOT EXECUTED
2014014: 81 e8 00 00 restore <== NOT EXECUTED
02013e40 <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)
{
2013e40: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013e44: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2013e48: 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);
2013e4c: f8 00 60 08 ld [ %g1 + 8 ], %i4
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);
2013e50: 94 07 bf d8 add %fp, -40, %o2
2013e54: 90 10 00 1c mov %i4, %o0
2013e58: 7f ff fc 50 call 2012f98 <rtems_rfs_inode_open>
2013e5c: 96 10 20 01 mov 1, %o3
if (rc > 0)
2013e60: ba 92 20 00 orcc %o0, 0, %i5
2013e64: 04 80 00 07 ble 2013e80 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
2013e68: 01 00 00 00 nop
type = rtems_rfs_rtems_node_type_by_inode (&inode);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
2013e6c: 40 00 3c ff call 2023268 <__errno> <== NOT EXECUTED
2013e70: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2013e74: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
2013e78: 81 c7 e0 08 ret <== NOT EXECUTED
2013e7c: 81 e8 00 00 restore <== NOT EXECUTED
if (rc > 0)
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
2013e80: 7f ff fe 90 call 20138c0 <rtems_rfs_rtems_node_type_by_inode>
2013e84: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
2013e88: 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);
2013e8c: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
2013e90: 7f ff fc ba call 2013178 <rtems_rfs_inode_close>
2013e94: 90 10 00 1c mov %i4, %o0
if (rc > 0)
2013e98: ba 92 20 00 orcc %o0, 0, %i5
2013e9c: 14 bf ff f4 bg 2013e6c <rtems_rfs_rtems_node_type+0x2c> <== NEVER TAKEN
2013ea0: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
}
return type;
}
2013ea4: 81 c7 e0 08 ret
2013ea8: 81 e8 00 00 restore
02013af0 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
2013af0: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013af4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
2013af8: d2 06 20 08 ld [ %i0 + 8 ], %o1
2013afc: d0 00 60 08 ld [ %g1 + 8 ], %o0
2013b00: 94 10 00 19 mov %i1, %o2
2013b04: 96 10 00 1a mov %i2, %o3
2013b08: 40 00 34 a2 call 2020d90 <rtems_rfs_symlink_read>
2013b0c: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
2013b10: 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)
2013b14: 80 a2 20 00 cmp %o0, 0
2013b18: 02 80 00 05 be 2013b2c <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
2013b1c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
2013b20: 40 00 3d d2 call 2023268 <__errno> <== NOT EXECUTED
2013b24: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013b28: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
2013b2c: 81 c7 e0 08 ret
2013b30: 81 e8 00 00 restore
02013a20 <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)
{
2013a20: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
2013a24: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 <== 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);
2013a28: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== 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);
2013a2c: e0 00 60 08 ld [ %g1 + 8 ], %l0 <== 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);
2013a30: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
2013a34: 94 10 00 1c mov %i4, %o2 <== 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);
2013a38: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED
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);
2013a3c: f4 06 60 0c ld [ %i1 + 0xc ], %i2 <== 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);
2013a40: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2013a44: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2013a48: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
2013a4c: 40 00 32 b6 call 2020524 <rtems_rfs_link> <== NOT EXECUTED
2013a50: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
2013a54: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2013a58: 02 80 00 07 be 2013a74 <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
2013a5c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
2013a60: 40 00 3e 02 call 2023268 <__errno> <== NOT EXECUTED
2013a64: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013a68: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2013a6c: 81 c7 e0 08 ret <== NOT EXECUTED
2013a70: 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,
2013a74: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2013a78: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2013a7c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
2013a80: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
2013a84: 40 00 33 1c call 20206f4 <rtems_rfs_unlink> <== NOT EXECUTED
2013a88: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
2013a8c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2013a90: 02 bf ff f7 be 2013a6c <rtems_rfs_rtems_rename+0x4c> <== NOT EXECUTED
2013a94: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
2013a98: 40 00 3d f4 call 2023268 <__errno> <== NOT EXECUTED
2013a9c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013aa0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2013aa4: 81 c7 e0 08 ret <== NOT EXECUTED
2013aa8: 81 e8 00 00 restore <== NOT EXECUTED
02014938 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
2014938: 9d e3 bf a0 save %sp, -96, %sp
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
201493c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
2014940: 07 00 00 10 sethi %hi(0x4000), %g3
2014944: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
2014948: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
201494c: 83 28 60 08 sll %g1, 8, %g1
2014950: 82 10 40 02 or %g1, %g2, %g1
2014954: 05 00 00 3c sethi %hi(0xf000), %g2
2014958: 84 08 40 02 and %g1, %g2, %g2
201495c: 80 a0 80 03 cmp %g2, %g3
2014960: 02 80 00 1d be 20149d4 <rtems_rfs_rtems_set_handlers+0x9c>
2014964: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
2014968: 09 00 00 2c sethi %hi(0xb000), %g4
201496c: 07 00 00 08 sethi %hi(0x2000), %g3
2014970: 88 08 40 04 and %g1, %g4, %g4
2014974: 80 a1 00 03 cmp %g4, %g3
2014978: 02 80 00 10 be 20149b8 <rtems_rfs_rtems_set_handlers+0x80><== NEVER TAKEN
201497c: 07 00 00 28 sethi %hi(0xa000), %g3
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
2014980: 80 a0 80 03 cmp %g2, %g3
2014984: 02 80 00 22 be 2014a0c <rtems_rfs_rtems_set_handlers+0xd4>
2014988: 07 00 00 20 sethi %hi(0x8000), %g3
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
201498c: 80 a0 80 03 cmp %g2, %g3
2014990: 02 80 00 18 be 20149f0 <rtems_rfs_rtems_set_handlers+0xb8><== ALWAYS TAKEN
2014994: 93 28 60 10 sll %g1, 0x10, %o1
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
2014998: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
201499c: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
20149a0: 40 00 3f c3 call 20248ac <printf> <== NOT EXECUTED
20149a4: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
return false;
20149a8: 82 10 20 00 clr %g1 <== NOT EXECUTED
}
return true;
}
20149ac: b0 08 60 01 and %g1, 1, %i0
20149b0: 81 c7 e0 08 ret
20149b4: 81 e8 00 00 restore
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
20149b8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
20149bc: 05 00 80 dc sethi %hi(0x2037000), %g2 <== NOT EXECUTED
20149c0: 84 10 a3 bc or %g2, 0x3bc, %g2 ! 20373bc <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
20149c4: c4 26 20 10 st %g2, [ %i0 + 0x10 ] <== NOT EXECUTED
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
20149c8: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED
20149cc: 81 c7 e0 08 ret <== NOT EXECUTED
20149d0: 81 e8 00 00 restore <== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
20149d4: 82 10 20 01 mov 1, %g1
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
20149d8: 05 00 80 dc sethi %hi(0x2037000), %g2
20149dc: 84 10 a3 e8 or %g2, 0x3e8, %g2 ! 20373e8 <rtems_rfs_rtems_dir_handlers>
20149e0: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
20149e4: b0 08 60 01 and %g1, 1, %i0
20149e8: 81 c7 e0 08 ret
20149ec: 81 e8 00 00 restore
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
20149f0: 82 10 20 01 mov 1, %g1
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
20149f4: 05 00 80 dd sethi %hi(0x2037400), %g2
20149f8: 84 10 a0 14 or %g2, 0x14, %g2 ! 2037414 <rtems_rfs_rtems_file_handlers>
20149fc: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
2014a00: b0 08 60 01 and %g1, 1, %i0
2014a04: 81 c7 e0 08 ret
2014a08: 81 e8 00 00 restore
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
2014a0c: 05 00 80 d5 sethi %hi(0x2035400), %g2
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
2014a10: 82 10 20 01 mov 1, %g1
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
2014a14: 84 10 a1 e4 or %g2, 0x1e4, %g2
2014a18: 10 bf ff e5 b 20149ac <rtems_rfs_rtems_set_handlers+0x74>
2014a1c: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
02013944 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
2013944: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013948: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
201394c: 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);
2013950: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
2013954: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
2013958: 7f ff fd 2e call 2012e10 <rtems_rfs_group_usage> <== NOT EXECUTED
201395c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
2013960: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
2013964: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
2013968: c6 07 bf f8 ld [ %fp + -8 ], %g3 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
201396c: f0 07 60 08 ld [ %i5 + 8 ], %i0 <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
2013970: f4 00 60 20 ld [ %g1 + 0x20 ], %i2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
2013974: f6 00 60 1c ld [ %g1 + 0x1c ], %i3 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
2013978: f8 07 40 00 ld [ %i5 ], %i4 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
201397c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
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);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
2013980: c8 07 60 1c ld [ %i5 + 0x1c ], %g4 <== 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;
2013984: 86 20 80 03 sub %g2, %g3, %g3 <== 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;
2013988: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
201398c: f0 26 40 00 st %i0, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
2013990: 84 20 40 02 sub %g1, %g2, %g2 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
2013994: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== 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);
2013998: f4 26 60 04 st %i2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
201399c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
20139a0: f6 26 60 0c st %i3, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20139a4: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
20139a8: c6 26 60 14 st %g3, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
20139ac: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
20139b0: c6 26 60 1c st %g3, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
20139b4: c4 26 60 24 st %g2, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
20139b8: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
20139bc: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
20139c0: f8 26 60 30 st %i4, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
20139c4: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
20139c8: c8 26 60 34 st %g4, [ %i1 + 0x34 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
20139cc: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
20139d0: 81 c7 e0 08 ret <== NOT EXECUTED
20139d4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02013b34 <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)
{
2013b34: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
2013b38: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
target, strlen (target),
2013b3c: 90 10 00 1b mov %i3, %o0
2013b40: 40 00 47 cc call 2025a70 <strlen>
2013b44: f8 00 60 08 ld [ %g1 + 8 ], %i4
const char* node_name,
size_t node_name_len,
const char* target)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
2013b48: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
2013b4c: 40 00 12 80 call 201854c <geteuid>
2013b50: ba 10 00 08 mov %o0, %i5
2013b54: 40 00 12 7a call 201853c <getegid>
2013b58: a0 10 00 08 mov %o0, %l0
2013b5c: 91 2a 20 10 sll %o0, 0x10, %o0
2013b60: 91 32 20 10 srl %o0, 0x10, %o0
2013b64: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
2013b68: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
2013b6c: 98 10 00 1d mov %i5, %o4
2013b70: 9b 2c 20 10 sll %l0, 0x10, %o5
2013b74: 90 10 00 1c mov %i4, %o0
2013b78: 92 10 00 19 mov %i1, %o1
2013b7c: 94 10 00 1a mov %i2, %o2
2013b80: 96 10 00 1b mov %i3, %o3
2013b84: 9b 33 60 10 srl %o5, 0x10, %o5
2013b88: 40 00 33 e7 call 2020b24 <rtems_rfs_symlink>
2013b8c: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
2013b90: 80 a2 20 00 cmp %o0, 0
2013b94: 02 80 00 05 be 2013ba8 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
2013b98: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
2013b9c: 40 00 3d b3 call 2023268 <__errno> <== NOT EXECUTED
2013ba0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013ba4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2013ba8: 81 c7 e0 08 ret
2013bac: 81 e8 00 00 restore
020145d8 <rtems_rfs_rtems_unlock_by_mt_entry>:
static void
rtems_rfs_rtems_unlock_by_mt_entry (
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
20145d8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = mt_entry->fs_info;
20145dc: d0 06 20 08 ld [ %i0 + 8 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
20145e0: 40 00 23 bd call 201d4d4 <rtems_rfs_buffers_release>
20145e4: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
20145e8: 7f ff e4 70 call 200d7a8 <rtems_semaphore_release>
20145ec: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
20145f0: ba 92 20 00 orcc %o0, 0, %i5
20145f4: 12 80 00 04 bne 2014604 <rtems_rfs_rtems_unlock_by_mt_entry+0x2c><== NEVER TAKEN
20145f8: 90 10 20 00 clr %o0
20145fc: 81 c7 e0 08 ret
2014600: 81 e8 00 00 restore
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2014604: 40 00 01 0c call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2014608: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201460c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2014610: 02 bf ff fb be 20145fc <rtems_rfs_rtems_unlock_by_mt_entry+0x24><== NOT EXECUTED
2014614: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2014618: 7f ff cf e1 call 200859c <rtems_status_text> <== NOT EXECUTED
201461c: 31 00 80 d5 sethi %hi(0x2035400), %i0 <== NOT EXECUTED
2014620: b0 16 21 00 or %i0, 0x100, %i0 ! 2035500 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
2014624: 40 00 40 a2 call 20248ac <printf> <== NOT EXECUTED
2014628: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
02013bb0 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
2013bb0: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013bb4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2013bb8: 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);
2013bbc: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2013bc0: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
2013bc4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2013bc8: 7f ff fc f4 call 2012f98 <rtems_rfs_inode_open> <== NOT EXECUTED
2013bcc: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
2013bd0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2013bd4: 02 80 00 07 be 2013bf0 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
2013bd8: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
2013bdc: 40 00 3d a3 call 2023268 <__errno> <== NOT EXECUTED
2013be0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013be4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2013be8: 81 c7 e0 08 ret <== NOT EXECUTED
2013bec: 81 e8 00 00 restore <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
2013bf0: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
2013bf4: 87 36 60 10 srl %i1, 0x10, %g3 <== NOT EXECUTED
2013bf8: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
2013bfc: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
2013c00: c6 28 60 11 stb %g3, [ %g1 + 0x11 ] <== NOT EXECUTED
2013c04: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013c08: 86 10 20 01 mov 1, %g3 <== 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);
2013c0c: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013c10: c6 2f bf e8 stb %g3, [ %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);
2013c14: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
2013c18: 87 36 a0 10 srl %i2, 0x10, %g3 <== NOT EXECUTED
2013c1c: 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);
2013c20: 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);
2013c24: 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);
2013c28: c6 28 60 15 stb %g3, [ %g1 + 0x15 ] <== NOT EXECUTED
2013c2c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
2013c30: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
2013c34: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2013c38: 7f ff fd 50 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2013c3c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
2013c40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2013c44: 02 bf ff e9 be 2013be8 <rtems_rfs_rtems_utime+0x38> <== NOT EXECUTED
2013c48: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
2013c4c: 40 00 3d 87 call 2023268 <__errno> <== NOT EXECUTED
2013c50: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013c54: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2013c58: 81 c7 e0 08 ret <== NOT EXECUTED
2013c5c: 81 e8 00 00 restore <== NOT EXECUTED
020117dc <rtems_rfs_rup_quotient>:
* Return a rounded up integer quotient given a dividend and divisor. That is:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
20117dc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
20117e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (dividend == 0)
20117e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20117e8: 02 80 00 06 be 2011800 <rtems_rfs_rup_quotient+0x24> <== NOT EXECUTED
20117ec: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
20117f0: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
20117f4: 7f ff c3 a8 call 2002694 <.udiv> <== NOT EXECUTED
20117f8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20117fc: b0 02 20 01 add %o0, 1, %i0 <== NOT EXECUTED
}
2011800: 81 c7 e0 08 ret <== NOT EXECUTED
2011804: 81 e8 00 00 restore <== NOT EXECUTED
0201cca4 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
201cca4: 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))
201cca8: 90 10 20 00 clr %o0
201ccac: 92 10 20 80 mov 0x80, %o1
201ccb0: 7f ff df 61 call 2014a34 <rtems_rfs_trace>
201ccb4: fa 06 20 08 ld [ %i0 + 8 ], %i5
201ccb8: 80 8a 20 ff btst 0xff, %o0
201ccbc: 32 80 00 37 bne,a 201cd98 <rtems_rfs_scan_chain+0xf4> <== NEVER TAKEN
201ccc0: d2 06 40 00 ld [ %i1 ], %o1 <== 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));
201ccc4: 39 00 80 d7 sethi %hi(0x2035c00), %i4
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))
201ccc8: 80 a7 40 18 cmp %i5, %i0
201cccc: 12 80 00 0b bne 201ccf8 <rtems_rfs_scan_chain+0x54> <== ALWAYS TAKEN
201ccd0: b8 17 22 78 or %i4, 0x278, %i4
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201ccd4: 10 80 00 2a b 201cd7c <rtems_rfs_scan_chain+0xd8> <== NOT EXECUTED
201ccd8: 90 10 20 00 clr %o0 <== NOT EXECUTED
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
201ccdc: 80 a0 40 1a cmp %g1, %i2
201cce0: 02 80 00 14 be 201cd30 <rtems_rfs_scan_chain+0x8c>
201cce4: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
201cce8: fa 07 60 04 ld [ %i5 + 4 ], %i5
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))
201ccec: 80 a7 40 18 cmp %i5, %i0
201ccf0: 02 80 00 23 be 201cd7c <rtems_rfs_scan_chain+0xd8>
201ccf4: 90 10 20 00 clr %o0
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201ccf8: 90 10 20 00 clr %o0
201ccfc: 7f ff df 4e call 2014a34 <rtems_rfs_trace>
201cd00: 92 10 20 80 mov 0x80, %o1
201cd04: 80 8a 20 ff btst 0xff, %o0
201cd08: 22 bf ff f5 be,a 201ccdc <rtems_rfs_scan_chain+0x38> <== ALWAYS TAKEN
201cd0c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
201cd10: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
201cd14: 40 00 1e e6 call 20248ac <printf> <== NOT EXECUTED
201cd18: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
201cd1c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
201cd20: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
201cd24: 32 bf ff f2 bne,a 201ccec <rtems_rfs_scan_chain+0x48> <== NOT EXECUTED
201cd28: fa 07 60 04 ld [ %i5 + 4 ], %i5 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201cd2c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201cd30: 7f ff df 41 call 2014a34 <rtems_rfs_trace>
201cd34: 92 10 20 80 mov 0x80, %o1
201cd38: 80 8a 20 ff btst 0xff, %o0
201cd3c: 22 80 00 07 be,a 201cd58 <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
201cd40: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
201cd44: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
201cd48: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201cd4c: 40 00 1e d8 call 20248ac <printf> <== NOT EXECUTED
201cd50: 90 12 22 80 or %o0, 0x280, %o0 ! 2035e80 <CSWTCH.2+0x16c> <== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
201cd54: 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 );
201cd58: 90 10 00 1d mov %i5, %o0
201cd5c: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
201cd60: b0 10 00 1d mov %i5, %i0
201cd64: 7f ff f3 8a call 2019b8c <_Chain_Extract>
201cd68: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
201cd6c: c0 27 60 04 clr [ %i5 + 4 ]
201cd70: c0 27 40 00 clr [ %i5 ]
201cd74: 81 c7 e0 08 ret
201cd78: 81 e8 00 00 restore
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201cd7c: 7f ff df 2e call 2014a34 <rtems_rfs_trace>
201cd80: 92 10 20 80 mov 0x80, %o1
201cd84: 80 8a 20 ff btst 0xff, %o0
201cd88: 12 80 00 0a bne 201cdb0 <rtems_rfs_scan_chain+0x10c> <== NEVER TAKEN
201cd8c: 11 00 80 d7 sethi %hi(0x2035c00), %o0
printf (": not found\n");
return NULL;
}
201cd90: 81 c7 e0 08 ret
201cd94: 91 e8 20 00 restore %g0, 0, %o0
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
201cd98: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201cd9c: 11 00 80 d7 sethi %hi(0x2035c00), %o0 <== NOT EXECUTED
201cda0: 40 00 1e c3 call 20248ac <printf> <== NOT EXECUTED
201cda4: 90 12 22 48 or %o0, 0x248, %o0 ! 2035e48 <CSWTCH.2+0x134> <== 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));
201cda8: 10 bf ff c8 b 201ccc8 <rtems_rfs_scan_chain+0x24> <== NOT EXECUTED
201cdac: 39 00 80 d7 sethi %hi(0x2035c00), %i4 <== NOT EXECUTED
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": not found\n");
return NULL;
201cdb0: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": not found\n");
201cdb4: 40 00 1f 56 call 2024b0c <puts> <== NOT EXECUTED
201cdb8: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED
return NULL;
}
201cdbc: 81 c7 e0 08 ret <== NOT EXECUTED
201cdc0: 81 e8 00 00 restore <== NOT EXECUTED
0201b394 <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,
201b394: 9d e3 bf 90 save %sp, -112, %sp
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
201b398: 90 10 00 18 mov %i0, %o0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
201b39c: ac 10 00 18 mov %i0, %l6
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
201b3a0: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
201b3a4: 7f ff ff e7 call 201b340 <rtems_rfs_bitmap_load_map>
201b3a8: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
201b3ac: b0 92 20 00 orcc %o0, 0, %i0
201b3b0: 24 80 00 04 ble,a 201b3c0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2c><== ALWAYS TAKEN
201b3b4: f8 06 40 00 ld [ %i1 ], %i4
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
}
201b3b8: 81 c7 e0 08 ret <== NOT EXECUTED
201b3bc: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
end_bit = test_bit + (window * direction);
201b3c0: a1 2e e0 0b sll %i3, 0xb, %l0
if (end_bit < 0)
201b3c4: a0 84 00 1c addcc %l0, %i4, %l0
201b3c8: 2c 80 00 06 bneg,a 201b3e0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
201b3cc: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
201b3d0: c2 05 a0 0c ld [ %l6 + 0xc ], %g1
201b3d4: 80 a4 00 01 cmp %l0, %g1
201b3d8: 3a 80 00 02 bcc,a 201b3e0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
201b3dc: 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];
201b3e0: ee 05 a0 14 ld [ %l6 + 0x14 ], %l7
map_bits = &map[map_index];
201b3e4: e6 07 bf fc ld [ %fp + -4 ], %l3
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);
201b3e8: a5 3f 20 05 sra %i4, 5, %l2
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
201b3ec: 83 2c a0 02 sll %l2, 2, %g1
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
201b3f0: 85 3f 20 0a sra %i4, 0xa, %g2
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
201b3f4: ab 36 e0 1f srl %i3, 0x1f, %l5
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];
201b3f8: 85 28 a0 02 sll %g2, 2, %g2
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)))
201b3fc: a9 3e e0 1f sra %i3, 0x1f, %l4
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
201b400: a6 04 c0 01 add %l3, %g1, %l3
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)))
201b404: a8 25 00 1b sub %l4, %i3, %l4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
201b408: 82 0d 60 ff and %l5, 0xff, %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);
201b40c: ba 0f 20 1f and %i4, 0x1f, %i5
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
201b410: 92 0c a0 1f and %l2, 0x1f, %o1
search_bits = &control->search_bits[search_index];
201b414: ae 05 c0 02 add %l7, %g2, %l7
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
201b418: b1 2e e0 02 sll %i3, 2, %i0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
201b41c: 97 2e e0 05 sll %i3, 5, %o3
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
201b420: a2 10 20 01 mov 1, %l1
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
201b424: c2 27 bf f4 st %g1, [ %fp + -12 ]
|| ((direction > 0) && (test_bit >= end_bit)))
201b428: a9 35 20 1f srl %l4, 0x1f, %l4
/*
* 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))
201b42c: c8 05 c0 00 ld [ %l7 ], %g4
201b430: 80 a1 20 00 cmp %g4, 0
201b434: 02 80 00 49 be 201b558 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1c4>
201b438: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
201b43c: 86 06 c0 12 add %i3, %l2, %g3
201b440: 87 28 e0 05 sll %g3, 5, %g3
* 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)
201b444: 80 a2 60 1f cmp %o1, 0x1f
201b448: 18 80 00 52 bgu 201b590 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1fc>
201b44c: 9f 2c 40 09 sll %l1, %o1, %o7
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
201b450: 80 8b c0 04 btst %o7, %g4
201b454: 22 80 00 13 be,a 201b4a0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x10c>
201b458: a6 04 c0 18 add %l3, %i0, %l3
* 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))
201b45c: c4 04 c0 00 ld [ %l3 ], %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);
201b460: 83 2c 40 1d sll %l1, %i5, %g1
* 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))
201b464: 80 88 40 02 btst %g1, %g2
201b468: 02 80 00 0b be 201b494 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x100>
201b46c: 80 a4 00 1c cmp %l0, %i4
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
201b470: 10 80 00 55 b 201b5c4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x230>
201b474: 82 28 80 01 andn %g2, %g1, %g1
{
/*
* 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)
201b478: 80 a7 60 1f cmp %i5, 0x1f
201b47c: 18 80 00 08 bgu 201b49c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108><== NEVER TAKEN
201b480: b8 07 00 1b add %i4, %i3, %i4
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
201b484: 83 2c 40 1d sll %l1, %i5, %g1
* 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))
201b488: 80 88 80 01 btst %g2, %g1
201b48c: 12 80 00 4d bne 201b5c0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x22c>
201b490: 80 a4 00 1c cmp %l0, %i4
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
201b494: 32 bf ff f9 bne,a 201b478 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe4>
201b498: ba 07 40 1b add %i5, %i3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
201b49c: a6 04 c0 18 add %l3, %i0, %l3
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
201b4a0: 80 a6 e0 00 cmp %i3, 0
201b4a4: 04 80 00 44 ble 201b5b4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x220>
201b4a8: a4 04 80 1b add %l2, %i3, %l2
201b4ac: b8 10 20 00 clr %i4
201b4b0: ba 10 20 00 clr %i5
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
201b4b4: b8 00 c0 1c add %g3, %i4, %i4
search_offset += direction;
201b4b8: 92 02 40 1b add %o1, %i3, %o1
if (((direction < 0) && (test_bit <= end_bit))
201b4bc: 84 10 00 15 mov %l5, %g2
201b4c0: 80 a4 00 1c cmp %l0, %i4
201b4c4: 16 80 00 03 bge 201b4d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x13c>
201b4c8: 82 10 20 01 mov 1, %g1
201b4cc: 82 10 20 00 clr %g1
201b4d0: 80 88 60 ff btst 0xff, %g1
201b4d4: 32 80 00 5b bne,a 201b640 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2ac>
201b4d8: c2 07 bf f4 ld [ %fp + -12 ], %g1
201b4dc: 86 00 c0 0b add %g3, %o3, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
201b4e0: 80 a4 00 1c cmp %l0, %i4
201b4e4: 04 80 00 03 ble 201b4f0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c>
201b4e8: 82 10 20 01 mov 1, %g1
201b4ec: 82 10 20 00 clr %g1
201b4f0: 80 88 60 ff btst 0xff, %g1
201b4f4: 02 bf ff d5 be 201b448 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
201b4f8: 80 a2 60 1f cmp %o1, 0x1f
201b4fc: 80 a5 20 00 cmp %l4, 0
201b500: 02 bf ff d2 be 201b448 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
201b504: 80 a2 60 1f cmp %o1, 0x1f
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
201b508: ae 05 c0 18 add %l7, %i0, %l7
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)))
201b50c: 82 10 20 01 mov 1, %g1
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
201b510: 92 10 20 00 clr %o1
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
201b514: 80 88 60 ff btst 0xff, %g1
201b518: 02 80 00 06 be 201b530 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x19c>
201b51c: 80 a4 00 1c cmp %l0, %i4
201b520: 80 88 a0 ff btst 0xff, %g2
201b524: 32 bf ff c3 bne,a 201b430 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
201b528: c8 05 c0 00 ld [ %l7 ], %g4
201b52c: 80 a4 00 1c cmp %l0, %i4
201b530: 16 80 00 03 bge 201b53c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a8>
201b534: 82 10 20 01 mov 1, %g1
201b538: 82 10 20 00 clr %g1
201b53c: 80 88 60 ff btst 0xff, %g1
201b540: 02 80 00 04 be 201b550 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1bc>
201b544: 80 a5 20 00 cmp %l4, 0
201b548: 32 bf ff ba bne,a 201b430 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
201b54c: c8 05 c0 00 ld [ %l7 ], %g4
return 0;
201b550: 81 c7 e0 08 ret
201b554: 91 e8 20 00 restore %g0, 0, %o0
* 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)
201b558: 04 80 00 34 ble 201b628 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x294>
201b55c: b8 0f 3f e0 and %i4, -32, %i4
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
201b560: 82 10 20 20 mov 0x20, %g1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
201b564: ba 10 20 00 clr %i5
*/
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;
201b568: 92 20 40 09 sub %g1, %o1, %o1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
201b56c: 83 2a 60 05 sll %o1, 5, %g1
201b570: b8 00 40 1c add %g1, %i4, %i4
* 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;
201b574: d6 27 bf f0 st %o3, [ %fp + -16 ]
201b578: 7f ff 9c 0d call 20025ac <.umul>
201b57c: 90 10 00 1b mov %i3, %o0
201b580: d6 07 bf f0 ld [ %fp + -16 ], %o3
201b584: 83 2a 20 02 sll %o0, 2, %g1
map_index += direction * bits_skipped;
201b588: a4 04 80 08 add %l2, %o0, %l2
* 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;
201b58c: a6 04 c0 01 add %l3, %g1, %l3
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
201b590: 80 a6 e0 00 cmp %i3, 0
201b594: 04 80 00 1c ble 201b604 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x270>
201b598: ae 05 c0 18 add %l7, %i0, %l7
201b59c: 80 a4 00 1c cmp %l0, %i4
201b5a0: 04 80 00 03 ble 201b5ac <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
201b5a4: 82 10 20 01 mov 1, %g1
201b5a8: 82 10 20 00 clr %g1
201b5ac: 10 bf ff d9 b 201b510 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c>
201b5b0: 84 10 20 00 clr %g2
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
201b5b4: b8 10 20 1f mov 0x1f, %i4
201b5b8: 10 bf ff bf b 201b4b4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x120>
201b5bc: ba 10 20 1f mov 0x1f, %i5
*/
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);
201b5c0: 82 28 80 01 andn %g2, %g1, %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,
201b5c4: 80 a0 60 00 cmp %g1, 0
201b5c8: 12 80 00 05 bne 201b5dc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x248>
201b5cc: c2 24 c0 00 st %g1, [ %l3 ]
*/
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);
201b5d0: c2 05 c0 00 ld [ %l7 ], %g1
201b5d4: 9e 28 40 0f andn %g1, %o7, %o7
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
201b5d8: de 25 c0 00 st %o7, [ %l7 ]
1 << search_offset);
control->free--;
201b5dc: c2 05 a0 10 ld [ %l6 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
201b5e0: c4 05 80 00 ld [ %l6 ], %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--;
201b5e4: 82 00 7f ff add %g1, -1, %g1
201b5e8: c2 25 a0 10 st %g1, [ %l6 + 0x10 ]
*bit = test_bit;
201b5ec: f8 26 40 00 st %i4, [ %i1 ]
*found = true;
201b5f0: 82 10 20 01 mov 1, %g1
201b5f4: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
201b5f8: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
201b5fc: 81 c7 e0 08 ret
201b600: 91 e8 20 00 restore %g0, 0, %o0
201b604: 84 10 00 15 mov %l5, %g2
201b608: 80 a4 00 1c cmp %l0, %i4
201b60c: 14 80 00 04 bg 201b61c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x288>
201b610: 82 10 20 01 mov 1, %g1
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
201b614: 10 bf ff c0 b 201b514 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
201b618: 92 10 20 1f mov 0x1f, %o1
201b61c: 82 10 20 00 clr %g1
201b620: 10 bf ff bd b 201b514 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
201b624: 92 10 20 1f mov 0x1f, %o1
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;
201b628: 83 2a 60 05 sll %o1, 5, %g1
map_offset = rtems_rfs_bitmap_element_bits () - 1;
201b62c: ba 10 20 1f mov 0x1f, %i5
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;
201b630: 82 38 00 01 xnor %g0, %g1, %g1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
201b634: 92 02 60 01 inc %o1
/*
* 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;
201b638: 10 bf ff cf b 201b574 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e0>
201b63c: b8 00 40 1c add %g1, %i4, %i4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
201b640: 80 a0 60 00 cmp %g1, 0
201b644: 22 bf ff a7 be,a 201b4e0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x14c>
201b648: 86 00 c0 0b add %g3, %o3, %g3
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
201b64c: ae 05 c0 18 add %l7, %i0, %l7
201b650: 80 a4 00 1c cmp %l0, %i4
201b654: 04 80 00 03 ble 201b660 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2cc><== NEVER TAKEN
201b658: 82 10 20 01 mov 1, %g1
201b65c: 82 10 20 00 clr %g1
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
201b660: 84 10 20 01 mov 1, %g2
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
201b664: 10 bf ff ac b 201b514 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
201b668: 92 10 20 1f mov 0x1f, %o1
02020b24 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
2020b24: 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))
2020b28: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
2020b2c: e4 17 a0 5e lduh [ %fp + 0x5e ], %l2
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
2020b30: 7f ff cf c1 call 2014a34 <rtems_rfs_trace>
2020b34: 92 10 20 00 clr %o1
2020b38: 80 8a 20 ff btst 0xff, %o0
2020b3c: 32 80 00 08 bne,a 2020b5c <rtems_rfs_symlink+0x38> <== NEVER TAKEN
2020b40: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
2020b44: c2 06 20 08 ld [ %i0 + 8 ], %g1
2020b48: 80 a7 00 01 cmp %i4, %g1
2020b4c: 0a 80 00 22 bcs 2020bd4 <rtems_rfs_symlink+0xb0> <== ALWAYS TAKEN
2020b50: b4 10 20 5b mov 0x5b, %i2
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
2020b54: 81 c7 e0 08 ret
2020b58: 91 e8 00 1a restore %g0, %i2, %o0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
2020b5c: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020b60: 40 00 0f 53 call 20248ac <printf> <== NOT EXECUTED
2020b64: 90 12 23 18 or %o0, 0x318, %o0 ! 2037318 <CSWTCH.2+0x1604><== NOT EXECUTED
2020b68: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
2020b6c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2020b70: 04 80 00 08 ble 2020b90 <rtems_rfs_symlink+0x6c> <== NOT EXECUTED
2020b74: a2 06 40 1a add %i1, %i2, %l1 <== NOT EXECUTED
printf ("%c", name[c]);
2020b78: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
2020b7c: 40 00 0f b6 call 2024a54 <putchar> <== NOT EXECUTED
2020b80: a0 04 20 01 inc %l0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
2020b84: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED
2020b88: 32 bf ff fd bne,a 2020b7c <rtems_rfs_symlink+0x58> <== NOT EXECUTED
2020b8c: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
2020b90: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020b94: 40 00 0f 46 call 20248ac <printf> <== NOT EXECUTED
2020b98: 90 12 23 40 or %o0, 0x340, %o0 ! 2037340 <CSWTCH.2+0x162c><== NOT EXECUTED
2020b9c: b4 10 00 1b mov %i3, %i2 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
2020ba0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2020ba4: 04 bf ff e8 ble 2020b44 <rtems_rfs_symlink+0x20> <== NOT EXECUTED
2020ba8: a0 07 00 1b add %i4, %i3, %l0 <== NOT EXECUTED
printf ("%c", link[c]);
2020bac: d0 4e 80 00 ldsb [ %i2 ], %o0 <== NOT EXECUTED
2020bb0: 40 00 0f a9 call 2024a54 <putchar> <== NOT EXECUTED
2020bb4: 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++)
2020bb8: 80 a6 80 10 cmp %i2, %l0 <== NOT EXECUTED
2020bbc: 32 bf ff fd bne,a 2020bb0 <rtems_rfs_symlink+0x8c> <== NOT EXECUTED
2020bc0: d0 4e 80 00 ldsb [ %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
2020bc4: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
2020bc8: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2020bcc: 1a bf ff e2 bcc 2020b54 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
2020bd0: b4 10 20 5b mov 0x5b, %i2 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
2020bd4: 40 00 13 a7 call 2025a70 <strlen>
2020bd8: 90 10 00 19 mov %i1, %o0
2020bdc: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
2020be0: 82 07 bf 74 add %fp, -140, %g1
2020be4: 96 10 00 08 mov %o0, %o3
2020be8: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
2020bec: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
2020bf0: 90 10 00 18 mov %i0, %o0
2020bf4: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2020bf8: 94 10 00 19 mov %i1, %o2
2020bfc: 9a 10 20 01 mov 1, %o5
2020c00: 19 00 00 28 sethi %hi(0xa000), %o4
2020c04: 7f ff ca 37 call 20134e0 <rtems_rfs_inode_create>
2020c08: 98 13 21 ff or %o4, 0x1ff, %o4 ! a1ff <PROM_START+0xa1ff>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
2020c0c: b4 92 20 00 orcc %o0, 0, %i2
2020c10: 14 bf ff d1 bg 2020b54 <rtems_rfs_symlink+0x30> <== NEVER TAKEN
2020c14: d2 07 bf 74 ld [ %fp + -140 ], %o1
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2020c18: 90 10 00 18 mov %i0, %o0
2020c1c: 94 07 bf 88 add %fp, -120, %o2
2020c20: 7f ff c8 de call 2012f98 <rtems_rfs_inode_open>
2020c24: 96 10 20 01 mov 1, %o3
if (rc > 0)
2020c28: b4 92 20 00 orcc %o0, 0, %i2
2020c2c: 14 bf ff ca bg 2020b54 <rtems_rfs_symlink+0x30> <== NEVER TAKEN
2020c30: 80 a7 20 13 cmp %i4, 0x13
/*
* 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)
2020c34: 38 80 00 20 bgu,a 2020cb4 <rtems_rfs_symlink+0x190> <== NEVER TAKEN
2020c38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
2020c3c: d0 07 bf 94 ld [ %fp + -108 ], %o0
2020c40: 92 10 20 00 clr %o1
2020c44: 94 10 20 14 mov 0x14, %o2
2020c48: 40 00 0e 9b call 20246b4 <memset>
2020c4c: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
2020c50: d0 07 bf 94 ld [ %fp + -108 ], %o0
2020c54: 92 10 00 1b mov %i3, %o1
2020c58: 90 02 20 1c add %o0, 0x1c, %o0
2020c5c: 40 00 0e 07 call 2024478 <memcpy>
2020c60: 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);
2020c64: c2 07 bf 94 ld [ %fp + -108 ], %g1
2020c68: c0 28 60 0c clrb [ %g1 + 0xc ]
2020c6c: c2 07 bf 94 ld [ %fp + -108 ], %g1
2020c70: c0 28 60 0d clrb [ %g1 + 0xd ]
2020c74: c2 07 bf 94 ld [ %fp + -108 ], %g1
2020c78: c0 28 60 0e clrb [ %g1 + 0xe ]
2020c7c: c2 07 bf 94 ld [ %fp + -108 ], %g1
2020c80: c0 28 60 0f clrb [ %g1 + 0xf ]
*/
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);
2020c84: c2 07 bf 94 ld [ %fp + -108 ], %g1
2020c88: 85 37 20 08 srl %i4, 8, %g2
2020c8c: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
2020c90: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
2020c94: 90 10 00 18 mov %i0, %o0
2020c98: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2020c9c: 82 10 20 01 mov 1, %g1
2020ca0: 92 07 bf 88 add %fp, -120, %o1
2020ca4: 7f ff c9 35 call 2013178 <rtems_rfs_inode_close>
2020ca8: c2 2f bf 98 stb %g1, [ %fp + -104 ]
2020cac: 10 bf ff aa b 2020b54 <rtems_rfs_symlink+0x30>
2020cb0: b4 10 00 08 mov %o0, %i2
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);
2020cb4: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
2020cb8: 7f ff ec b9 call 201bf9c <rtems_rfs_block_map_open> <== NOT EXECUTED
2020cbc: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
2020cc0: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
2020cc4: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2020cc8: 04 80 00 05 ble 2020cdc <rtems_rfs_symlink+0x1b8> <== NOT EXECUTED
2020ccc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
2020cd0: 7f ff c9 2a call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2020cd4: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
2020cd8: 30 bf ff 9f b,a 2020b54 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
2020cdc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
2020ce0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2020ce4: 7f ff ee 07 call 201c500 <rtems_rfs_block_map_grow> <== NOT EXECUTED
2020ce8: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
2020cec: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2020cf0: 04 80 00 07 ble 2020d0c <rtems_rfs_symlink+0x1e8> <== NOT EXECUTED
2020cf4: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
2020cf8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020cfc: 7f ff ed 09 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
2020d00: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
2020d04: 10 bf ff f3 b 2020cd0 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
2020d08: 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;
2020d0c: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
2020d10: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
2020d14: c0 27 bf 84 clr [ %fp + -124 ] <== 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);
2020d18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020d1c: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
2020d20: 7f ff f0 a3 call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2020d24: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
2020d28: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2020d2c: 14 bf ff f4 bg 2020cfc <rtems_rfs_symlink+0x1d8> <== NOT EXECUTED
2020d30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
2020d34: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
2020d38: 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);
2020d3c: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
2020d40: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
2020d44: 40 00 0e 5c call 20246b4 <memset> <== NOT EXECUTED
2020d48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
2020d4c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2020d50: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2020d54: 40 00 0d c9 call 2024478 <memcpy> <== NOT EXECUTED
2020d58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
2020d5c: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
2020d60: 7f ff f0 19 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2020d64: 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);
2020d68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2020d6c: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
2020d70: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
2020d74: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
2020d78: 7f ff ec ea call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
2020d7c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
2020d80: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2020d84: 04 bf ff c0 ble 2020c84 <rtems_rfs_symlink+0x160> <== NOT EXECUTED
2020d88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020d8c: 30 bf ff d1 b,a 2020cd0 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
02020d90 <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)
{
2020d90: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
2020d94: 90 10 20 04 mov 4, %o0
2020d98: 7f ff cf 27 call 2014a34 <rtems_rfs_trace>
2020d9c: 92 10 20 00 clr %o1
2020da0: 80 8a 20 ff btst 0xff, %o0
2020da4: 12 80 00 17 bne 2020e00 <rtems_rfs_symlink_read+0x70> <== NEVER TAKEN
2020da8: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
2020dac: 90 10 00 18 mov %i0, %o0
2020db0: 92 10 00 19 mov %i1, %o1
2020db4: 94 07 bf 88 add %fp, -120, %o2
2020db8: 7f ff c8 78 call 2012f98 <rtems_rfs_inode_open>
2020dbc: 96 10 20 01 mov 1, %o3
if (rc)
2020dc0: ba 92 20 00 orcc %o0, 0, %i5
2020dc4: 12 80 00 0d bne 2020df8 <rtems_rfs_symlink_read+0x68> <== NEVER TAKEN
2020dc8: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
2020dcc: 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);
2020dd0: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
2020dd4: 85 28 a0 08 sll %g2, 8, %g2
2020dd8: 84 08 80 01 and %g2, %g1, %g2
2020ddc: 03 00 00 28 sethi %hi(0xa000), %g1
2020de0: 80 a0 80 01 cmp %g2, %g1
2020de4: 02 80 00 0c be 2020e14 <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
2020de8: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &inode);
2020dec: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
2020df0: 7f ff c8 e2 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2020df4: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
2020df8: 81 c7 e0 08 ret
2020dfc: 91 e8 00 1d restore %g0, %i5, %o0
{
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
2020e00: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020e04: 40 00 0e aa call 20248ac <printf> <== NOT EXECUTED
2020e08: 90 12 23 48 or %o0, 0x348, %o0 ! 2037348 <CSWTCH.2+0x1634><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
2020e0c: 10 bf ff e9 b 2020db0 <rtems_rfs_symlink_read+0x20> <== NOT EXECUTED
2020e10: 90 10 00 18 mov %i0, %o0 <== 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);
2020e14: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
2020e18: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
2020e1c: 95 2a a0 08 sll %o2, 8, %o2
2020e20: 94 10 40 0a or %g1, %o2, %o2
2020e24: 80 a2 80 1b cmp %o2, %i3
2020e28: 38 80 00 02 bgu,a 2020e30 <rtems_rfs_symlink_read+0xa0>
2020e2c: 94 10 00 1b mov %i3, %o2
2020e30: 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);
2020e34: c8 0a 60 0c ldub [ %o1 + 0xc ], %g4
2020e38: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
2020e3c: c6 0a 60 0f ldub [ %o1 + 0xf ], %g3
2020e40: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
2020e44: 89 29 20 18 sll %g4, 0x18, %g4
2020e48: 85 28 a0 10 sll %g2, 0x10, %g2
2020e4c: 83 28 60 08 sll %g1, 8, %g1
2020e50: 84 11 00 02 or %g4, %g2, %g2
2020e54: 84 10 80 03 or %g2, %g3, %g2
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
2020e58: 80 90 80 01 orcc %g2, %g1, %g0
2020e5c: 12 80 00 0a bne 2020e84 <rtems_rfs_symlink_read+0xf4> <== NEVER TAKEN
2020e60: 90 10 00 18 mov %i0, %o0
{
memcpy (path, inode.node->data.name, *length);
2020e64: 90 10 00 1a mov %i2, %o0
2020e68: 40 00 0d 84 call 2024478 <memcpy>
2020e6c: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
2020e70: 90 10 00 18 mov %i0, %o0
2020e74: 7f ff c8 c1 call 2013178 <rtems_rfs_inode_close>
2020e78: 92 07 bf 88 add %fp, -120, %o1
2020e7c: 10 bf ff df b 2020df8 <rtems_rfs_symlink_read+0x68>
2020e80: ba 10 00 08 mov %o0, %i5
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);
2020e84: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
2020e88: 7f ff ec 45 call 201bf9c <rtems_rfs_block_map_open> <== NOT EXECUTED
2020e8c: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
2020e90: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
if (rc > 0)
2020e94: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2020e98: 04 80 00 05 ble 2020eac <rtems_rfs_symlink_read+0x11c> <== NOT EXECUTED
2020e9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
2020ea0: 7f ff c8 b6 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2020ea4: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
2020ea8: 30 bf ff d4 b,a 2020df8 <rtems_rfs_symlink_read+0x68> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
2020eac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
2020eb0: 94 10 20 00 clr %o2 <== NOT EXECUTED
2020eb4: 96 10 20 00 clr %o3 <== NOT EXECUTED
2020eb8: 7f ff ed 68 call 201c458 <rtems_rfs_block_map_seek> <== NOT EXECUTED
2020ebc: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
2020ec0: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2020ec4: 04 80 00 09 ble 2020ee8 <rtems_rfs_symlink_read+0x158> <== NOT EXECUTED
2020ec8: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
2020ecc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
2020ed0: 7f ff ec 94 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
2020ed4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
2020ed8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020edc: 7f ff c8 a7 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2020ee0: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
2020ee4: 30 bf ff c5 b,a 2020df8 <rtems_rfs_symlink_read+0x68> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2020ee8: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
2020eec: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
2020ef0: c0 27 bf 84 clr [ %fp + -124 ] <== 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);
2020ef4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020ef8: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
2020efc: 7f ff f0 2c call 201cfac <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2020f00: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
2020f04: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2020f08: 34 bf ff f2 bg,a 2020ed0 <rtems_rfs_symlink_read+0x140> <== NOT EXECUTED
2020f0c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
2020f10: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
2020f14: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
2020f18: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
2020f1c: 40 00 0d 57 call 2024478 <memcpy> <== NOT EXECUTED
2020f20: 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);
2020f24: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
2020f28: 7f ff ef a7 call 201cdc4 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2020f2c: 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);
2020f30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2020f34: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
2020f38: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
2020f3c: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
2020f40: 7f ff ec 78 call 201c120 <rtems_rfs_block_map_close> <== NOT EXECUTED
2020f44: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
2020f48: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2020f4c: 04 bf ff c9 ble 2020e70 <rtems_rfs_symlink_read+0xe0> <== NOT EXECUTED
2020f50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020f54: 30 bf ff d3 b,a 2020ea0 <rtems_rfs_symlink_read+0x110> <== NOT EXECUTED
02014a74 <rtems_rfs_trace_clear_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
2014a74: 03 00 81 23 sethi %hi(0x2048c00), %g1 <== NOT EXECUTED
2014a78: c4 18 61 d0 ldd [ %g1 + 0x1d0 ], %g2 ! 2048dd0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
2014a7c: 98 28 80 08 andn %g2, %o0, %o4 <== NOT EXECUTED
2014a80: 9a 28 c0 09 andn %g3, %o1, %o5 <== NOT EXECUTED
return state;
}
2014a84: 90 10 00 02 mov %g2, %o0 <== 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;
2014a88: d8 38 61 d0 std %o4, [ %g1 + 0x1d0 ] <== NOT EXECUTED
return state;
}
2014a8c: 81 c3 e0 08 retl <== NOT EXECUTED
2014a90: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
02014a54 <rtems_rfs_trace_set_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
2014a54: 03 00 81 23 sethi %hi(0x2048c00), %g1 <== NOT EXECUTED
2014a58: c4 18 61 d0 ldd [ %g1 + 0x1d0 ], %g2 ! 2048dd0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
2014a5c: 98 12 00 02 or %o0, %g2, %o4 <== NOT EXECUTED
2014a60: 9a 12 40 03 or %o1, %g3, %o5 <== NOT EXECUTED
return state;
}
2014a64: 90 10 00 02 mov %g2, %o0 <== 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;
2014a68: d8 38 61 d0 std %o4, [ %g1 + 0x1d0 ] <== NOT EXECUTED
return state;
}
2014a6c: 81 c3 e0 08 retl <== NOT EXECUTED
2014a70: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
02014a94 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
2014a94: 9d e3 bf 00 save %sp, -256, %sp <== NOT EXECUTED
const char* table[] =
2014a98: 13 00 80 d6 sethi %hi(0x2035800), %o1 <== NOT EXECUTED
2014a9c: a8 07 bf 64 add %fp, -156, %l4 <== NOT EXECUTED
2014aa0: 92 12 61 1c or %o1, 0x11c, %o1 <== NOT EXECUTED
2014aa4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2014aa8: 40 00 3e 74 call 2024478 <memcpy> <== NOT EXECUTED
2014aac: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2014ab0: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
2014ab4: 04 80 00 3f ble 2014bb0 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
2014ab8: 01 00 00 00 nop <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2014abc: e4 06 60 04 ld [ %i1 + 4 ], %l2 <== NOT EXECUTED
2014ac0: c2 4c 80 00 ldsb [ %l2 ], %g1 <== NOT EXECUTED
2014ac4: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2014ac8: 02 80 00 6e be 2014c80 <rtems_rfs_trace_shell_command+0x1ec><== NOT EXECUTED
2014acc: 2f 00 81 23 sethi %hi(0x2048c00), %l7 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2014ad0: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
2014ad4: f8 1d e1 d0 ldd [ %l7 + 0x1d0 ], %i4 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
2014ad8: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
2014adc: b4 10 20 00 clr %i2 <== NOT EXECUTED
2014ae0: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
2014ae4: a0 10 20 00 clr %l0 <== NOT EXECUTED
2014ae8: a2 10 20 00 clr %l1 <== NOT EXECUTED
2014aec: 10 80 00 10 b 2014b2c <rtems_rfs_trace_shell_command+0x98><== NOT EXECUTED
2014af0: ae 15 e1 d0 or %l7, 0x1d0, %l7 <== NOT EXECUTED
2014af4: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
2014af8: aa 10 20 00 clr %l5 <== NOT EXECUTED
2014afc: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
2014b00: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2014b04: a6 04 e0 01 inc %l3 <== NOT EXECUTED
2014b08: 80 a4 c0 18 cmp %l3, %i0 <== NOT EXECUTED
2014b0c: 02 80 00 29 be 2014bb0 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
2014b10: f8 3d c0 00 std %i4, [ %l7 ] <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
2014b14: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED
int arg;
int t;
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
2014b18: e4 06 40 01 ld [ %i1 + %g1 ], %l2 <== NOT EXECUTED
2014b1c: c2 4c 80 00 ldsb [ %l2 ], %g1 <== NOT EXECUTED
2014b20: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2014b24: 22 80 00 58 be,a 2014c84 <rtems_rfs_trace_shell_command+0x1f0><== NOT EXECUTED
2014b28: c2 4c a0 01 ldsb [ %l2 + 1 ], %g1 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2014b2c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
2014b30: 13 00 80 cd sethi %hi(0x2033400), %o1 <== NOT EXECUTED
2014b34: 40 00 41 e5 call 20252c8 <strcmp> <== NOT EXECUTED
2014b38: 92 12 61 20 or %o1, 0x120, %o1 ! 2033520 <__FUNCTION__.7127+0x588><== NOT EXECUTED
2014b3c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014b40: 22 80 00 02 be,a 2014b48 <rtems_rfs_trace_shell_command+0xb4><== NOT EXECUTED
2014b44: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2014b48: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
2014b4c: 13 00 80 d5 sethi %hi(0x2035400), %o1 <== NOT EXECUTED
2014b50: 40 00 41 de call 20252c8 <strcmp> <== NOT EXECUTED
2014b54: 92 12 62 b0 or %o1, 0x2b0, %o1 ! 20356b0 <rtems_rfs_rtems_eval_config+0xa0><== NOT EXECUTED
2014b58: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014b5c: 22 bf ff e6 be,a 2014af4 <rtems_rfs_trace_shell_command+0x60><== NOT EXECUTED
2014b60: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
2014b64: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
2014b68: 13 00 80 d5 sethi %hi(0x2035400), %o1 <== NOT EXECUTED
2014b6c: 40 00 41 d7 call 20252c8 <strcmp> <== NOT EXECUTED
2014b70: 92 12 62 b8 or %o1, 0x2b8, %o1 ! 20356b8 <rtems_rfs_rtems_eval_config+0xa8><== NOT EXECUTED
2014b74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014b78: 12 80 00 13 bne 2014bc4 <rtems_rfs_trace_shell_command+0x130><== NOT EXECUTED
2014b7c: ac 10 20 00 clr %l6 <== NOT EXECUTED
{
if (set)
2014b80: 80 8d 60 ff btst 0xff, %l5 <== NOT EXECUTED
2014b84: 22 80 00 23 be,a 2014c10 <rtems_rfs_trace_shell_command+0x17c><== NOT EXECUTED
2014b88: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
2014b8c: b8 3e a0 00 xnor %i2, 0, %i4 <== NOT EXECUTED
2014b90: ba 3e e0 00 xnor %i3, 0, %i5 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
2014b94: f8 3d c0 00 std %i4, [ %l7 ] <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
2014b98: 21 3f ff ff sethi %hi(0xfffffc00), %l0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2014b9c: a6 04 e0 01 inc %l3 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
2014ba0: a0 14 23 ff or %l0, 0x3ff, %l0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2014ba4: 80 a4 c0 18 cmp %l3, %i0 <== NOT EXECUTED
2014ba8: 12 bf ff db bne 2014b14 <rtems_rfs_trace_shell_command+0x80><== NOT EXECUTED
2014bac: a2 10 00 10 mov %l0, %l1 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
2014bb0: 81 c7 e0 08 ret <== NOT EXECUTED
2014bb4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
2014bb8: 80 a5 a0 27 cmp %l6, 0x27 <== NOT EXECUTED
2014bbc: 22 80 00 11 be,a 2014c00 <rtems_rfs_trace_shell_command+0x16c><== NOT EXECUTED
2014bc0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
2014bc4: 85 2d a0 02 sll %l6, 2, %g2 <== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
2014bc8: d2 05 00 02 ld [ %l4 + %g2 ], %o1 <== NOT EXECUTED
2014bcc: 40 00 41 bf call 20252c8 <strcmp> <== NOT EXECUTED
2014bd0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
2014bd4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014bd8: 32 bf ff f8 bne,a 2014bb8 <rtems_rfs_trace_shell_command+0x124><== NOT EXECUTED
2014bdc: ac 05 a0 01 inc %l6 <== NOT EXECUTED
{
if (set)
2014be0: 80 8d 60 ff btst 0xff, %l5 <== NOT EXECUTED
2014be4: 02 80 00 10 be 2014c24 <rtems_rfs_trace_shell_command+0x190><== NOT EXECUTED
2014be8: 80 8d a0 20 btst 0x20, %l6 <== NOT EXECUTED
set_value = 1ULL << t;
2014bec: 12 80 00 1e bne 2014c64 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
2014bf0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2014bf4: a0 10 20 00 clr %l0 <== NOT EXECUTED
2014bf8: a3 28 40 16 sll %g1, %l6, %l1 <== NOT EXECUTED
2014bfc: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
2014c00: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
2014c04: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
2014c08: 10 bf ff bf b 2014b04 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
2014c0c: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
2014c10: b8 10 20 00 clr %i4 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
2014c14: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
2014c18: ba 10 20 00 clr %i5 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
2014c1c: 10 bf ff ba b 2014b04 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
2014c20: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1ULL << t;
else
clear_value = 1ULL << t;
2014c24: 12 80 00 09 bne 2014c48 <rtems_rfs_trace_shell_command+0x1b4><== NOT EXECUTED
2014c28: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2014c2c: b4 10 20 00 clr %i2 <== NOT EXECUTED
2014c30: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
2014c34: b7 28 40 16 sll %g1, %l6, %i3 <== NOT EXECUTED
2014c38: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
2014c3c: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
2014c40: 10 bf ff b1 b 2014b04 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
2014c44: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
2014c48: b6 10 20 00 clr %i3 <== NOT EXECUTED
2014c4c: b5 28 40 16 sll %g1, %l6, %i2 <== NOT EXECUTED
2014c50: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
2014c54: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
2014c58: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
2014c5c: 10 bf ff aa b 2014b04 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
2014c60: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1ULL << t;
2014c64: a2 10 20 00 clr %l1 <== NOT EXECUTED
2014c68: a1 28 40 16 sll %g1, %l6, %l0 <== NOT EXECUTED
2014c6c: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
2014c70: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
2014c74: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
2014c78: 10 bf ff a3 b 2014b04 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
2014c7c: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
2014c80: c2 4c a0 01 ldsb [ %l2 + 1 ], %g1 <== NOT EXECUTED
2014c84: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
2014c88: 02 80 00 09 be 2014cac <rtems_rfs_trace_shell_command+0x218><== NOT EXECUTED
2014c8c: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
2014c90: 02 80 00 0e be 2014cc8 <rtems_rfs_trace_shell_command+0x234><== NOT EXECUTED
2014c94: 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");
2014c98: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2014c9c: 40 00 3f 9c call 2024b0c <puts> <== NOT EXECUTED
2014ca0: 90 12 22 98 or %o0, 0x298, %o0 ! 2035698 <rtems_rfs_rtems_eval_config+0x88><== NOT EXECUTED
2014ca4: 81 c7 e0 08 ret <== NOT EXECUTED
2014ca8: 81 e8 00 00 restore <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
2014cac: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2014cb0: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
return 0;
2014cb4: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
2014cb8: 40 00 3e fd call 20248ac <printf> <== NOT EXECUTED
2014cbc: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED
2014cc0: 81 c7 e0 08 ret <== NOT EXECUTED
2014cc4: 81 e8 00 00 restore <== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
2014cc8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2014ccc: 11 00 80 d5 sethi %hi(0x2035400), %o0 <== NOT EXECUTED
2014cd0: 3b 00 80 d5 sethi %hi(0x2035400), %i5 <== NOT EXECUTED
2014cd4: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
2014cd8: 40 00 3e f5 call 20248ac <printf> <== NOT EXECUTED
2014cdc: b8 10 00 1e mov %fp, %i4 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
2014ce0: ba 17 62 90 or %i5, 0x290, %i5 <== NOT EXECUTED
2014ce4: d2 05 00 00 ld [ %l4 ], %o1 <== NOT EXECUTED
2014ce8: 40 00 3e f1 call 20248ac <printf> <== NOT EXECUTED
2014cec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2014cf0: a8 05 20 04 add %l4, 4, %l4 <== 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++)
2014cf4: 80 a5 00 1c cmp %l4, %i4 <== NOT EXECUTED
2014cf8: 32 bf ff fc bne,a 2014ce8 <rtems_rfs_trace_shell_command+0x254><== NOT EXECUTED
2014cfc: d2 05 00 00 ld [ %l4 ], %o1 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
2014d00: 81 c7 e0 08 ret <== NOT EXECUTED
2014d04: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
020206f4 <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)
{
20206f4: 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))
20206f8: 90 10 20 00 clr %o0
20206fc: 7f ff d0 ce call 2014a34 <rtems_rfs_trace>
2020700: 13 00 80 00 sethi %hi(0x2000000), %o1
2020704: 80 8a 20 ff btst 0xff, %o0
2020708: 12 80 00 4a bne 2020830 <rtems_rfs_unlink+0x13c> <== NEVER TAKEN
202070c: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
2020710: 90 10 00 18 mov %i0, %o0
2020714: 92 10 00 1a mov %i2, %o1
2020718: 94 07 bf d8 add %fp, -40, %o2
202071c: 7f ff ca 1f call 2012f98 <rtems_rfs_inode_open>
2020720: 96 10 20 01 mov 1, %o3
if (rc)
2020724: ba 92 20 00 orcc %o0, 0, %i5
2020728: 12 80 00 19 bne 202078c <rtems_rfs_unlink+0x98> <== NEVER TAKEN
202072c: 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));
2020730: 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);
2020734: c2 08 60 02 ldub [ %g1 + 2 ], %g1
2020738: 83 28 60 08 sll %g1, 8, %g1
202073c: 82 08 40 02 and %g1, %g2, %g1
2020740: 05 00 00 10 sethi %hi(0x4000), %g2
2020744: 82 18 40 02 xor %g1, %g2, %g1
if (dir)
2020748: 80 a0 00 01 cmp %g0, %g1
202074c: a0 60 3f ff subx %g0, -1, %l0
2020750: 80 a4 20 00 cmp %l0, 0
2020754: 02 80 00 12 be 202079c <rtems_rfs_unlink+0xa8>
2020758: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
202075c: 12 80 00 0e bne 2020794 <rtems_rfs_unlink+0xa0> <== ALWAYS TAKEN
2020760: 80 a7 20 01 cmp %i4, 1
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
2020764: 90 10 20 00 clr %o0 <== NOT EXECUTED
2020768: 7f ff d0 b3 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202076c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
2020770: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020774: 12 80 00 5a bne 20208dc <rtems_rfs_unlink+0x1e8> <== NOT EXECUTED
2020778: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
202077c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020780: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2020784: 7f ff ca 7d call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2020788: ba 10 20 15 mov 0x15, %i5 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
202078c: 81 c7 e0 08 ret
2020790: 91 e8 00 1d restore %g0, %i5, %o0
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
{
switch (dir_mode)
2020794: 02 80 00 3f be 2020890 <rtems_rfs_unlink+0x19c> <== ALWAYS TAKEN
2020798: 90 10 00 18 mov %i0, %o0
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
202079c: 90 10 00 18 mov %i0, %o0
20207a0: 92 10 00 19 mov %i1, %o1
20207a4: 94 07 bf b0 add %fp, -80, %o2
20207a8: 7f ff c9 fc call 2012f98 <rtems_rfs_inode_open>
20207ac: 96 10 20 01 mov 1, %o3
if (rc)
20207b0: ba 92 20 00 orcc %o0, 0, %i5
20207b4: 12 80 00 25 bne 2020848 <rtems_rfs_unlink+0x154> <== NEVER TAKEN
20207b8: 90 10 20 00 clr %o0
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
20207bc: 90 10 00 18 mov %i0, %o0
20207c0: 92 07 bf b0 add %fp, -80, %o1
20207c4: 94 10 00 1a mov %i2, %o2
20207c8: 7f ff f6 43 call 201e0d4 <rtems_rfs_dir_del_entry>
20207cc: 96 10 00 1b mov %i3, %o3
if (rc > 0)
20207d0: ba 92 20 00 orcc %o0, 0, %i5
20207d4: 04 80 00 46 ble 20208ec <rtems_rfs_unlink+0x1f8> <== ALWAYS TAKEN
20207d8: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
20207dc: 7f ff d0 96 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20207e0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
20207e4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20207e8: 02 80 00 0a be 2020810 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
20207ec: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
20207f0: 40 00 14 79 call 20259d4 <strerror> <== NOT EXECUTED
20207f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20207f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20207fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020800: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020804: 40 00 10 2a call 20248ac <printf> <== NOT EXECUTED
2020808: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 20371e8 <CSWTCH.2+0x14d4><== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
202080c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
2020810: 7f ff ca 5a call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2020814: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
2020818: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
202081c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2020820: 7f ff ca 56 call 2013178 <rtems_rfs_inode_close> <== NOT EXECUTED
2020824: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
2020828: 81 c7 e0 08 ret <== NOT EXECUTED
202082c: 81 e8 00 00 restore <== NOT EXECUTED
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
2020830: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020834: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2020838: 40 00 10 1d call 20248ac <printf> <== NOT EXECUTED
202083c: 90 12 21 48 or %o0, 0x148, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
2020840: 10 bf ff b5 b 2020714 <rtems_rfs_unlink+0x20> <== NOT EXECUTED
2020844: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
2020848: 7f ff d0 7b call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202084c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
2020850: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020854: 22 80 00 0a be,a 202087c <rtems_rfs_unlink+0x188> <== NOT EXECUTED
2020858: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
202085c: 40 00 14 5e call 20259d4 <strerror> <== NOT EXECUTED
2020860: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020864: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020868: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
202086c: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020870: 40 00 10 0f call 20248ac <printf> <== NOT EXECUTED
2020874: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 20371b8 <CSWTCH.2+0x14a4><== 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);
2020878: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
202087c: 92 07 bf d8 add %fp, -40, %o1
2020880: 7f ff ca 3e call 2013178 <rtems_rfs_inode_close>
2020884: b0 10 00 1d mov %i5, %i0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
2020888: 81 c7 e0 08 ret
202088c: 81 e8 00 00 restore
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
2020890: 7f ff f8 14 call 201e8e0 <rtems_rfs_dir_empty>
2020894: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
2020898: ba 92 20 00 orcc %o0, 0, %i5
202089c: 04 bf ff c0 ble 202079c <rtems_rfs_unlink+0xa8>
20208a0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
20208a4: 7f ff d0 64 call 2014a34 <rtems_rfs_trace>
20208a8: 13 00 80 00 sethi %hi(0x2000000), %o1
20208ac: 80 8a 20 ff btst 0xff, %o0
20208b0: 22 bf ff f3 be,a 202087c <rtems_rfs_unlink+0x188> <== ALWAYS TAKEN
20208b4: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
20208b8: 40 00 14 47 call 20259d4 <strerror> <== NOT EXECUTED
20208bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20208c0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20208c4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20208c8: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
20208cc: 40 00 0f f8 call 20248ac <printf> <== NOT EXECUTED
20208d0: 90 12 21 98 or %o0, 0x198, %o0 ! 2037198 <CSWTCH.2+0x1484><== 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);
20208d4: 10 bf ff ea b 202087c <rtems_rfs_unlink+0x188> <== NOT EXECUTED
20208d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
switch (dir_mode)
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link is a directory\n");
20208dc: 40 00 10 8c call 2024b0c <puts> <== NOT EXECUTED
20208e0: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
20208e4: 10 bf ff a7 b 2020780 <rtems_rfs_unlink+0x8c> <== NOT EXECUTED
20208e8: 90 10 00 18 mov %i0, %o0 <== 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);
20208ec: c4 07 bf e4 ld [ %fp + -28 ], %g2
if (links == 0xffff)
links = 0;
20208f0: 07 3f ff c0 sethi %hi(0xffff0000), %g3
*/
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);
20208f4: c2 08 80 00 ldub [ %g2 ], %g1
20208f8: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
20208fc: 83 28 60 08 sll %g1, 8, %g1
2020900: 82 10 40 02 or %g1, %g2, %g1
if (links == 0xffff)
2020904: 85 28 60 10 sll %g1, 0x10, %g2
2020908: 85 30 a0 10 srl %g2, 0x10, %g2
links = 0;
202090c: 84 38 c0 02 xnor %g3, %g2, %g2
2020910: 80 a0 00 02 cmp %g0, %g2
2020914: ba 60 20 00 subx %g0, 0, %i5
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
2020918: 13 00 80 00 sethi %hi(0x2000000), %o1
202091c: 7f ff d0 46 call 2014a34 <rtems_rfs_trace>
2020920: ba 08 40 1d and %g1, %i5, %i5
2020924: 80 8a 20 ff btst 0xff, %o0
2020928: 12 80 00 22 bne 20209b0 <rtems_rfs_unlink+0x2bc> <== NEVER TAKEN
202092c: b9 2f 60 10 sll %i5, 0x10, %i4
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
2020930: b9 37 20 10 srl %i4, 0x10, %i4
2020934: 80 a7 20 01 cmp %i4, 1
2020938: 08 80 00 39 bleu 2020a1c <rtems_rfs_unlink+0x328>
202093c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
2020940: ba 07 7f ff add %i5, -1, %i5
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
2020944: 85 37 60 08 srl %i5, 8, %g2
2020948: c4 28 40 00 stb %g2, [ %g1 ]
202094c: c2 07 bf e4 ld [ %fp + -28 ], %g1
2020950: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2020954: 82 10 20 01 mov 1, %g1
2020958: c2 2f bf e8 stb %g1, [ %fp + -24 ]
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
202095c: 90 07 bf b0 add %fp, -80, %o0
2020960: 92 10 20 01 mov 1, %o1
2020964: 7f ff ca 60 call 20132e4 <rtems_rfs_inode_time_stamp_now>
2020968: 94 10 20 01 mov 1, %o2
if (rc > 0)
202096c: ba 92 20 00 orcc %o0, 0, %i5
2020970: 04 80 00 17 ble 20209cc <rtems_rfs_unlink+0x2d8> <== ALWAYS TAKEN
2020974: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
2020978: 7f ff d0 2f call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
202097c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
2020980: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020984: 22 bf ff a3 be,a 2020810 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
2020988: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
202098c: 40 00 14 12 call 20259d4 <strerror> <== NOT EXECUTED
2020990: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020994: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020998: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
202099c: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
20209a0: 40 00 0f c3 call 20248ac <printf> <== NOT EXECUTED
20209a4: 90 12 22 70 or %o0, 0x270, %o0 ! 2037270 <CSWTCH.2+0x155c><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
20209a8: 10 bf ff 9a b 2020810 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
20209ac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
20209b0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
20209b4: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
20209b8: 95 37 20 10 srl %i4, 0x10, %o2 <== NOT EXECUTED
20209bc: 40 00 0f bc call 20248ac <printf> <== NOT EXECUTED
20209c0: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
if (links > 1)
20209c4: 10 bf ff dc b 2020934 <rtems_rfs_unlink+0x240> <== NOT EXECUTED
20209c8: b9 37 20 10 srl %i4, 0x10, %i4 <== 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);
20209cc: 90 10 00 18 mov %i0, %o0
20209d0: 7f ff c9 ea call 2013178 <rtems_rfs_inode_close>
20209d4: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
20209d8: ba 92 20 00 orcc %o0, 0, %i5
20209dc: 04 80 00 24 ble 2020a6c <rtems_rfs_unlink+0x378> <== ALWAYS TAKEN
20209e0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
20209e4: 7f ff d0 14 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
20209e8: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
20209ec: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20209f0: 22 bf ff a3 be,a 202087c <rtems_rfs_unlink+0x188> <== NOT EXECUTED
20209f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
20209f8: 40 00 13 f7 call 20259d4 <strerror> <== NOT EXECUTED
20209fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020a00: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020a04: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020a08: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020a0c: 40 00 0f a8 call 20248ac <printf> <== NOT EXECUTED
2020a10: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 20372a8 <CSWTCH.2+0x1594><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
2020a14: 10 bf ff 9a b 202087c <rtems_rfs_unlink+0x188> <== NOT EXECUTED
2020a18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
2020a1c: 90 10 00 18 mov %i0, %o0
2020a20: 7f ff c9 fc call 2013210 <rtems_rfs_inode_delete>
2020a24: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
2020a28: ba 92 20 00 orcc %o0, 0, %i5
2020a2c: 04 80 00 23 ble 2020ab8 <rtems_rfs_unlink+0x3c4> <== ALWAYS TAKEN
2020a30: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
2020a34: 7f ff d0 00 call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2020a38: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
2020a3c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020a40: 22 bf ff 74 be,a 2020810 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
2020a44: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
2020a48: 40 00 13 e3 call 20259d4 <strerror> <== NOT EXECUTED
2020a4c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020a50: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020a54: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020a58: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020a5c: 40 00 0f 94 call 20248ac <printf> <== NOT EXECUTED
2020a60: 90 12 22 40 or %o0, 0x240, %o0 ! 2037240 <CSWTCH.2+0x152c><== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
2020a64: 10 bf ff 6b b 2020810 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
2020a68: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
2020a6c: 90 10 00 18 mov %i0, %o0
2020a70: 7f ff c9 c2 call 2013178 <rtems_rfs_inode_close>
2020a74: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
2020a78: ba 92 20 00 orcc %o0, 0, %i5
2020a7c: 04 bf ff 44 ble 202078c <rtems_rfs_unlink+0x98> <== ALWAYS TAKEN
2020a80: 90 10 20 00 clr %o0
2020a84: 7f ff cf ec call 2014a34 <rtems_rfs_trace> <== NOT EXECUTED
2020a88: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
2020a8c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2020a90: 02 bf ff 3f be 202078c <rtems_rfs_unlink+0x98> <== NOT EXECUTED
2020a94: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
2020a98: 40 00 13 cf call 20259d4 <strerror> <== NOT EXECUTED
2020a9c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020aa0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020aa4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020aa8: 11 00 80 dc sethi %hi(0x2037000), %o0 <== NOT EXECUTED
2020aac: 40 00 0f 80 call 20248ac <printf> <== NOT EXECUTED
2020ab0: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 20372e0 <CSWTCH.2+0x15cc><== NOT EXECUTED
2020ab4: 30 bf ff 36 b,a 202078c <rtems_rfs_unlink+0x98> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
2020ab8: 80 a4 20 00 cmp %l0, 0
2020abc: 02 bf ff a9 be 2020960 <rtems_rfs_unlink+0x26c>
2020ac0: 90 07 bf b0 add %fp, -80, %o0
*/
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);
2020ac4: c4 07 bf bc ld [ %fp + -68 ], %g2
if (links == 0xffff)
2020ac8: 3b 00 00 3f sethi %hi(0xfc00), %i5
*/
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);
2020acc: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
2020ad0: c6 08 80 00 ldub [ %g2 ], %g3
if (links == 0xffff)
2020ad4: ba 17 63 ff or %i5, 0x3ff, %i5
*/
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);
2020ad8: 87 28 e0 08 sll %g3, 8, %g3
2020adc: 86 10 c0 01 or %g3, %g1, %g3
if (links == 0xffff)
2020ae0: 89 28 e0 10 sll %g3, 0x10, %g4
2020ae4: 89 31 20 10 srl %g4, 0x10, %g4
2020ae8: 80 a1 00 1d cmp %g4, %i5
2020aec: 02 80 00 0c be 2020b1c <rtems_rfs_unlink+0x428> <== NEVER TAKEN
2020af0: 82 10 00 03 mov %g3, %g1
{
links = rtems_rfs_inode_get_links (&parent_inode);
if (links > 1)
2020af4: 80 a1 20 01 cmp %g4, 1
2020af8: 38 80 00 02 bgu,a 2020b00 <rtems_rfs_unlink+0x40c>
2020afc: 82 00 ff ff add %g3, -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);
2020b00: 87 30 60 08 srl %g1, 8, %g3
2020b04: c6 28 80 00 stb %g3, [ %g2 ]
2020b08: c4 07 bf bc ld [ %fp + -68 ], %g2
2020b0c: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2020b10: 82 10 20 01 mov 1, %g1
2020b14: 10 bf ff 92 b 202095c <rtems_rfs_unlink+0x268>
2020b18: c2 2f bf c0 stb %g1, [ %fp + -64 ]
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;
2020b1c: 10 bf ff f9 b 2020b00 <rtems_rfs_unlink+0x40c> <== NOT EXECUTED
2020b20: 82 10 20 00 clr %g1 <== NOT EXECUTED
02024310 <rtems_shell_rfs_format>:
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
2024310: 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));
2024314: c0 27 bf e8 clr [ %fp + -24 ] <== NOT EXECUTED
2024318: c0 27 bf ec clr [ %fp + -20 ] <== NOT EXECUTED
202431c: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
2024320: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
2024324: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
2024328: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
202432c: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
2024330: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
2024334: 37 00 80 8b sethi %hi(0x2022c00), %i3 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2024338: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
202433c: 14 80 00 0a bg 2024364 <rtems_shell_rfs_format+0x54> <== NOT EXECUTED
2024340: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
2024344: 10 80 00 69 b 20244e8 <rtems_shell_rfs_format+0x1d8> <== NOT EXECUTED
2024348: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
202434c: 12 80 00 55 bne 20244a0 <rtems_shell_rfs_format+0x190> <== NOT EXECUTED
2024350: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2024354: ba 07 60 01 inc %i5 <== NOT EXECUTED
2024358: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
202435c: 04 80 00 1d ble 20243d0 <rtems_shell_rfs_format+0xc0> <== NOT EXECUTED
2024360: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2024364: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
2024368: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
202436c: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
2024370: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2024374: 12 bf ff f6 bne 202434c <rtems_shell_rfs_format+0x3c> <== NOT EXECUTED
2024378: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
202437c: c2 0a 60 01 ldub [ %o1 + 1 ], %g1 <== NOT EXECUTED
2024380: 82 00 7f b7 add %g1, -73, %g1 <== NOT EXECUTED
2024384: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
2024388: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
202438c: 08 80 00 08 bleu 20243ac <rtems_shell_rfs_format+0x9c> <== NOT EXECUTED
2024390: 84 16 e0 e4 or %i3, 0xe4, %g2 <== NOT EXECUTED
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
2024394: 11 00 81 6c sethi %hi(0x205b000), %o0 <== NOT EXECUTED
return 1;
2024398: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
202439c: 40 00 71 02 call 20407a4 <printf> <== NOT EXECUTED
20243a0: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
20243a4: 81 c7 e0 08 ret <== NOT EXECUTED
20243a8: 81 e8 00 00 restore <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
20243ac: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
20243b0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED
20243b4: 81 c0 40 00 jmp %g1 <== NOT EXECUTED
20243b8: 01 00 00 00 nop <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
20243bc: ba 07 60 01 inc %i5 <== NOT EXECUTED
20243c0: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
20243c4: 14 bf ff e8 bg 2024364 <rtems_shell_rfs_format+0x54> <== NOT EXECUTED
20243c8: f4 2f bf fd stb %i2, [ %fp + -3 ] <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
20243cc: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
20243d0: 02 80 00 45 be 20244e4 <rtems_shell_rfs_format+0x1d4> <== NOT EXECUTED
20243d4: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
printf ("error: no driver name provided\n");
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
20243d8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20243dc: 40 00 39 df call 2032b58 <rtems_rfs_format> <== NOT EXECUTED
20243e0: b0 10 20 00 clr %i0 <== NOT EXECUTED
20243e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20243e8: 06 80 00 34 bl 20244b8 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
20243ec: 01 00 00 00 nop <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
20243f0: 81 c7 e0 08 ret <== NOT EXECUTED
20243f4: 81 e8 00 00 restore <== NOT EXECUTED
case 'v':
config.verbose = true;
break;
case 's':
arg++;
20243f8: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
20243fc: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
2024400: 04 80 00 45 ble 2024514 <rtems_shell_rfs_format+0x204> <== NOT EXECUTED
2024404: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
2024408: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
202440c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2024410: 40 00 80 ba call 20446f8 <strtoul> <== NOT EXECUTED
2024414: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2024418: 10 bf ff cf b 2024354 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
202441c: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
2024420: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
2024424: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
2024428: 04 80 00 47 ble 2024544 <rtems_shell_rfs_format+0x234> <== NOT EXECUTED
202442c: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
2024430: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2024434: 92 10 20 00 clr %o1 <== NOT EXECUTED
2024438: 40 00 80 b0 call 20446f8 <strtoul> <== NOT EXECUTED
202443c: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2024440: 10 bf ff c5 b 2024354 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
2024444: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
}
config.group_blocks = strtoul (argv[arg], 0, 0);
break;
case 'i':
arg++;
2024448: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
202444c: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
2024450: 04 80 00 37 ble 202452c <rtems_shell_rfs_format+0x21c> <== NOT EXECUTED
2024454: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
2024458: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
202445c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2024460: 40 00 80 a6 call 20446f8 <strtoul> <== NOT EXECUTED
2024464: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2024468: 10 bf ff bb b 2024354 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
202446c: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
2024470: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
2024474: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
2024478: 04 80 00 21 ble 20244fc <rtems_shell_rfs_format+0x1ec> <== NOT EXECUTED
202447c: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
2024480: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2024484: 92 10 20 00 clr %o1 <== NOT EXECUTED
2024488: 40 00 80 9c call 20446f8 <strtoul> <== NOT EXECUTED
202448c: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2024490: 10 bf ff b1 b 2024354 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
2024494: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
config.group_inodes = strtoul (argv[arg], 0, 0);
break;
case 'I':
config.initialise_inodes = true;
break;
2024498: 10 bf ff af b 2024354 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
202449c: f4 2f bf fc stb %i2, [ %fp + -4 ] <== NOT EXECUTED
{
if (!driver)
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
20244a0: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
return 1;
20244a4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
{
if (!driver)
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
20244a8: 40 00 70 bf call 20407a4 <printf> <== NOT EXECUTED
20244ac: 90 12 23 18 or %o0, 0x318, %o0 <== NOT EXECUTED
20244b0: 81 c7 e0 08 ret <== NOT EXECUTED
20244b4: 81 e8 00 00 restore <== NOT EXECUTED
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
20244b8: 40 00 5e 6c call 203be68 <__errno> <== NOT EXECUTED
20244bc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
20244c0: 40 00 7a 11 call 2042d04 <strerror> <== NOT EXECUTED
20244c4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20244c8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20244cc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20244d0: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
20244d4: 40 00 70 b4 call 20407a4 <printf> <== NOT EXECUTED
20244d8: 90 12 23 48 or %o0, 0x348, %o0 ! 205d348 <rtems_rtc_shell_usage+0x18a0><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
20244dc: 81 c7 e0 08 ret <== NOT EXECUTED
20244e0: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
20244e4: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
return 1;
20244e8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
20244ec: 40 00 71 46 call 2040a04 <puts> <== NOT EXECUTED
20244f0: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
20244f4: 81 c7 e0 08 ret <== NOT EXECUTED
20244f8: 81 e8 00 00 restore <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
20244fc: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
return 1;
2024500: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
2024504: 40 00 71 40 call 2040a04 <puts> <== NOT EXECUTED
2024508: 90 12 22 80 or %o0, 0x280, %o0 <== NOT EXECUTED
202450c: 81 c7 e0 08 ret <== NOT EXECUTED
2024510: 81 e8 00 00 restore <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
2024514: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
return 1;
2024518: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
202451c: 40 00 71 3a call 2040a04 <puts> <== NOT EXECUTED
2024520: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
2024524: 81 c7 e0 08 ret <== NOT EXECUTED
2024528: 81 e8 00 00 restore <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
202452c: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
return 1;
2024530: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
2024534: 40 00 71 34 call 2040a04 <puts> <== NOT EXECUTED
2024538: 90 12 22 b0 or %o0, 0x2b0, %o0 <== NOT EXECUTED
202453c: 81 c7 e0 08 ret <== NOT EXECUTED
2024540: 81 e8 00 00 restore <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
2024544: 11 00 81 74 sethi %hi(0x205d000), %o0 <== NOT EXECUTED
return 1;
2024548: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
202454c: 40 00 71 2e call 2040a04 <puts> <== NOT EXECUTED
2024550: 90 12 22 e0 or %o0, 0x2e0, %o0 <== NOT EXECUTED
2024554: 81 c7 e0 08 ret <== NOT EXECUTED
2024558: 81 e8 00 00 restore <== NOT EXECUTED
02016d64 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
2016d64: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
2016d68: 80 a6 60 00 cmp %i1, 0
2016d6c: 12 80 00 04 bne 2016d7c <rtems_signal_send+0x18>
2016d70: 82 10 20 0a mov 0xa, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2016d74: 81 c7 e0 08 ret
2016d78: 91 e8 00 01 restore %g0, %g1, %o0
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
2016d7c: 90 10 00 18 mov %i0, %o0
2016d80: 40 00 13 dc call 201bcf0 <_Thread_Get>
2016d84: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
2016d88: c2 07 bf fc ld [ %fp + -4 ], %g1
2016d8c: 80 a0 60 00 cmp %g1, 0
2016d90: 12 80 00 20 bne 2016e10 <rtems_signal_send+0xac>
2016d94: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
2016d98: fa 02 21 58 ld [ %o0 + 0x158 ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
2016d9c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2016da0: 80 a0 60 00 cmp %g1, 0
2016da4: 02 80 00 1e be 2016e1c <rtems_signal_send+0xb8>
2016da8: 01 00 00 00 nop
if ( asr->is_enabled ) {
2016dac: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
2016db0: 80 a0 60 00 cmp %g1, 0
2016db4: 02 80 00 1e be 2016e2c <rtems_signal_send+0xc8>
2016db8: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2016dbc: 7f ff e2 4f call 200f6f8 <sparc_disable_interrupts>
2016dc0: 01 00 00 00 nop
*signal_set |= signals;
2016dc4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2016dc8: b2 10 40 19 or %g1, %i1, %i1
2016dcc: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
2016dd0: 7f ff e2 4e call 200f708 <sparc_enable_interrupts>
2016dd4: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
2016dd8: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2016ddc: 82 10 62 60 or %g1, 0x260, %g1 ! 203ce60 <_Per_CPU_Information>
2016de0: c4 00 60 08 ld [ %g1 + 8 ], %g2
2016de4: 80 a0 a0 00 cmp %g2, 0
2016de8: 02 80 00 06 be 2016e00 <rtems_signal_send+0x9c>
2016dec: 01 00 00 00 nop
2016df0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2016df4: 80 a7 00 02 cmp %i4, %g2
2016df8: 02 80 00 15 be 2016e4c <rtems_signal_send+0xe8> <== ALWAYS TAKEN
2016dfc: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
2016e00: 40 00 13 b0 call 201bcc0 <_Thread_Enable_dispatch>
2016e04: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2016e08: 10 bf ff db b 2016d74 <rtems_signal_send+0x10>
2016e0c: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2016e10: 82 10 20 04 mov 4, %g1
}
2016e14: 81 c7 e0 08 ret
2016e18: 91 e8 00 01 restore %g0, %g1, %o0
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
2016e1c: 40 00 13 a9 call 201bcc0 <_Thread_Enable_dispatch>
2016e20: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
2016e24: 10 bf ff d4 b 2016d74 <rtems_signal_send+0x10>
2016e28: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2016e2c: 7f ff e2 33 call 200f6f8 <sparc_disable_interrupts>
2016e30: 01 00 00 00 nop
*signal_set |= signals;
2016e34: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2016e38: b2 10 40 19 or %g1, %i1, %i1
2016e3c: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
2016e40: 7f ff e2 32 call 200f708 <sparc_enable_interrupts>
2016e44: 01 00 00 00 nop
2016e48: 30 bf ff ee b,a 2016e00 <rtems_signal_send+0x9c>
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
if ( asr->is_enabled ) {
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
2016e4c: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
2016e50: 30 bf ff ec b,a 2016e00 <rtems_signal_send+0x9c>
0200fa94 <rtems_sparse_disk_create_and_register>:
const char *device_file_name,
uint32_t media_block_size,
rtems_blkdev_bnum blocks_with_buffer,
rtems_blkdev_bnum media_block_count,
uint8_t fill_pattern )
{
200fa94: 9d e3 bf 98 save %sp, -104, %sp
const rtems_blkdev_bnum blocks_with_buffer )
{
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
size_t const alloc_size = sizeof( rtems_sparse_disk )
200fa98: 92 10 00 1a mov %i2, %o1
200fa9c: 7f ff ca bc call 200258c <.umul>
200faa0: 90 06 60 08 add %i1, 8, %o0
+ key_table_size + data_size;
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
200faa4: 7f ff d7 c1 call 20059a8 <malloc>
200faa8: 90 02 20 1c add %o0, 0x1c, %o0
200faac: 92 10 00 08 mov %o0, %o1
rtems_sparse_disk *sparse_disk = sparse_disk_allocate(
media_block_size,
blocks_with_buffer
);
if ( sparse_disk != NULL ) {
200fab0: 80 a2 60 00 cmp %o1, 0
200fab4: 02 80 00 0b be 200fae0 <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
200fab8: 90 10 20 1a mov 0x1a, %o0
sc = rtems_sparse_disk_register(
200fabc: 03 00 80 3e sethi %hi(0x200f800), %g1
200fac0: 82 10 61 9c or %g1, 0x19c, %g1 ! 200f99c <rtems_sparse_disk_free>
200fac4: 90 10 00 18 mov %i0, %o0
200fac8: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200facc: 94 10 00 19 mov %i1, %o2
200fad0: 96 10 00 1a mov %i2, %o3
200fad4: 98 10 00 1b mov %i3, %o4
200fad8: 7f ff ff b4 call 200f9a8 <rtems_sparse_disk_register>
200fadc: 9a 10 00 1c mov %i4, %o5
} else {
sc = RTEMS_NO_MEMORY;
}
return sc;
}
200fae0: 81 c7 e0 08 ret
200fae4: 91 e8 00 08 restore %g0, %o0, %o0
0200f9a8 <rtems_sparse_disk_register>:
uint32_t media_block_size,
rtems_blkdev_bnum blocks_with_buffer,
rtems_blkdev_bnum media_block_count,
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
200f9a8: 9d e3 bf a0 save %sp, -96, %sp
200f9ac: a2 10 00 18 mov %i0, %l1
200f9b0: a0 10 00 19 mov %i1, %l0
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
200f9b4: b0 10 20 0a mov 0xa, %i0
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
200f9b8: 80 a6 c0 1c cmp %i3, %i4
200f9bc: 08 80 00 04 bleu 200f9cc <rtems_sparse_disk_register+0x24><== ALWAYS TAKEN
200f9c0: f2 07 a0 5c ld [ %fp + 0x5c ], %i1
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
200f9c4: 81 c7 e0 08 ret <== NOT EXECUTED
200f9c8: 81 e8 00 00 restore <== NOT EXECUTED
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
200f9cc: 80 a4 20 00 cmp %l0, 0
200f9d0: 02 80 00 2f be 200fa8c <rtems_sparse_disk_register+0xe4> <== NEVER TAKEN
200f9d4: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
200f9d8: a5 2e e0 03 sll %i3, 3, %l2
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
200f9dc: 90 10 00 10 mov %l0, %o0
200f9e0: b0 04 a0 1c add %l2, 0x1c, %i0
200f9e4: 40 00 38 b6 call 201dcbc <memset>
200f9e8: 94 10 00 18 mov %i0, %o2
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
200f9ec: 92 10 00 1a mov %i2, %o1
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
200f9f0: fa 2c 20 14 stb %i5, [ %l0 + 0x14 ]
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
200f9f4: 7f ff ca e6 call 200258c <.umul>
200f9f8: 90 10 00 1b mov %i3, %o0
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
200f9fc: b0 04 00 18 add %l0, %i0, %i0
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
200fa00: 94 10 00 08 mov %o0, %o2
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
200fa04: 92 10 00 1d mov %i5, %o1
200fa08: 40 00 38 ad call 201dcbc <memset>
200fa0c: 90 10 00 18 mov %i0, %o0
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
sc = rtems_semaphore_create(
200fa10: 92 10 20 01 mov 1, %o1
sd->fill_pattern = fill_pattern;
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
200fa14: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
sc = rtems_semaphore_create(
200fa18: 94 10 20 54 mov 0x54, %o2
200fa1c: 11 14 d4 10 sethi %hi(0x53504000), %o0
200fa20: 96 10 20 00 clr %o3
200fa24: 90 12 21 52 or %o0, 0x152, %o0
200fa28: 7f ff e8 2a call 2009ad0 <rtems_semaphore_create>
200fa2c: 98 10 00 10 mov %l0, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
200fa30: b0 92 20 00 orcc %o0, 0, %i0
200fa34: 12 bf ff e4 bne 200f9c4 <rtems_sparse_disk_register+0x1c> <== NEVER TAKEN
200fa38: 84 04 20 1c add %l0, 0x1c, %g2
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
200fa3c: f6 24 20 04 st %i3, [ %l0 + 4 ]
sd->key_table = (rtems_sparse_disk_key *) data;
200fa40: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
200fa44: 82 10 20 00 clr %g1
200fa48: 80 a6 e0 00 cmp %i3, 0
200fa4c: 02 80 00 08 be 200fa6c <rtems_sparse_disk_register+0xc4> <== NEVER TAKEN
200fa50: 84 00 80 12 add %g2, %l2, %g2
}
return sc;
}
rtems_status_code rtems_sparse_disk_register(
200fa54: 86 04 00 01 add %l0, %g1, %g3
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
sd->key_table[i].data = data;
200fa58: c4 20 e0 20 st %g2, [ %g3 + 0x20 ]
200fa5c: 82 00 60 08 add %g1, 8, %g1
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
200fa60: 80 a4 80 01 cmp %l2, %g1
200fa64: 12 bf ff fc bne 200fa54 <rtems_sparse_disk_register+0xac>
200fa68: 84 00 80 1a add %g2, %i2, %g2
sd->key_table[i].data = data;
}
sd->media_block_size = media_block_size;
200fa6c: f4 24 20 0c st %i2, [ %l0 + 0xc ]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
200fa70: b2 10 00 1a mov %i2, %i1
200fa74: 37 00 80 3d sethi %hi(0x200f400), %i3
200fa78: b4 10 00 1c mov %i4, %i2
200fa7c: b0 10 00 11 mov %l1, %i0
200fa80: b6 16 e2 c4 or %i3, 0x2c4, %i3
200fa84: 40 00 0b 63 call 2012810 <rtems_blkdev_create>
200fa88: 99 e8 00 10 restore %g0, %l0, %o4
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
200fa8c: 81 c7 e0 08 ret <== NOT EXECUTED
200fa90: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
02025f1c <rtems_stack_checker_begin_extension>:
Thread_Control *the_thread
)
{
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
2025f1c: c2 02 20 08 ld [ %o0 + 8 ], %g1
2025f20: 80 a0 60 00 cmp %g1, 0
2025f24: 02 80 00 0c be 2025f54 <rtems_stack_checker_begin_extension+0x38><== NEVER TAKEN
2025f28: 05 00 81 9f sethi %hi(0x2067c00), %g2
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
2025f2c: c2 02 20 b8 ld [ %o0 + 0xb8 ], %g1
2025f30: c6 00 a1 ac ld [ %g2 + 0x1ac ], %g3
2025f34: 84 10 a1 ac or %g2, 0x1ac, %g2
2025f38: c6 20 60 08 st %g3, [ %g1 + 8 ]
2025f3c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
2025f40: c6 20 60 0c st %g3, [ %g1 + 0xc ]
2025f44: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2025f48: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
2025f4c: c4 00 a0 0c ld [ %g2 + 0xc ], %g2
2025f50: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
2025f54: 81 c3 e0 08 retl
02025e68 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
2025e68: 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 )
2025e6c: 3b 00 81 9a sethi %hi(0x2066800), %i5
2025e70: c2 07 63 c0 ld [ %i5 + 0x3c0 ], %g1 ! 2066bc0 <Stack_check_Initialized>
2025e74: 80 a0 60 00 cmp %g1, 0
2025e78: 12 80 00 20 bne 2025ef8 <rtems_stack_checker_create_extension+0x90>
2025e7c: 07 00 81 9f sethi %hi(0x2067c00), %g3
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
2025e80: 09 3f bb 7c sethi %hi(0xfeedf000), %g4
2025e84: 82 10 e1 ac or %g3, 0x1ac, %g1
2025e88: 88 11 20 0d or %g4, 0xd, %g4
2025e8c: c8 20 e1 ac st %g4, [ %g3 + 0x1ac ]
2025e90: 07 02 eb 43 sethi %hi(0xbad0c00), %g3
2025e94: 86 10 e1 06 or %g3, 0x106, %g3 ! bad0d06 <RAM_END+0x96d0d06>
/*
* 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) {
2025e98: 05 00 81 9e sethi %hi(0x2067800), %g2
2025e9c: d0 00 a0 80 ld [ %g2 + 0x80 ], %o0 ! 2067880 <_Per_CPU_Information>
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
2025ea0: c6 20 60 04 st %g3, [ %g1 + 4 ]
2025ea4: 07 37 ab 7c sethi %hi(0xdeadf000), %g3
2025ea8: 86 10 e0 0d or %g3, 0xd, %g3 ! deadf00d <RAM_END+0xdc6df00d>
2025eac: c6 20 60 08 st %g3, [ %g1 + 8 ]
2025eb0: 07 18 03 43 sethi %hi(0x600d0c00), %g3
2025eb4: 86 10 e1 06 or %g3, 0x106, %g3 ! 600d0d06 <RAM_END+0x5dcd0d06>
2025eb8: c6 20 60 0c st %g3, [ %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) {
2025ebc: 80 a2 20 00 cmp %o0, 0
2025ec0: 02 80 00 0c be 2025ef0 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
2025ec4: 84 10 a0 80 or %g2, 0x80, %g2
2025ec8: d4 00 a0 04 ld [ %g2 + 4 ], %o2
2025ecc: 80 a2 a0 00 cmp %o2, 0
2025ed0: 02 80 00 08 be 2025ef0 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
2025ed4: 03 00 81 9f sethi %hi(0x2067c00), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
2025ed8: 84 10 61 bc or %g1, 0x1bc, %g2 ! 2067dbc <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
2025edc: 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;
2025ee0: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
2025ee4: d4 20 61 bc st %o2, [ %g1 + 0x1bc ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
2025ee8: 40 00 65 be call 203f5e0 <memset>
2025eec: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
2025ef0: 82 10 20 01 mov 1, %g1
2025ef4: c2 27 63 c0 st %g1, [ %i5 + 0x3c0 ]
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
2025ef8: 80 a6 60 00 cmp %i1, 0
2025efc: 02 80 00 06 be 2025f14 <rtems_stack_checker_create_extension+0xac><== NEVER TAKEN
2025f00: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
2025f04: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
2025f08: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
2025f0c: 40 00 65 b5 call 203f5e0 <memset>
2025f10: 92 10 20 a5 mov 0xa5, %o1
return true;
}
2025f14: 81 c7 e0 08 ret
2025f18: 91 e8 20 01 restore %g0, 1, %o0
0202607c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
202607c: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
2026080: 39 00 81 9e sethi %hi(0x2067800), %i4
2026084: b8 17 20 80 or %i4, 0x80, %i4 ! 2067880 <_Per_CPU_Information>
2026088: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
202608c: d0 00 60 b8 ld [ %g1 + 0xb8 ], %o0
2026090: 80 a7 80 08 cmp %fp, %o0
2026094: 0a 80 00 06 bcs 20260ac <rtems_stack_checker_is_blown+0x30><== NEVER TAKEN
2026098: ba 10 20 01 mov 1, %i5
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
202609c: c2 00 60 b4 ld [ %g1 + 0xb4 ], %g1
20260a0: 82 02 00 01 add %o0, %g1, %g1
20260a4: 80 a0 40 1e cmp %g1, %fp
20260a8: ba 40 20 00 addx %g0, 0, %i5
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
20260ac: 03 00 81 9a sethi %hi(0x2066800), %g1
20260b0: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 2066bc0 <Stack_check_Initialized>
20260b4: 80 a0 60 00 cmp %g1, 0
20260b8: 02 80 00 12 be 2026100 <rtems_stack_checker_is_blown+0x84><== NEVER TAKEN
20260bc: 82 10 20 00 clr %g1
pattern_ok = (!memcmp(
20260c0: 90 02 20 08 add %o0, 8, %o0
20260c4: 94 10 20 10 mov 0x10, %o2
20260c8: 13 00 81 9f sethi %hi(0x2067c00), %o1
20260cc: 40 00 64 8c call 203f2fc <memcmp>
20260d0: 92 12 61 ac or %o1, 0x1ac, %o1 ! 2067dac <Stack_check_Pattern>
20260d4: 80 a0 00 08 cmp %g0, %o0
20260d8: 82 60 3f ff subx %g0, -1, %g1
20260dc: 92 10 00 01 mov %g1, %o1
20260e0: 82 18 60 01 xor %g1, 1, %g1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
20260e4: 80 88 60 ff btst 0xff, %g1
20260e8: 12 80 00 08 bne 2026108 <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
20260ec: 80 8f 60 ff btst 0xff, %i5
20260f0: 12 80 00 06 bne 2026108 <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
20260f4: b0 10 20 00 clr %i0
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
20260f8: 81 c7 e0 08 ret
20260fc: 81 e8 00 00 restore
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
2026100: 10 bf ff f9 b 20260e4 <rtems_stack_checker_is_blown+0x68> <== NOT EXECUTED
2026104: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
2026108: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
202610c: 7f ff ff 94 call 2025f5c <Stack_check_report_blown_task> <== NOT EXECUTED
2026110: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
02026118 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2026118: 9d e3 bf a0 save %sp, -96, %sp
if ( !print )
202611c: 80 a6 60 00 cmp %i1, 0
2026120: 02 80 00 14 be 2026170 <rtems_stack_checker_report_usage_with_plugin+0x58><== NEVER TAKEN
2026124: 39 00 81 9a sethi %hi(0x2066800), %i4
return;
print_context = context;
print_handler = print;
2026128: 3b 00 81 9a sethi %hi(0x2066800), %i5
)
{
if ( !print )
return;
print_context = context;
202612c: f0 27 23 c4 st %i0, [ %i4 + 0x3c4 ]
print_handler = print;
2026130: f2 27 63 c8 st %i1, [ %i5 + 0x3c8 ]
(*print)( context, "Stack usage by thread\n");
2026134: 90 10 00 18 mov %i0, %o0
2026138: 13 00 81 77 sethi %hi(0x205dc00), %o1
202613c: 9f c6 40 00 call %i1
2026140: 92 12 60 c8 or %o1, 0xc8, %o1 ! 205dcc8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8>
(*print)( context,
2026144: 90 10 00 18 mov %i0, %o0
2026148: 13 00 81 77 sethi %hi(0x205dc00), %o1
202614c: 9f c6 40 00 call %i1
2026150: 92 12 60 e0 or %o1, 0xe0, %o1 ! 205dce0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x410>
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
2026154: 11 00 80 97 sethi %hi(0x2025c00), %o0
2026158: 40 00 11 86 call 202a770 <rtems_iterate_over_all_threads>
202615c: 90 12 20 e8 or %o0, 0xe8, %o0 ! 2025ce8 <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);
2026160: 7f ff fe e2 call 2025ce8 <Stack_check_Dump_threads_usage>
2026164: 90 10 3f ff mov -1, %o0
#endif
print_context = NULL;
2026168: c0 27 23 c4 clr [ %i4 + 0x3c4 ]
print_handler = NULL;
202616c: c0 27 63 c8 clr [ %i5 + 0x3c8 ]
2026170: 81 c7 e0 08 ret
2026174: 81 e8 00 00 restore
0202600c <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
202600c: 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);
2026010: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
/*
* 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,
2026014: 13 00 81 9f sethi %hi(0x2067c00), %o1
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);
2026018: 90 00 60 08 add %g1, 8, %o0
/*
* 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,
202601c: 94 10 20 10 mov 0x10, %o2
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
2026020: 80 a7 80 01 cmp %fp, %g1
2026024: 0a 80 00 07 bcs 2026040 <rtems_stack_checker_switch_extension+0x34><== NEVER TAKEN
2026028: 92 12 61 ac or %o1, 0x1ac, %o1
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
202602c: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
2026030: 82 00 40 02 add %g1, %g2, %g1
2026034: 80 a7 80 01 cmp %fp, %g1
2026038: 08 80 00 0a bleu 2026060 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
202603c: 01 00 00 00 nop
/*
* 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,
2026040: 40 00 64 af call 203f2fc <memcmp> <== NOT EXECUTED
2026044: 01 00 00 00 nop <== NOT EXECUTED
2026048: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
202604c: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
2026050: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
2026054: 90 10 00 18 mov %i0, %o0
2026058: 7f ff ff c1 call 2025f5c <Stack_check_report_blown_task>
202605c: 92 0a 60 01 and %o1, 1, %o1
/*
* 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,
2026060: 40 00 64 a7 call 203f2fc <memcmp>
2026064: 01 00 00 00 nop
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
2026068: 80 a2 20 00 cmp %o0, 0
202606c: 12 bf ff fa bne 2026054 <rtems_stack_checker_switch_extension+0x48>
2026070: 92 10 20 00 clr %o1
2026074: 81 c7 e0 08 ret
2026078: 81 e8 00 00 restore
0200dddc <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
200dddc: 9d e3 bf 90 save %sp, -112, %sp
double result;
char *end;
if ( !n )
200dde0: 80 a6 60 00 cmp %i1, 0
200dde4: 02 80 00 19 be 200de48 <rtems_string_to_double+0x6c>
200dde8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200ddec: 40 00 0c ed call 20111a0 <__errno>
200ddf0: 01 00 00 00 nop
200ddf4: c0 22 00 00 clr [ %o0 ]
*n = 0;
200ddf8: c0 26 40 00 clr [ %i1 ]
200ddfc: c0 26 60 04 clr [ %i1 + 4 ]
result = strtod( s, &end );
200de00: 90 10 00 18 mov %i0, %o0
200de04: 40 00 17 fc call 2013df4 <strtod>
200de08: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
200de0c: 80 a6 a0 00 cmp %i2, 0
200de10: 02 80 00 03 be 200de1c <rtems_string_to_double+0x40>
200de14: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200de18: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200de1c: 80 a6 00 02 cmp %i0, %g2
200de20: 02 80 00 0a be 200de48 <rtems_string_to_double+0x6c>
200de24: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200de28: 40 00 0c de call 20111a0 <__errno>
200de2c: c1 3f bf f0 std %f0, [ %fp + -16 ]
200de30: c2 02 00 00 ld [ %o0 ], %g1
200de34: 80 a0 60 22 cmp %g1, 0x22
200de38: 02 80 00 06 be 200de50 <rtems_string_to_double+0x74>
200de3c: c1 1f bf f0 ldd [ %fp + -16 ], %f0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
200de40: c1 3e 40 00 std %f0, [ %i1 ]
return RTEMS_SUCCESSFUL;
200de44: 82 10 20 00 clr %g1
}
200de48: 81 c7 e0 08 ret
200de4c: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200de50: 05 00 80 7f sethi %hi(0x201fc00), %g2
200de54: d1 18 a2 e8 ldd [ %g2 + 0x2e8 ], %f8 ! 201fee8 <_rodata_start+0x17f8>
200de58: 81 a8 0a 48 fcmpd %f0, %f8
200de5c: 01 00 00 00 nop
200de60: 13 bf ff fa fbe 200de48 <rtems_string_to_double+0x6c>
200de64: 82 10 20 0a mov 0xa, %g1 ! a <PROM_START+0xa>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
200de68: 05 00 80 83 sethi %hi(0x2020c00), %g2
200de6c: d1 18 a0 88 ldd [ %g2 + 0x88 ], %f8 ! 2020c88 <_CPU_Trap_slot_template+0x10>
200de70: 81 a8 0a c8 fcmped %f0, %f8
200de74: 01 00 00 00 nop
200de78: 0d bf ff f4 fbg 200de48 <rtems_string_to_double+0x6c>
200de7c: 05 00 80 83 sethi %hi(0x2020c00), %g2
200de80: d1 18 a0 90 ldd [ %g2 + 0x90 ], %f8 ! 2020c90 <_CPU_Trap_slot_template+0x18>
200de84: 81 a8 0a c8 fcmped %f0, %f8
200de88: 01 00 00 00 nop
200de8c: 09 bf ff ef fbl 200de48 <rtems_string_to_double+0x6c>
200de90: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
200de94: 10 bf ff ec b 200de44 <rtems_string_to_double+0x68> <== NOT EXECUTED
200de98: c1 3e 40 00 std %f0, [ %i1 ] <== NOT EXECUTED
0200de9c <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
200de9c: 9d e3 bf 90 save %sp, -112, %sp
float result;
char *end;
if ( !n )
200dea0: 80 a6 60 00 cmp %i1, 0
200dea4: 02 80 00 18 be 200df04 <rtems_string_to_float+0x68>
200dea8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200deac: 40 00 0c bd call 20111a0 <__errno>
200deb0: 01 00 00 00 nop
200deb4: c0 22 00 00 clr [ %o0 ]
*n = 0;
200deb8: c0 26 40 00 clr [ %i1 ]
result = strtof( s, &end );
200debc: 90 10 00 18 mov %i0, %o0
200dec0: 40 00 17 d4 call 2013e10 <strtof>
200dec4: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
200dec8: 80 a6 a0 00 cmp %i2, 0
200decc: 02 80 00 03 be 200ded8 <rtems_string_to_float+0x3c>
200ded0: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200ded4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200ded8: 80 a6 00 02 cmp %i0, %g2
200dedc: 02 80 00 0a be 200df04 <rtems_string_to_float+0x68>
200dee0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dee4: 40 00 0c af call 20111a0 <__errno>
200dee8: c1 27 bf f4 st %f0, [ %fp + -12 ]
200deec: c2 02 00 00 ld [ %o0 ], %g1
200def0: 80 a0 60 22 cmp %g1, 0x22
200def4: 02 80 00 06 be 200df0c <rtems_string_to_float+0x70>
200def8: c1 07 bf f4 ld [ %fp + -12 ], %f0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
200defc: c1 26 40 00 st %f0, [ %i1 ]
return RTEMS_SUCCESSFUL;
200df00: 82 10 20 00 clr %g1
}
200df04: 81 c7 e0 08 ret
200df08: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200df0c: 05 00 80 7f sethi %hi(0x201fc00), %g2
200df10: d1 00 a2 dc ld [ %g2 + 0x2dc ], %f8 ! 201fedc <_rodata_start+0x17ec>
200df14: 81 a8 0a 28 fcmps %f0, %f8
200df18: 01 00 00 00 nop
200df1c: 13 bf ff fa fbe 200df04 <rtems_string_to_float+0x68>
200df20: 82 10 20 0a mov 0xa, %g1 ! a <PROM_START+0xa>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
200df24: 05 00 80 83 sethi %hi(0x2020c00), %g2
200df28: d1 00 a0 98 ld [ %g2 + 0x98 ], %f8 ! 2020c98 <_CPU_Trap_slot_template+0x20>
200df2c: 81 a8 0a a8 fcmpes %f0, %f8
200df30: 01 00 00 00 nop
200df34: 0d bf ff f4 fbg 200df04 <rtems_string_to_float+0x68>
200df38: 05 00 80 83 sethi %hi(0x2020c00), %g2
200df3c: d1 00 a0 9c ld [ %g2 + 0x9c ], %f8 ! 2020c9c <_CPU_Trap_slot_template+0x24>
200df40: 81 a8 0a a8 fcmpes %f0, %f8
200df44: 01 00 00 00 nop
200df48: 09 bf ff ef fbl 200df04 <rtems_string_to_float+0x68>
200df4c: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
200df50: 10 bf ff ec b 200df00 <rtems_string_to_float+0x64> <== NOT EXECUTED
200df54: c1 26 40 00 st %f0, [ %i1 ] <== NOT EXECUTED
02020224 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
2020224: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
2020228: 80 a6 60 00 cmp %i1, 0
202022c: 02 80 00 1a be 2020294 <rtems_string_to_int+0x70>
2020230: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
2020234: 40 00 6f 0d call 203be68 <__errno>
2020238: 01 00 00 00 nop
202023c: c0 22 00 00 clr [ %o0 ]
*n = 0;
2020240: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
2020244: 90 10 00 18 mov %i0, %o0
2020248: 92 07 bf fc add %fp, -4, %o1
202024c: 40 00 8f dd call 20441c0 <strtol>
2020250: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
2020254: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
2020258: 80 a6 a0 00 cmp %i2, 0
202025c: 02 80 00 03 be 2020268 <rtems_string_to_int+0x44>
2020260: ba 10 00 08 mov %o0, %i5
*endptr = end;
2020264: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
2020268: 80 a6 00 02 cmp %i0, %g2
202026c: 02 80 00 0a be 2020294 <rtems_string_to_int+0x70>
2020270: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
2020274: 40 00 6e fd call 203be68 <__errno>
2020278: 01 00 00 00 nop
202027c: c2 02 00 00 ld [ %o0 ], %g1
2020280: 80 a0 60 22 cmp %g1, 0x22
2020284: 02 80 00 06 be 202029c <rtems_string_to_int+0x78>
2020288: 03 20 00 00 sethi %hi(0x80000000), %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
202028c: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
2020290: 82 10 20 00 clr %g1
}
2020294: 81 c7 e0 08 ret
2020298: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
202029c: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
20202a0: 80 a0 60 00 cmp %g1, 0
20202a4: 02 bf ff fc be 2020294 <rtems_string_to_int+0x70>
20202a8: 82 10 20 0a mov 0xa, %g1
20202ac: 80 a7 60 00 cmp %i5, 0
20202b0: 02 bf ff f9 be 2020294 <rtems_string_to_int+0x70> <== NEVER TAKEN
20202b4: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
20202b8: 80 a7 40 02 cmp %i5, %g2
20202bc: 02 bf ff f6 be 2020294 <rtems_string_to_int+0x70> <== ALWAYS TAKEN
20202c0: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
20202c4: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
20202c8: 10 bf ff f3 b 2020294 <rtems_string_to_int+0x70> <== NOT EXECUTED
20202cc: 82 10 20 00 clr %g1 <== NOT EXECUTED
0200e0dc <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
200e0dc: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
200e0e0: 80 a6 60 00 cmp %i1, 0
200e0e4: 02 80 00 1a be 200e14c <rtems_string_to_long+0x70>
200e0e8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200e0ec: 40 00 0c 2d call 20111a0 <__errno>
200e0f0: 01 00 00 00 nop
200e0f4: c0 22 00 00 clr [ %o0 ]
*n = 0;
200e0f8: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
200e0fc: 90 10 00 18 mov %i0, %o0
200e100: 92 07 bf fc add %fp, -4, %o1
200e104: 40 00 17 e4 call 2014094 <strtol>
200e108: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
200e10c: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
200e110: 80 a6 a0 00 cmp %i2, 0
200e114: 02 80 00 03 be 200e120 <rtems_string_to_long+0x44>
200e118: ba 10 00 08 mov %o0, %i5
*endptr = end;
200e11c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200e120: 80 a6 00 02 cmp %i0, %g2
200e124: 02 80 00 0a be 200e14c <rtems_string_to_long+0x70>
200e128: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e12c: 40 00 0c 1d call 20111a0 <__errno>
200e130: 01 00 00 00 nop
200e134: c2 02 00 00 ld [ %o0 ], %g1
200e138: 80 a0 60 22 cmp %g1, 0x22
200e13c: 02 80 00 06 be 200e154 <rtems_string_to_long+0x78>
200e140: 03 20 00 00 sethi %hi(0x80000000), %g1
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
200e144: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
200e148: 82 10 20 00 clr %g1
}
200e14c: 81 c7 e0 08 ret
200e150: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200e154: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e158: 80 a0 60 00 cmp %g1, 0
200e15c: 02 bf ff fc be 200e14c <rtems_string_to_long+0x70>
200e160: 82 10 20 0a mov 0xa, %g1
200e164: 80 a7 60 00 cmp %i5, 0
200e168: 02 bf ff f9 be 200e14c <rtems_string_to_long+0x70> <== NEVER TAKEN
200e16c: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200e170: 80 a7 40 02 cmp %i5, %g2
200e174: 02 bf ff f6 be 200e14c <rtems_string_to_long+0x70> <== ALWAYS TAKEN
200e178: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
200e17c: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200e180: 10 bf ff f3 b 200e14c <rtems_string_to_long+0x70> <== NOT EXECUTED
200e184: 82 10 20 00 clr %g1 <== NOT EXECUTED
0200e004 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
200e004: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
200e008: 80 a6 60 00 cmp %i1, 0
200e00c: 02 80 00 1c be 200e07c <rtems_string_to_long_long+0x78>
200e010: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200e014: 40 00 0c 63 call 20111a0 <__errno>
200e018: 01 00 00 00 nop
200e01c: c0 22 00 00 clr [ %o0 ]
*n = 0;
200e020: c0 26 40 00 clr [ %i1 ]
200e024: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
200e028: 90 10 00 18 mov %i0, %o0
200e02c: 92 07 bf fc add %fp, -4, %o1
200e030: 40 00 18 22 call 20140b8 <strtoll>
200e034: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
200e038: c4 07 bf fc ld [ %fp + -4 ], %g2
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
200e03c: b8 10 00 08 mov %o0, %i4
if ( endptr )
200e040: 80 a6 a0 00 cmp %i2, 0
200e044: 02 80 00 03 be 200e050 <rtems_string_to_long_long+0x4c>
200e048: ba 10 00 09 mov %o1, %i5
*endptr = end;
200e04c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200e050: 80 a6 00 02 cmp %i0, %g2
200e054: 02 80 00 0a be 200e07c <rtems_string_to_long_long+0x78>
200e058: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e05c: 40 00 0c 51 call 20111a0 <__errno>
200e060: 01 00 00 00 nop
200e064: c2 02 00 00 ld [ %o0 ], %g1
200e068: 80 a0 60 22 cmp %g1, 0x22
200e06c: 02 80 00 06 be 200e084 <rtems_string_to_long_long+0x80>
200e070: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
200e074: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
200e078: 82 10 20 00 clr %g1
}
200e07c: 81 c7 e0 08 ret
200e080: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200e084: 07 3f ff ff sethi %hi(0xfffffc00), %g3
200e088: 84 10 a3 ff or %g2, 0x3ff, %g2
200e08c: 86 10 e3 ff or %g3, 0x3ff, %g3
200e090: 84 1f 00 02 xor %i4, %g2, %g2
200e094: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e098: 80 90 80 03 orcc %g2, %g3, %g0
200e09c: 12 80 00 04 bne 200e0ac <rtems_string_to_long_long+0xa8>
200e0a0: 80 97 00 1d orcc %i4, %i5, %g0
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
200e0a4: 10 bf ff f6 b 200e07c <rtems_string_to_long_long+0x78>
200e0a8: 82 10 20 0a mov 0xa, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e0ac: 02 bf ff f4 be 200e07c <rtems_string_to_long_long+0x78> <== NEVER TAKEN
200e0b0: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200e0b4: 03 20 00 00 sethi %hi(0x80000000), %g1
200e0b8: 80 a7 00 01 cmp %i4, %g1
200e0bc: 32 bf ff ef bne,a 200e078 <rtems_string_to_long_long+0x74><== NEVER TAKEN
200e0c0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200e0c4: 80 a7 60 00 cmp %i5, 0
200e0c8: 22 bf ff ed be,a 200e07c <rtems_string_to_long_long+0x78><== ALWAYS TAKEN
200e0cc: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
200e0d0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200e0d4: 10 bf ff ea b 200e07c <rtems_string_to_long_long+0x78> <== NOT EXECUTED
200e0d8: 82 10 20 00 clr %g1 <== NOT EXECUTED
020202e0 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
20202e0: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
20202e4: 80 a6 60 00 cmp %i1, 0
20202e8: 02 80 00 1b be 2020354 <rtems_string_to_unsigned_char+0x74>
20202ec: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
20202f0: 40 00 6e de call 203be68 <__errno>
20202f4: 01 00 00 00 nop
20202f8: c0 22 00 00 clr [ %o0 ]
*n = 0;
20202fc: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
2020300: 90 10 00 18 mov %i0, %o0
2020304: 92 07 bf fc add %fp, -4, %o1
2020308: 40 00 90 fc call 20446f8 <strtoul>
202030c: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
2020310: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
2020314: 80 a6 a0 00 cmp %i2, 0
2020318: 02 80 00 03 be 2020324 <rtems_string_to_unsigned_char+0x44>
202031c: ba 10 00 08 mov %o0, %i5
*endptr = end;
2020320: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
2020324: 80 a6 00 02 cmp %i0, %g2
2020328: 02 80 00 0b be 2020354 <rtems_string_to_unsigned_char+0x74>
202032c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
2020330: 40 00 6e ce call 203be68 <__errno>
2020334: 01 00 00 00 nop
2020338: c2 02 00 00 ld [ %o0 ], %g1
202033c: 80 a0 60 22 cmp %g1, 0x22
2020340: 02 80 00 0e be 2020378 <rtems_string_to_unsigned_char+0x98>
2020344: 80 a7 60 ff cmp %i5, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
2020348: 18 80 00 05 bgu 202035c <rtems_string_to_unsigned_char+0x7c>
202034c: 82 10 20 00 clr %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
2020350: fa 2e 40 00 stb %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
}
2020354: 81 c7 e0 08 ret
2020358: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
202035c: 40 00 6e c3 call 203be68 <__errno>
2020360: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
2020364: 82 10 20 0a mov 0xa, %g1 ! a <PROM_START+0xa>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
2020368: 84 10 20 22 mov 0x22, %g2
202036c: c4 22 00 00 st %g2, [ %o0 ]
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
2020370: 81 c7 e0 08 ret
2020374: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
2020378: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
202037c: 80 a0 bf fd cmp %g2, -3
2020380: 18 bf ff f5 bgu 2020354 <rtems_string_to_unsigned_char+0x74><== ALWAYS TAKEN
2020384: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
2020388: 10 bf ff f0 b 2020348 <rtems_string_to_unsigned_char+0x68><== NOT EXECUTED
202038c: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
0200e248 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
200e248: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
200e24c: 80 a6 60 00 cmp %i1, 0
200e250: 02 80 00 1a be 200e2b8 <rtems_string_to_unsigned_int+0x70>
200e254: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200e258: 40 00 0b d2 call 20111a0 <__errno>
200e25c: 01 00 00 00 nop
200e260: c0 22 00 00 clr [ %o0 ]
*n = 0;
200e264: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200e268: 90 10 00 18 mov %i0, %o0
200e26c: 92 07 bf fc add %fp, -4, %o1
200e270: 40 00 18 d7 call 20145cc <strtoul>
200e274: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
200e278: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
200e27c: 80 a6 a0 00 cmp %i2, 0
200e280: 02 80 00 03 be 200e28c <rtems_string_to_unsigned_int+0x44>
200e284: ba 10 00 08 mov %o0, %i5
*endptr = end;
200e288: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200e28c: 80 a6 00 02 cmp %i0, %g2
200e290: 02 80 00 0a be 200e2b8 <rtems_string_to_unsigned_int+0x70>
200e294: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e298: 40 00 0b c2 call 20111a0 <__errno>
200e29c: 01 00 00 00 nop
200e2a0: c2 02 00 00 ld [ %o0 ], %g1
200e2a4: 80 a0 60 22 cmp %g1, 0x22
200e2a8: 02 80 00 06 be 200e2c0 <rtems_string_to_unsigned_int+0x78>
200e2ac: 84 07 7f ff add %i5, -1, %g2
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
200e2b0: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
200e2b4: 82 10 20 00 clr %g1
}
200e2b8: 81 c7 e0 08 ret
200e2bc: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e2c0: 80 a0 bf fd cmp %g2, -3
200e2c4: 18 bf ff fd bgu 200e2b8 <rtems_string_to_unsigned_int+0x70><== ALWAYS TAKEN
200e2c8: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
200e2cc: 10 bf ff fa b 200e2b4 <rtems_string_to_unsigned_int+0x6c> <== NOT EXECUTED
200e2d0: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
0200c4d8 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
200c4d8: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
200c4dc: 80 a6 60 00 cmp %i1, 0
200c4e0: 02 80 00 1a be 200c548 <rtems_string_to_unsigned_long+0x70>
200c4e4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200c4e8: 40 00 be 60 call 203be68 <__errno>
200c4ec: 01 00 00 00 nop
200c4f0: c0 22 00 00 clr [ %o0 ]
*n = 0;
200c4f4: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200c4f8: 90 10 00 18 mov %i0, %o0
200c4fc: 92 07 bf fc add %fp, -4, %o1
200c500: 40 00 e0 7e call 20446f8 <strtoul>
200c504: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
200c508: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
200c50c: 80 a6 a0 00 cmp %i2, 0
200c510: 02 80 00 03 be 200c51c <rtems_string_to_unsigned_long+0x44>
200c514: ba 10 00 08 mov %o0, %i5
*endptr = end;
200c518: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200c51c: 80 a6 00 02 cmp %i0, %g2
200c520: 02 80 00 0a be 200c548 <rtems_string_to_unsigned_long+0x70>
200c524: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200c528: 40 00 be 50 call 203be68 <__errno>
200c52c: 01 00 00 00 nop
200c530: c2 02 00 00 ld [ %o0 ], %g1
200c534: 80 a0 60 22 cmp %g1, 0x22
200c538: 02 80 00 06 be 200c550 <rtems_string_to_unsigned_long+0x78>
200c53c: 84 07 7f ff add %i5, -1, %g2
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200c540: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
200c544: 82 10 20 00 clr %g1
}
200c548: 81 c7 e0 08 ret
200c54c: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200c550: 80 a0 bf fd cmp %g2, -3
200c554: 18 bf ff fd bgu 200c548 <rtems_string_to_unsigned_long+0x70><== ALWAYS TAKEN
200c558: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200c55c: 10 bf ff fa b 200c544 <rtems_string_to_unsigned_long+0x6c><== NOT EXECUTED
200c560: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
0200e2d4 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
200e2d4: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
200e2d8: 80 a6 60 00 cmp %i1, 0
200e2dc: 02 80 00 1c be 200e34c <rtems_string_to_unsigned_long_long+0x78>
200e2e0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200e2e4: 40 00 0b af call 20111a0 <__errno>
200e2e8: 01 00 00 00 nop
200e2ec: c0 22 00 00 clr [ %o0 ]
*n = 0;
200e2f0: c0 26 40 00 clr [ %i1 ]
200e2f4: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
200e2f8: 90 10 00 18 mov %i0, %o0
200e2fc: 92 07 bf fc add %fp, -4, %o1
200e300: 40 00 18 bc call 20145f0 <strtoull>
200e304: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
200e308: c4 07 bf fc ld [ %fp + -4 ], %g2
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
200e30c: b8 10 00 08 mov %o0, %i4
if ( endptr )
200e310: 80 a6 a0 00 cmp %i2, 0
200e314: 02 80 00 03 be 200e320 <rtems_string_to_unsigned_long_long+0x4c>
200e318: ba 10 00 09 mov %o1, %i5
*endptr = end;
200e31c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200e320: 80 a6 00 02 cmp %i0, %g2
200e324: 02 80 00 0a be 200e34c <rtems_string_to_unsigned_long_long+0x78>
200e328: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e32c: 40 00 0b 9d call 20111a0 <__errno>
200e330: 01 00 00 00 nop
200e334: c2 02 00 00 ld [ %o0 ], %g1
200e338: 80 a0 60 22 cmp %g1, 0x22
200e33c: 02 80 00 06 be 200e354 <rtems_string_to_unsigned_long_long+0x80>
200e340: 86 87 7f ff addcc %i5, -1, %g3
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200e344: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
200e348: 82 10 20 00 clr %g1
}
200e34c: 81 c7 e0 08 ret
200e350: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
200e354: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200e358: 80 a0 bf ff cmp %g2, -1
200e35c: 12 bf ff fa bne 200e344 <rtems_string_to_unsigned_long_long+0x70><== NEVER TAKEN
200e360: 80 a0 ff fd cmp %g3, -3
200e364: 18 bf ff fa bgu 200e34c <rtems_string_to_unsigned_long_long+0x78><== ALWAYS TAKEN
200e368: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200e36c: 10 bf ff f7 b 200e348 <rtems_string_to_unsigned_long_long+0x74><== NOT EXECUTED
200e370: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
02003050 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
2003050: 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 =
2003054: 94 10 20 18 mov 0x18, %o2
2003058: 92 10 00 18 mov %i0, %o1
200305c: 40 00 08 58 call 20051bc <rtems_filesystem_eval_path_start>
2003060: 90 07 be 60 add %fp, -416, %o0
static inline void rtems_filesystem_eval_path_extract_currentloc(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_location_info_t *get
)
{
rtems_filesystem_location_copy_and_detach(
2003064: 92 07 be 78 add %fp, -392, %o1
2003068: aa 10 00 08 mov %o0, %l5
200306c: 40 00 09 4d call 20055a0 <rtems_filesystem_location_copy_and_detach>
2003070: 90 07 be 48 add %fp, -440, %o0
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
2003074: c2 07 be 5c ld [ %fp + -420 ], %g1
static inline void rtems_filesystem_eval_path_set_flags(
rtems_filesystem_eval_path_context_t *ctx,
int flags
)
{
ctx->flags = flags;
2003078: 84 10 20 60 mov 0x60, %g2
200307c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2003080: c4 27 be 70 st %g2, [ %fp + -400 ]
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2003084: 05 00 80 82 sethi %hi(0x2020800), %g2
2003088: 84 10 a0 30 or %g2, 0x30, %g2 ! 2020830 <IMFS_ops>
200308c: 80 a0 40 02 cmp %g1, %g2
2003090: 02 80 00 06 be 20030a8 <rtems_tarfs_load+0x58>
2003094: 05 00 80 84 sethi %hi(0x2021000), %g2
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
2003098: 84 10 a1 a0 or %g2, 0x1a0, %g2 ! 20211a0 <fifoIMFS_ops>
200309c: 80 a0 40 02 cmp %g1, %g2
20030a0: 12 80 00 78 bne 2003280 <rtems_tarfs_load+0x230> <== ALWAYS TAKEN
20030a4: 01 00 00 00 nop
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
20030a8: 80 a6 a1 ff cmp %i2, 0x1ff
20030ac: 08 80 00 4b bleu 20031d8 <rtems_tarfs_load+0x188> <== NEVER TAKEN
20030b0: 01 00 00 00 nop
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
20030b4: ac 07 bf 00 add %fp, -256, %l6
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
20030b8: 27 00 80 82 sethi %hi(0x2020800), %l3
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
20030bc: 84 38 00 16 xnor %g0, %l6, %g2
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
20030c0: a2 10 22 00 mov 0x200, %l1
20030c4: b8 10 22 00 mov 0x200, %i4
20030c8: ba 10 20 00 clr %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
20030cc: a6 14 e0 b8 or %l3, 0xb8, %l3
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
20030d0: a0 07 be 98 add %fp, -360, %l0
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
20030d4: 10 80 00 08 b 20030f4 <rtems_tarfs_load+0xa4>
20030d8: c4 27 be 44 st %g2, [ %fp + -444 ]
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
20030dc: 02 80 00 46 be 20031f4 <rtems_tarfs_load+0x1a4>
20030e0: ba 10 00 1c mov %i4, %i5
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
20030e4: b8 07 62 00 add %i5, 0x200, %i4
20030e8: 80 a7 00 1a cmp %i4, %i2
20030ec: 18 80 00 3b bgu 20031d8 <rtems_tarfs_load+0x188> <== NEVER TAKEN
20030f0: a2 10 00 1c mov %i4, %l1
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
20030f4: ba 06 40 1d add %i1, %i5, %i5
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
20030f8: 92 10 00 13 mov %l3, %o1
20030fc: 90 07 61 01 add %i5, 0x101, %o0
2003100: 40 00 47 ab call 2014fac <strncmp>
2003104: 94 10 20 05 mov 5, %o2
2003108: 80 a2 20 00 cmp %o0, 0
200310c: 12 80 00 33 bne 20031d8 <rtems_tarfs_load+0x188>
2003110: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
2003114: 92 10 00 1d mov %i5, %o1
2003118: 40 00 47 fb call 2015104 <strncpy>
200311c: 90 10 00 10 mov %l0, %o0
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
2003120: 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';
2003124: c0 2f be fb clrb [ %fp + -261 ]
linkflag = hdr_ptr[156];
2003128: f6 0f 60 9c ldub [ %i5 + 0x9c ], %i3
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
200312c: 40 00 23 d1 call 200c070 <_rtems_octal2ulong>
2003130: 90 07 60 64 add %i5, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
2003134: 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);
2003138: a8 10 00 08 mov %o0, %l4
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
200313c: 40 00 23 cd call 200c070 <_rtems_octal2ulong>
2003140: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
2003144: 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);
2003148: a4 10 00 08 mov %o0, %l2
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
200314c: 40 00 23 c9 call 200c070 <_rtems_octal2ulong>
2003150: 90 07 60 94 add %i5, 0x94, %o0
2003154: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
2003158: 40 00 25 20 call 200c5d8 <_rtems_tar_header_checksum>
200315c: 90 10 00 1d mov %i5, %o0
2003160: 80 a2 00 17 cmp %o0, %l7
2003164: 12 80 00 1d bne 20031d8 <rtems_tarfs_load+0x188> <== NEVER TAKEN
2003168: 01 00 00 00 nop
* 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) {
200316c: b6 0e e0 ff and %i3, 0xff, %i3
2003170: 80 a6 e0 35 cmp %i3, 0x35
2003174: 12 bf ff da bne 20030dc <rtems_tarfs_load+0x8c>
2003178: 80 a6 e0 30 cmp %i3, 0x30
strcpy(full_filename, mountpoint);
200317c: 90 10 00 16 mov %l6, %o0
2003180: 40 00 45 27 call 201461c <stpcpy>
2003184: 92 10 00 18 mov %i0, %o1
if (full_filename[strlen(full_filename)-1] != '/')
2003188: c4 07 be 44 ld [ %fp + -444 ], %g2
200318c: 82 07 80 08 add %fp, %o0, %g1
2003190: 82 00 40 02 add %g1, %g2, %g1
2003194: c2 48 7f 00 ldsb [ %g1 + -256 ], %g1
2003198: 80 a0 60 2f cmp %g1, 0x2f
200319c: 02 80 00 04 be 20031ac <rtems_tarfs_load+0x15c> <== ALWAYS TAKEN
20031a0: 82 10 20 2f mov 0x2f, %g1
strcat(full_filename, "/");
20031a4: c0 2a 20 01 clrb [ %o0 + 1 ] <== NOT EXECUTED
20031a8: c2 2a 00 00 stb %g1, [ %o0 ] <== NOT EXECUTED
strcat(full_filename, filename);
20031ac: 92 10 00 10 mov %l0, %o1
20031b0: 40 00 45 3a call 2014698 <strcat>
20031b4: 90 10 00 16 mov %l6, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
20031b8: 90 10 00 16 mov %l6, %o0
20031bc: 40 00 04 01 call 20041c0 <mkdir>
20031c0: 92 10 21 ff mov 0x1ff, %o1
20031c4: ba 10 00 1c mov %i4, %i5
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
20031c8: b8 07 62 00 add %i5, 0x200, %i4
20031cc: 80 a7 00 1a cmp %i4, %i2
20031d0: 08 bf ff c9 bleu 20030f4 <rtems_tarfs_load+0xa4> <== ALWAYS TAKEN
20031d4: a2 10 00 1c mov %i4, %l1
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
20031d8: 40 00 02 5b call 2003b44 <rtems_filesystem_location_free>
20031dc: 90 07 be 48 add %fp, -440, %o0
if (
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
) {
rv = -1;
20031e0: b0 10 20 00 clr %i0
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
rtems_filesystem_eval_path_cleanup( &ctx );
20031e4: 40 00 08 36 call 20052bc <rtems_filesystem_eval_path_cleanup>
20031e8: 90 07 be 60 add %fp, -416, %o0
20031ec: 81 c7 e0 08 ret
20031f0: 81 e8 00 00 restore
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
rtems_filesystem_location_free( currentloc );
20031f4: 40 00 02 54 call 2003b44 <rtems_filesystem_location_free>
20031f8: 90 10 00 15 mov %l5, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
20031fc: 92 07 be 48 add %fp, -440, %o1
2003200: 40 00 01 83 call 200380c <rtems_filesystem_location_clone>
2003204: 90 10 00 15 mov %l5, %o0
rtems_filesystem_eval_path_set_path(
2003208: 40 00 47 37 call 2014ee4 <strlen>
200320c: 90 10 00 10 mov %l0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
2003210: e0 27 be 60 st %l0, [ %fp + -416 ]
ctx->pathlen = pathlen;
2003214: d0 27 be 64 st %o0, [ %fp + -412 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
2003218: 40 00 07 6c call 2004fc8 <rtems_filesystem_eval_path_continue>
200321c: 90 07 be 60 add %fp, -416, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
2003220: c2 05 60 10 ld [ %l5 + 0x10 ], %g1
2003224: 05 00 80 83 sethi %hi(0x2020c00), %g2
2003228: 84 10 a2 fc or %g2, 0x2fc, %g2 ! 2020efc <rtems_filesystem_null_handlers>
200322c: 80 a0 40 02 cmp %g1, %g2
2003230: 02 80 00 10 be 2003270 <rtems_tarfs_load+0x220> <== NEVER TAKEN
2003234: d4 07 be 68 ld [ %fp + -408 ], %o2
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
2003238: c2 05 60 14 ld [ %l5 + 0x14 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
200323c: c2 00 60 08 ld [ %g1 + 8 ], %g1
2003240: d6 07 be 6c ld [ %fp + -404 ], %o3
2003244: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2003248: 03 00 00 20 sethi %hi(0x8000), %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,
200324c: 98 0d 21 ff and %l4, 0x1ff, %o4
2003250: 90 10 00 15 mov %l5, %o0
2003254: 98 13 00 01 or %o4, %g1, %o4
2003258: 40 00 25 9a call 200c8c0 <IMFS_create_node_with_control>
200325c: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
2003260: 82 06 40 11 add %i1, %l1, %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;
2003264: c0 22 20 50 clr [ %o0 + 0x50 ]
2003268: e4 22 20 54 st %l2, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
200326c: c2 22 20 58 st %g1, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
2003270: ba 04 a1 ff add %l2, 0x1ff, %i5
offset += 512 * nblocks;
2003274: ba 0f 7e 00 and %i5, -512, %i5
2003278: 10 bf ff 9b b 20030e4 <rtems_tarfs_load+0x94>
200327c: ba 07 40 11 add %i5, %l1, %i5
}
}
rtems_filesystem_location_free( &rootloc );
2003280: 40 00 02 31 call 2003b44 <rtems_filesystem_location_free>
2003284: 90 07 be 48 add %fp, -440, %o0
if (
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
) {
rv = -1;
2003288: b0 10 3f ff mov -1, %i0
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
rtems_filesystem_eval_path_cleanup( &ctx );
200328c: 40 00 08 0c call 20052bc <rtems_filesystem_eval_path_cleanup>
2003290: 90 07 be 60 add %fp, -416, %o0
2003294: 81 c7 e0 08 ret
2003298: 81 e8 00 00 restore
02011ed8 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
2011ed8: 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 )
2011edc: 80 a6 a0 00 cmp %i2, 0
2011ee0: 02 80 00 3b be 2011fcc <rtems_task_mode+0xf4>
2011ee4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
2011ee8: 21 00 80 8b sethi %hi(0x2022c00), %l0
2011eec: a0 14 23 d0 or %l0, 0x3d0, %l0 ! 2022fd0 <_Per_CPU_Information>
2011ef0: fa 04 20 10 ld [ %l0 + 0x10 ], %i5
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
2011ef4: c4 0f 60 70 ldub [ %i5 + 0x70 ], %g2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
2011ef8: c2 07 60 78 ld [ %i5 + 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;
2011efc: 80 a0 00 02 cmp %g0, %g2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
2011f00: f8 07 61 58 ld [ %i5 + 0x158 ], %i4
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
2011f04: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
2011f08: 80 a0 60 00 cmp %g1, 0
2011f0c: 12 80 00 40 bne 201200c <rtems_task_mode+0x134>
2011f10: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
2011f14: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
2011f18: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
2011f1c: 7f ff eb a8 call 200cdbc <_CPU_ISR_Get_level>
2011f20: a2 60 3f ff subx %g0, -1, %l1
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;
2011f24: a3 2c 60 0a sll %l1, 0xa, %l1
2011f28: 90 14 40 08 or %l1, %o0, %o0
old_mode |= _ISR_Get_level();
2011f2c: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
2011f30: 80 8e 61 00 btst 0x100, %i1
2011f34: 02 80 00 06 be 2011f4c <rtems_task_mode+0x74>
2011f38: 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;
2011f3c: 83 36 20 08 srl %i0, 8, %g1
2011f40: 82 18 60 01 xor %g1, 1, %g1
2011f44: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
2011f48: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
2011f4c: 80 8e 62 00 btst 0x200, %i1
2011f50: 12 80 00 21 bne 2011fd4 <rtems_task_mode+0xfc>
2011f54: 80 8e 22 00 btst 0x200, %i0
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
2011f58: 80 8e 60 0f btst 0xf, %i1
2011f5c: 12 80 00 27 bne 2011ff8 <rtems_task_mode+0x120>
2011f60: 01 00 00 00 nop
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
2011f64: 80 8e 64 00 btst 0x400, %i1
2011f68: 02 80 00 14 be 2011fb8 <rtems_task_mode+0xe0>
2011f6c: 86 10 20 00 clr %g3
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
2011f70: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
2011f74: b1 36 20 0a srl %i0, 0xa, %i0
2011f78: b0 1e 20 01 xor %i0, 1, %i0
2011f7c: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
2011f80: 80 a6 00 01 cmp %i0, %g1
2011f84: 22 80 00 0e be,a 2011fbc <rtems_task_mode+0xe4>
2011f88: 03 00 80 8b sethi %hi(0x2022c00), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
2011f8c: 7f ff c3 69 call 2002d30 <sparc_disable_interrupts>
2011f90: f0 2f 20 08 stb %i0, [ %i4 + 8 ]
_signals = information->signals_pending;
2011f94: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
information->signals_pending = information->signals_posted;
2011f98: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
information->signals_posted = _signals;
2011f9c: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
2011fa0: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
2011fa4: 7f ff c3 67 call 2002d40 <sparc_enable_interrupts>
2011fa8: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
2011fac: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2011fb0: 80 a0 00 01 cmp %g0, %g1
2011fb4: 86 40 20 00 addx %g0, 0, %g3
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
2011fb8: 03 00 80 8b sethi %hi(0x2022c00), %g1
2011fbc: c4 00 63 c8 ld [ %g1 + 0x3c8 ], %g2 ! 2022fc8 <_System_state_Current>
2011fc0: 80 a0 a0 03 cmp %g2, 3
2011fc4: 02 80 00 1f be 2012040 <rtems_task_mode+0x168>
2011fc8: 82 10 20 00 clr %g1
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
2011fcc: 81 c7 e0 08 ret
2011fd0: 91 e8 00 01 restore %g0, %g1, %o0
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
2011fd4: 22 bf ff e1 be,a 2011f58 <rtems_task_mode+0x80>
2011fd8: c0 27 60 78 clr [ %i5 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
2011fdc: 03 00 80 8a sethi %hi(0x2022800), %g1
2011fe0: c2 00 62 10 ld [ %g1 + 0x210 ], %g1 ! 2022a10 <_Thread_Ticks_per_timeslice>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
2011fe4: 80 8e 60 0f btst 0xf, %i1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
2011fe8: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
2011fec: 82 10 20 01 mov 1, %g1
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
2011ff0: 02 bf ff dd be 2011f64 <rtems_task_mode+0x8c>
2011ff4: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
2011ff8: 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 ) );
2011ffc: 7f ff c3 51 call 2002d40 <sparc_enable_interrupts>
2012000: 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 ) {
2012004: 10 bf ff d9 b 2011f68 <rtems_task_mode+0x90>
2012008: 80 8e 64 00 btst 0x400, %i1
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;
201200c: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
2012010: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
2012014: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
2012018: 7f ff eb 69 call 200cdbc <_CPU_ISR_Get_level>
201201c: a2 60 3f ff subx %g0, -1, %l1
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;
2012020: a3 2c 60 0a sll %l1, 0xa, %l1
2012024: 90 14 40 08 or %l1, %o0, %o0
old_mode |= _ISR_Get_level();
2012028: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
201202c: 80 8e 61 00 btst 0x100, %i1
2012030: 02 bf ff c7 be 2011f4c <rtems_task_mode+0x74>
2012034: 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;
2012038: 10 bf ff c2 b 2011f40 <rtems_task_mode+0x68>
201203c: 83 36 20 08 srl %i0, 8, %g1
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
2012040: 80 88 e0 ff btst 0xff, %g3
2012044: 12 80 00 0a bne 201206c <rtems_task_mode+0x194>
2012048: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
201204c: c6 04 20 14 ld [ %l0 + 0x14 ], %g3
2012050: 80 a0 80 03 cmp %g2, %g3
2012054: 02 bf ff de be 2011fcc <rtems_task_mode+0xf4>
2012058: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
201205c: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
2012060: 80 a0 a0 00 cmp %g2, 0
2012064: 02 bf ff da be 2011fcc <rtems_task_mode+0xf4> <== NEVER TAKEN
2012068: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
201206c: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
2012070: c2 2c 20 0c stb %g1, [ %l0 + 0xc ]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
2012074: 40 00 02 95 call 2012ac8 <_Thread_Dispatch>
2012078: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
201207c: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
2012080: 81 c7 e0 08 ret
2012084: 91 e8 00 01 restore %g0, %g1, %o0
0200c6b4 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
200c6b4: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
200c6b8: 80 a6 60 00 cmp %i1, 0
200c6bc: 02 80 00 08 be 200c6dc <rtems_task_set_priority+0x28>
200c6c0: 80 a6 a0 00 cmp %i2, 0
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
200c6c4: 03 00 80 88 sethi %hi(0x2022000), %g1
200c6c8: c4 08 61 0c ldub [ %g1 + 0x10c ], %g2 ! 202210c <rtems_maximum_priority>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
200c6cc: 80 a6 40 02 cmp %i1, %g2
200c6d0: 18 80 00 1e bgu 200c748 <rtems_task_set_priority+0x94>
200c6d4: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
200c6d8: 80 a6 a0 00 cmp %i2, 0
200c6dc: 02 80 00 1b be 200c748 <rtems_task_set_priority+0x94>
200c6e0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
200c6e4: 90 10 00 18 mov %i0, %o0
200c6e8: 40 00 0a 4c call 200f018 <_Thread_Get>
200c6ec: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200c6f0: c2 07 bf fc ld [ %fp + -4 ], %g1
200c6f4: 80 a0 60 00 cmp %g1, 0
200c6f8: 12 80 00 16 bne 200c750 <rtems_task_set_priority+0x9c>
200c6fc: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
200c700: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
200c704: 80 a6 60 00 cmp %i1, 0
200c708: 02 80 00 0d be 200c73c <rtems_task_set_priority+0x88>
200c70c: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
200c710: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200c714: 80 a0 60 00 cmp %g1, 0
200c718: 02 80 00 06 be 200c730 <rtems_task_set_priority+0x7c>
200c71c: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
200c720: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200c724: 80 a6 40 01 cmp %i1, %g1
200c728: 1a 80 00 05 bcc 200c73c <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
200c72c: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
200c730: 92 10 00 19 mov %i1, %o1
200c734: 40 00 08 db call 200eaa0 <_Thread_Change_priority>
200c738: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
200c73c: 40 00 0a 2b call 200efe8 <_Thread_Enable_dispatch>
200c740: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
200c744: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200c748: 81 c7 e0 08 ret
200c74c: 91 e8 00 01 restore %g0, %g1, %o0
200c750: 81 c7 e0 08 ret
200c754: 91 e8 00 01 restore %g0, %g1, %o0
0200621c <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
200621c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
2006220: 80 a6 60 00 cmp %i1, 0
2006224: 02 80 00 1e be 200629c <rtems_task_variable_delete+0x80>
2006228: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
200622c: 90 10 00 18 mov %i0, %o0
2006230: 40 00 08 c0 call 2008530 <_Thread_Get>
2006234: 92 07 bf fc add %fp, -4, %o1
switch (location) {
2006238: c2 07 bf fc ld [ %fp + -4 ], %g1
200623c: 80 a0 60 00 cmp %g1, 0
2006240: 12 80 00 19 bne 20062a4 <rtems_task_variable_delete+0x88>
2006244: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
2006248: c2 02 21 64 ld [ %o0 + 0x164 ], %g1
while (tvp) {
200624c: 80 a0 60 00 cmp %g1, 0
2006250: 02 80 00 10 be 2006290 <rtems_task_variable_delete+0x74>
2006254: 01 00 00 00 nop
if (tvp->ptr == ptr) {
2006258: c4 00 60 04 ld [ %g1 + 4 ], %g2
200625c: 80 a0 80 19 cmp %g2, %i1
2006260: 32 80 00 09 bne,a 2006284 <rtems_task_variable_delete+0x68>
2006264: d2 00 40 00 ld [ %g1 ], %o1
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
2006268: 10 80 00 18 b 20062c8 <rtems_task_variable_delete+0xac>
200626c: c4 00 40 00 ld [ %g1 ], %g2
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
2006270: 80 a0 80 19 cmp %g2, %i1
2006274: 22 80 00 0e be,a 20062ac <rtems_task_variable_delete+0x90>
2006278: c4 02 40 00 ld [ %o1 ], %g2
200627c: 82 10 00 09 mov %o1, %g1
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
2006280: d2 00 40 00 ld [ %g1 ], %o1
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
2006284: 80 a2 60 00 cmp %o1, 0
2006288: 32 bf ff fa bne,a 2006270 <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
200628c: c4 02 60 04 ld [ %o1 + 4 ], %g2
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
2006290: 40 00 08 9c call 2008500 <_Thread_Enable_dispatch>
2006294: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
2006298: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200629c: 81 c7 e0 08 ret
20062a0: 91 e8 00 01 restore %g0, %g1, %o0
20062a4: 81 c7 e0 08 ret
20062a8: 91 e8 00 01 restore %g0, %g1, %o0
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
20062ac: c4 20 40 00 st %g2, [ %g1 ]
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
20062b0: 40 00 00 2e call 2006368 <_RTEMS_Tasks_Invoke_task_variable_dtor>
20062b4: 01 00 00 00 nop
_Thread_Enable_dispatch();
20062b8: 40 00 08 92 call 2008500 <_Thread_Enable_dispatch>
20062bc: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
20062c0: 10 bf ff f7 b 200629c <rtems_task_variable_delete+0x80>
20062c4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
20062c8: 92 10 00 01 mov %g1, %o1
20062cc: 10 bf ff f9 b 20062b0 <rtems_task_variable_delete+0x94>
20062d0: c4 22 21 64 st %g2, [ %o0 + 0x164 ]
020062d4 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
20062d4: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
20062d8: 80 a6 60 00 cmp %i1, 0
20062dc: 02 80 00 1b be 2006348 <rtems_task_variable_get+0x74>
20062e0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !result )
20062e4: 80 a6 a0 00 cmp %i2, 0
20062e8: 02 80 00 18 be 2006348 <rtems_task_variable_get+0x74>
20062ec: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
20062f0: 40 00 08 90 call 2008530 <_Thread_Get>
20062f4: 92 07 bf fc add %fp, -4, %o1
switch (location) {
20062f8: c2 07 bf fc ld [ %fp + -4 ], %g1
20062fc: 80 a0 60 00 cmp %g1, 0
2006300: 12 80 00 14 bne 2006350 <rtems_task_variable_get+0x7c>
2006304: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
2006308: c2 02 21 64 ld [ %o0 + 0x164 ], %g1
while (tvp) {
200630c: 80 a0 60 00 cmp %g1, 0
2006310: 32 80 00 07 bne,a 200632c <rtems_task_variable_get+0x58>
2006314: c4 00 60 04 ld [ %g1 + 4 ], %g2
2006318: 30 80 00 10 b,a 2006358 <rtems_task_variable_get+0x84>
200631c: 80 a0 60 00 cmp %g1, 0
2006320: 02 80 00 0e be 2006358 <rtems_task_variable_get+0x84> <== NEVER TAKEN
2006324: 01 00 00 00 nop
if (tvp->ptr == ptr) {
2006328: c4 00 60 04 ld [ %g1 + 4 ], %g2
200632c: 80 a0 80 19 cmp %g2, %i1
2006330: 32 bf ff fb bne,a 200631c <rtems_task_variable_get+0x48>
2006334: c2 00 40 00 ld [ %g1 ], %g1
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
2006338: c2 00 60 0c ld [ %g1 + 0xc ], %g1
_Thread_Enable_dispatch();
200633c: 40 00 08 71 call 2008500 <_Thread_Enable_dispatch>
2006340: c2 26 80 00 st %g1, [ %i2 ]
return RTEMS_SUCCESSFUL;
2006344: 82 10 20 00 clr %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2006348: 81 c7 e0 08 ret
200634c: 91 e8 00 01 restore %g0, %g1, %o0
2006350: 81 c7 e0 08 ret
2006354: 91 e8 00 01 restore %g0, %g1, %o0
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
2006358: 40 00 08 6a call 2008500 <_Thread_Enable_dispatch>
200635c: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
2006360: 10 bf ff fa b 2006348 <rtems_task_variable_get+0x74>
2006364: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
02006484 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
2006484: 80 a2 20 09 cmp %o0, 9
2006488: 02 80 00 1c be 20064f8 <rtems_termios_baud_to_index+0x74>
200648c: 82 10 20 09 mov 9, %g1
2006490: 80 a2 20 09 cmp %o0, 9
2006494: 08 80 00 1b bleu 2006500 <rtems_termios_baud_to_index+0x7c>
2006498: 80 a2 20 04 cmp %o0, 4
200649c: 80 a2 20 0e cmp %o0, 0xe
20064a0: 02 80 00 16 be 20064f8 <rtems_termios_baud_to_index+0x74>
20064a4: 82 10 20 0e mov 0xe, %g1
20064a8: 80 a2 20 0e cmp %o0, 0xe
20064ac: 08 80 00 28 bleu 200654c <rtems_termios_baud_to_index+0xc8>
20064b0: 80 a2 20 0b cmp %o0, 0xb
20064b4: 05 00 00 04 sethi %hi(0x1000), %g2
20064b8: 86 10 a0 02 or %g2, 2, %g3 ! 1002 <PROM_START+0x1002>
20064bc: 80 a2 00 03 cmp %o0, %g3
20064c0: 02 80 00 0e be 20064f8 <rtems_termios_baud_to_index+0x74>
20064c4: 82 10 20 11 mov 0x11, %g1
20064c8: 80 a2 00 03 cmp %o0, %g3
20064cc: 08 80 00 3a bleu 20065b4 <rtems_termios_baud_to_index+0x130>
20064d0: 80 a2 20 0f cmp %o0, 0xf
20064d4: 86 10 a0 03 or %g2, 3, %g3
20064d8: 80 a2 00 03 cmp %o0, %g3
20064dc: 02 80 00 07 be 20064f8 <rtems_termios_baud_to_index+0x74>
20064e0: 82 10 20 12 mov 0x12, %g1
20064e4: 84 10 a0 04 or %g2, 4, %g2
20064e8: 80 a2 00 02 cmp %o0, %g2
20064ec: 02 80 00 03 be 20064f8 <rtems_termios_baud_to_index+0x74>
20064f0: 82 10 20 13 mov 0x13, %g1
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;
20064f4: 82 10 3f ff mov -1, %g1
}
return baud_index;
}
20064f8: 81 c3 e0 08 retl
20064fc: 90 10 00 01 mov %g1, %o0
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
2006500: 02 bf ff fe be 20064f8 <rtems_termios_baud_to_index+0x74>
2006504: 82 10 20 04 mov 4, %g1
2006508: 80 a2 20 04 cmp %o0, 4
200650c: 08 80 00 1d bleu 2006580 <rtems_termios_baud_to_index+0xfc>
2006510: 80 a2 20 01 cmp %o0, 1
2006514: 80 a2 20 06 cmp %o0, 6
2006518: 02 bf ff f8 be 20064f8 <rtems_termios_baud_to_index+0x74>
200651c: 82 10 20 06 mov 6, %g1
2006520: 80 a2 20 06 cmp %o0, 6
2006524: 0a bf ff f5 bcs 20064f8 <rtems_termios_baud_to_index+0x74>
2006528: 82 10 20 05 mov 5, %g1
200652c: 80 a2 20 07 cmp %o0, 7
2006530: 02 bf ff f2 be 20064f8 <rtems_termios_baud_to_index+0x74>
2006534: 82 10 20 07 mov 7, %g1
2006538: 80 a2 20 08 cmp %o0, 8
200653c: 02 bf ff ef be 20064f8 <rtems_termios_baud_to_index+0x74> <== ALWAYS TAKEN
2006540: 82 10 20 08 mov 8, %g1
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;
2006544: 10 bf ff ed b 20064f8 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
2006548: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
200654c: 02 bf ff eb be 20064f8 <rtems_termios_baud_to_index+0x74>
2006550: 82 10 20 0b mov 0xb, %g1
2006554: 80 a2 20 0b cmp %o0, 0xb
2006558: 0a bf ff e8 bcs 20064f8 <rtems_termios_baud_to_index+0x74>
200655c: 82 10 20 0a mov 0xa, %g1
2006560: 80 a2 20 0c cmp %o0, 0xc
2006564: 02 bf ff e5 be 20064f8 <rtems_termios_baud_to_index+0x74>
2006568: 82 10 20 0c mov 0xc, %g1
200656c: 80 a2 20 0d cmp %o0, 0xd
2006570: 02 bf ff e2 be 20064f8 <rtems_termios_baud_to_index+0x74> <== ALWAYS TAKEN
2006574: 82 10 20 0d mov 0xd, %g1
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;
2006578: 10 bf ff e0 b 20064f8 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
200657c: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
2006580: 02 bf ff de be 20064f8 <rtems_termios_baud_to_index+0x74>
2006584: 82 10 20 01 mov 1, %g1
2006588: 80 a2 20 01 cmp %o0, 1
200658c: 0a bf ff db bcs 20064f8 <rtems_termios_baud_to_index+0x74>
2006590: 82 10 20 00 clr %g1
2006594: 80 a2 20 02 cmp %o0, 2
2006598: 02 bf ff d8 be 20064f8 <rtems_termios_baud_to_index+0x74>
200659c: 82 10 20 02 mov 2, %g1
20065a0: 80 a2 20 03 cmp %o0, 3
20065a4: 02 bf ff d5 be 20064f8 <rtems_termios_baud_to_index+0x74> <== ALWAYS TAKEN
20065a8: 82 10 20 03 mov 3, %g1
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;
20065ac: 10 bf ff d3 b 20064f8 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
20065b0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
20065b4: 02 bf ff d1 be 20064f8 <rtems_termios_baud_to_index+0x74>
20065b8: 82 10 20 0f mov 0xf, %g1
20065bc: 84 10 a0 01 or %g2, 1, %g2
20065c0: 80 a2 00 02 cmp %o0, %g2
20065c4: 12 bf ff cc bne 20064f4 <rtems_termios_baud_to_index+0x70><== NEVER TAKEN
20065c8: 82 10 20 10 mov 0x10, %g1
20065cc: 30 bf ff cb b,a 20064f8 <rtems_termios_baud_to_index+0x74>
02005808 <rtems_termios_close>:
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
2005808: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
200580c: 39 00 80 78 sethi %hi(0x201e000), %i4
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2005810: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
2005814: d0 07 21 d0 ld [ %i4 + 0x1d0 ], %o0
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2005818: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
200581c: 92 10 20 00 clr %o1
2005820: 40 00 08 d0 call 2007b60 <rtems_semaphore_obtain>
2005824: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005828: 80 a2 20 00 cmp %o0, 0
200582c: 12 80 00 6e bne 20059e4 <rtems_termios_close+0x1dc> <== NEVER TAKEN
2005830: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
2005834: c2 07 60 08 ld [ %i5 + 8 ], %g1
2005838: 82 00 7f ff add %g1, -1, %g1
200583c: 80 a0 60 00 cmp %g1, 0
2005840: 12 80 00 39 bne 2005924 <rtems_termios_close+0x11c>
2005844: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
2005848: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
200584c: 03 00 80 77 sethi %hi(0x201dc00), %g1
2005850: 85 28 a0 05 sll %g2, 5, %g2
2005854: 82 10 63 14 or %g1, 0x314, %g1
2005858: 82 00 40 02 add %g1, %g2, %g1
200585c: c2 00 60 04 ld [ %g1 + 4 ], %g1
2005860: 80 a0 60 00 cmp %g1, 0
2005864: 22 80 00 42 be,a 200596c <rtems_termios_close+0x164>
2005868: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
200586c: 9f c0 40 00 call %g1
2005870: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005874: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005878: 80 a0 60 02 cmp %g1, 2
200587c: 22 80 00 4f be,a 20059b8 <rtems_termios_close+0x1b0> <== NEVER TAKEN
2005880: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
2005884: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
2005888: 80 a0 60 00 cmp %g1, 0
200588c: 22 80 00 07 be,a 20058a8 <rtems_termios_close+0xa0> <== ALWAYS TAKEN
2005890: c2 07 40 00 ld [ %i5 ], %g1
(*tty->device.lastClose)(tty->major, tty->minor, arg);
2005894: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
2005898: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
200589c: 9f c0 40 00 call %g1 <== NOT EXECUTED
20058a0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
20058a4: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
20058a8: 80 a0 60 00 cmp %g1, 0
20058ac: 02 80 00 29 be 2005950 <rtems_termios_close+0x148>
20058b0: c4 07 60 04 ld [ %i5 + 4 ], %g2
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
20058b4: c4 20 60 04 st %g2, [ %g1 + 4 ]
20058b8: c4 07 60 04 ld [ %i5 + 4 ], %g2
}
if (tty->back == NULL) {
20058bc: 80 a0 a0 00 cmp %g2, 0
20058c0: 22 80 00 21 be,a 2005944 <rtems_termios_close+0x13c> <== ALWAYS TAKEN
20058c4: 05 00 80 78 sethi %hi(0x201e000), %g2
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
20058c8: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
20058cc: 40 00 08 6e call 2007a84 <rtems_semaphore_delete>
20058d0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
20058d4: 40 00 08 6c call 2007a84 <rtems_semaphore_delete>
20058d8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
20058dc: 40 00 08 6a call 2007a84 <rtems_semaphore_delete>
20058e0: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
20058e4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
20058e8: 80 a0 60 00 cmp %g1, 0
20058ec: 02 80 00 13 be 2005938 <rtems_termios_close+0x130>
20058f0: 01 00 00 00 nop
20058f4: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20058f8: 80 a0 60 02 cmp %g1, 2
20058fc: 02 80 00 0f be 2005938 <rtems_termios_close+0x130>
2005900: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
2005904: 7f ff f7 5b call 2003670 <free>
2005908: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
200590c: 7f ff f7 59 call 2003670 <free>
2005910: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
2005914: 7f ff f7 57 call 2003670 <free>
2005918: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
200591c: 7f ff f7 55 call 2003670 <free>
2005920: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2005924: d0 07 21 d0 ld [ %i4 + 0x1d0 ], %o0
2005928: 40 00 08 dd call 2007c9c <rtems_semaphore_release>
200592c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
2005930: 81 c7 e0 08 ret
2005934: 81 e8 00 00 restore
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
2005938: 40 00 08 53 call 2007a84 <rtems_semaphore_delete>
200593c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
2005940: 30 bf ff f1 b,a 2005904 <rtems_termios_close+0xfc>
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
2005944: c0 20 60 04 clr [ %g1 + 4 ]
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
2005948: 10 bf ff e1 b 20058cc <rtems_termios_close+0xc4>
200594c: c2 20 a1 d8 st %g1, [ %g2 + 0x1d8 ]
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
2005950: 03 00 80 78 sethi %hi(0x201e000), %g1
if ( rtems_termios_ttyTail != NULL ) {
2005954: 80 a0 a0 00 cmp %g2, 0
2005958: 02 80 00 25 be 20059ec <rtems_termios_close+0x1e4> <== ALWAYS TAKEN
200595c: c4 20 61 d4 st %g2, [ %g1 + 0x1d4 ]
rtems_termios_ttyTail->forw = NULL;
2005960: c0 20 80 00 clr [ %g2 ] <== NOT EXECUTED
2005964: 10 bf ff d9 b 20058c8 <rtems_termios_close+0xc0> <== NOT EXECUTED
2005968: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200596c: 92 10 20 00 clr %o1
2005970: 40 00 08 7c call 2007b60 <rtems_semaphore_obtain>
2005974: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
2005978: 80 a2 20 00 cmp %o0, 0
200597c: 12 80 00 1a bne 20059e4 <rtems_termios_close+0x1dc> <== NEVER TAKEN
2005980: 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) {
2005984: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005988: 80 a0 60 00 cmp %g1, 0
200598c: 02 80 00 04 be 200599c <rtems_termios_close+0x194>
2005990: 01 00 00 00 nop
2005994: 7f ff fe 72 call 200535c <drainOutput.part.0>
2005998: 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);
200599c: 40 00 08 c0 call 2007c9c <rtems_semaphore_release>
20059a0: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
20059a4: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20059a8: 80 a0 60 02 cmp %g1, 2
20059ac: 32 bf ff b7 bne,a 2005888 <rtems_termios_close+0x80>
20059b0: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
20059b4: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
20059b8: 40 00 07 31 call 200767c <rtems_event_send>
20059bc: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
20059c0: 80 a2 20 00 cmp %o0, 0
20059c4: 12 80 00 08 bne 20059e4 <rtems_termios_close+0x1dc> <== NEVER TAKEN
20059c8: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
20059cc: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
20059d0: 40 00 07 2b call 200767c <rtems_event_send>
20059d4: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
20059d8: 80 a2 20 00 cmp %o0, 0
20059dc: 22 bf ff ab be,a 2005888 <rtems_termios_close+0x80> <== ALWAYS TAKEN
20059e0: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
20059e4: 40 00 0a 44 call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
20059e8: 01 00 00 00 nop <== NOT EXECUTED
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
20059ec: 03 00 80 78 sethi %hi(0x201e000), %g1
20059f0: 10 bf ff b7 b 20058cc <rtems_termios_close+0xc4>
20059f4: c0 20 61 d8 clr [ %g1 + 0x1d8 ] ! 201e1d8 <rtems_termios_ttyHead>
02006ef0 <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)
{
2006ef0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2006ef4: c4 06 20 90 ld [ %i0 + 0x90 ], %g2
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2006ef8: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2006efc: b2 00 80 19 add %g2, %i1, %i1
2006f00: f2 26 20 90 st %i1, [ %i0 + 0x90 ]
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2006f04: 80 a0 60 02 cmp %g1, 2
2006f08: 02 80 00 10 be 2006f48 <rtems_termios_dequeue_characters+0x58>
2006f0c: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
2006f10: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
2006f14: 80 a0 60 05 cmp %g1, 5
2006f18: 02 80 00 04 be 2006f28 <rtems_termios_dequeue_characters+0x38>
2006f1c: 03 00 80 77 sethi %hi(0x201dc00), %g1
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
2006f20: 7f ff f8 73 call 20050ec <rtems_termios_refill_transmitter>
2006f24: 81 e8 00 00 restore
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2006f28: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1
2006f2c: 80 a0 60 00 cmp %g1, 0
2006f30: 02 80 00 04 be 2006f40 <rtems_termios_dequeue_characters+0x50><== NEVER TAKEN
2006f34: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
2006f38: 9f c0 40 00 call %g1
2006f3c: 01 00 00 00 nop
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
2006f40: 81 c7 e0 08 ret
2006f44: 91 e8 20 00 restore %g0, 0, %o0
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
2006f48: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
2006f4c: 40 00 01 cc call 200767c <rtems_event_send>
2006f50: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
2006f54: 80 a2 20 00 cmp %o0, 0
2006f58: 02 bf ff fa be 2006f40 <rtems_termios_dequeue_characters+0x50><== ALWAYS TAKEN
2006f5c: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
2006f60: 40 00 04 e5 call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
02006b48 <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)
{
2006b48: 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) {
2006b4c: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
2006b50: 37 00 80 77 sethi %hi(0x201dc00), %i3
2006b54: 83 28 60 05 sll %g1, 5, %g1
2006b58: b6 16 e3 14 or %i3, 0x314, %i3
2006b5c: 82 06 c0 01 add %i3, %g1, %g1
2006b60: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2006b64: 80 a0 60 00 cmp %g1, 0
2006b68: 02 80 00 23 be 2006bf4 <rtems_termios_enqueue_raw_characters+0xac>
2006b6c: b8 10 00 18 mov %i0, %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)
2006b70: b0 06 bf ff add %i2, -1, %i0
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--) {
2006b74: 80 a6 a0 00 cmp %i2, 0
2006b78: 12 80 00 08 bne 2006b98 <rtems_termios_enqueue_raw_characters+0x50><== ALWAYS TAKEN
2006b7c: ba 10 20 00 clr %i5
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006b80: 10 80 00 0d b 2006bb4 <rtems_termios_enqueue_raw_characters+0x6c><== NOT EXECUTED
2006b84: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1 <== NOT EXECUTED
2006b88: ba 07 60 01 inc %i5
2006b8c: 83 28 60 05 sll %g1, 5, %g1
2006b90: 82 06 c0 01 add %i3, %g1, %g1
2006b94: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
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);
2006b98: d0 4e 40 1d ldsb [ %i1 + %i5 ], %o0
2006b9c: 9f c0 40 00 call %g1
2006ba0: 92 10 00 1c mov %i4, %o1
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
2006ba4: 80 a7 40 18 cmp %i5, %i0
2006ba8: 32 bf ff f8 bne,a 2006b88 <rtems_termios_enqueue_raw_characters+0x40>
2006bac: c2 07 20 cc ld [ %i4 + 0xcc ], %g1
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006bb0: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
2006bb4: 80 a0 60 00 cmp %g1, 0
2006bb8: 12 80 00 0d bne 2006bec <rtems_termios_enqueue_raw_characters+0xa4><== NEVER TAKEN
2006bbc: 01 00 00 00 nop
2006bc0: c2 07 20 dc ld [ %i4 + 0xdc ], %g1
2006bc4: 80 a0 60 00 cmp %g1, 0
2006bc8: 02 80 00 07 be 2006be4 <rtems_termios_enqueue_raw_characters+0x9c>
2006bcc: b0 10 20 00 clr %i0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2006bd0: d2 07 20 e0 ld [ %i4 + 0xe0 ], %o1
2006bd4: 9f c0 40 00 call %g1
2006bd8: 90 07 20 30 add %i4, 0x30, %o0
tty->tty_rcvwakeup = 1;
2006bdc: 82 10 20 01 mov 1, %g1
2006be0: c2 27 20 e4 st %g1, [ %i4 + 0xe4 ]
2006be4: 81 c7 e0 08 ret
2006be8: 81 e8 00 00 restore
}
return 0;
2006bec: 81 c7 e0 08 ret <== NOT EXECUTED
2006bf0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
* 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)
2006bf4: b4 06 40 1a add %i1, %i2, %i2
2006bf8: a0 10 20 00 clr %l0
2006bfc: 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);
2006c00: a2 07 20 30 add %i4, 0x30, %l1
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
2006c04: a4 07 20 4a add %i4, 0x4a, %l2
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2006c08: 80 a6 40 1a cmp %i1, %i2
2006c0c: 22 80 00 28 be,a 2006cac <rtems_termios_enqueue_raw_characters+0x164>
2006c10: c2 07 20 78 ld [ %i4 + 0x78 ], %g1
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
2006c14: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1
}
return 0;
}
while (len--) {
c = *buf++;
2006c18: fa 0e 40 00 ldub [ %i1 ], %i5
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
2006c1c: 80 88 62 00 btst 0x200, %g1
2006c20: 02 80 00 0b be 2006c4c <rtems_termios_enqueue_raw_characters+0x104>
2006c24: b2 06 60 01 inc %i1
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
2006c28: c4 0f 20 4a ldub [ %i4 + 0x4a ], %g2
2006c2c: 83 2f 60 18 sll %i5, 0x18, %g1
2006c30: 83 38 60 18 sra %g1, 0x18, %g1
2006c34: 80 a0 40 02 cmp %g1, %g2
2006c38: 02 80 00 5c be 2006da8 <rtems_termios_enqueue_raw_characters+0x260>
2006c3c: c4 0f 20 49 ldub [ %i4 + 0x49 ], %g2
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
2006c40: 80 a0 40 02 cmp %g1, %g2
2006c44: 02 80 00 61 be 2006dc8 <rtems_termios_enqueue_raw_characters+0x280><== NEVER TAKEN
2006c48: 01 00 00 00 nop
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
2006c4c: 80 8c 20 ff btst 0xff, %l0
2006c50: 02 80 00 1d be 2006cc4 <rtems_termios_enqueue_raw_characters+0x17c><== ALWAYS TAKEN
2006c54: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
2006c58: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1
2006c5c: 82 08 60 30 and %g1, 0x30, %g1
2006c60: 80 a0 60 20 cmp %g1, 0x20
2006c64: 12 bf ff ea bne 2006c0c <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
2006c68: 80 a6 40 1a cmp %i1, %i2
/* disable interrupts */
rtems_interrupt_disable(level);
2006c6c: 7f ff ee 68 call 200260c <sparc_disable_interrupts> <== NOT EXECUTED
2006c70: 01 00 00 00 nop <== NOT EXECUTED
2006c74: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2006c78: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2006c7c: c2 07 20 94 ld [ %i4 + 0x94 ], %g1 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
2006c80: 84 08 bf df and %g2, -33, %g2 <== NOT EXECUTED
2006c84: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2006c88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006c8c: 12 80 00 57 bne 2006de8 <rtems_termios_enqueue_raw_characters+0x2a0><== NOT EXECUTED
2006c90: 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);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2006c94: 7f ff ee 62 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
2006c98: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2006c9c: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
2006ca0: 12 bf ff dd bne 2006c14 <rtems_termios_enqueue_raw_characters+0xcc><== NOT EXECUTED
2006ca4: 01 00 00 00 nop <== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
2006ca8: c2 07 20 78 ld [ %i4 + 0x78 ], %g1 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006cac: d0 07 20 68 ld [ %i4 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
2006cb0: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006cb4: 40 00 03 fa call 2007c9c <rtems_semaphore_release>
2006cb8: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
return dropped;
2006cbc: 81 c7 e0 08 ret
2006cc0: 81 e8 00 00 restore
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
2006cc4: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
2006cc8: d2 07 20 64 ld [ %i4 + 0x64 ], %o1
2006ccc: 40 00 49 ec call 201947c <.urem>
2006cd0: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
2006cd4: 7f ff ee 4e call 200260c <sparc_disable_interrupts>
2006cd8: b6 10 00 08 mov %o0, %i3
2006cdc: a6 10 00 08 mov %o0, %l3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
2006ce0: c2 07 20 5c ld [ %i4 + 0x5c ], %g1
2006ce4: d0 07 20 64 ld [ %i4 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
2006ce8: d2 07 20 64 ld [ %i4 + 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)
2006cec: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
2006cf0: 40 00 49 e3 call 201947c <.urem>
2006cf4: 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)
2006cf8: c2 07 20 c0 ld [ %i4 + 0xc0 ], %g1
2006cfc: 80 a2 00 01 cmp %o0, %g1
2006d00: 08 80 00 13 bleu 2006d4c <rtems_termios_enqueue_raw_characters+0x204><== ALWAYS TAKEN
2006d04: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
2006d08: c2 07 20 b8 ld [ %i4 + 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) &&
2006d0c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2006d10: 12 80 00 0f bne 2006d4c <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
2006d14: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
2006d18: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
2006d1c: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
2006d20: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
2006d24: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
2006d28: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
2006d2c: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006d30: c2 07 20 b8 ld [ %i4 + 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))
2006d34: 02 80 00 35 be 2006e08 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
2006d38: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
2006d3c: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
2006d40: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
2006d44: 02 80 00 40 be 2006e44 <rtems_termios_enqueue_raw_characters+0x2fc><== NOT EXECUTED
2006d48: 01 00 00 00 nop <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2006d4c: 7f ff ee 34 call 200261c <sparc_enable_interrupts>
2006d50: 90 10 00 13 mov %l3, %o0
if (newTail == tty->rawInBuf.Head) {
2006d54: c2 07 20 5c ld [ %i4 + 0x5c ], %g1
2006d58: 80 a0 40 1b cmp %g1, %i3
2006d5c: 22 bf ff ab be,a 2006c08 <rtems_termios_enqueue_raw_characters+0xc0><== NEVER TAKEN
2006d60: b0 06 20 01 inc %i0 <== NOT EXECUTED
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
2006d64: c2 07 20 58 ld [ %i4 + 0x58 ], %g1
2006d68: fa 28 40 1b stb %i5, [ %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 )) {
2006d6c: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
2006d70: f6 27 20 60 st %i3, [ %i4 + 0x60 ]
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006d74: 80 a0 60 00 cmp %g1, 0
2006d78: 12 bf ff a5 bne 2006c0c <rtems_termios_enqueue_raw_characters+0xc4><== NEVER TAKEN
2006d7c: 80 a6 40 1a cmp %i1, %i2
2006d80: c2 07 20 dc ld [ %i4 + 0xdc ], %g1
2006d84: 80 a0 60 00 cmp %g1, 0
2006d88: 02 bf ff a1 be 2006c0c <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
2006d8c: 80 a6 40 1a cmp %i1, %i2
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2006d90: d2 07 20 e0 ld [ %i4 + 0xe0 ], %o1 <== NOT EXECUTED
2006d94: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006d98: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
2006d9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2006da0: 10 bf ff 9a b 2006c08 <rtems_termios_enqueue_raw_characters+0xc0><== NOT EXECUTED
2006da4: c2 27 20 e4 st %g1, [ %i4 + 0xe4 ] <== NOT EXECUTED
/* 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]) {
2006da8: 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;
2006dac: c2 07 20 b8 ld [ %i4 + 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]) {
2006db0: 22 80 00 0b be,a 2006ddc <rtems_termios_enqueue_raw_characters+0x294><== NEVER TAKEN
2006db4: 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;
2006db8: 82 10 60 10 or %g1, 0x10, %g1
* 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)
2006dbc: a0 10 20 01 mov 1, %l0
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
2006dc0: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ]
2006dc4: 30 bf ff a5 b,a 2006c58 <rtems_termios_enqueue_raw_characters+0x110>
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
2006dc8: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
* 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)
2006dcc: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
2006dd0: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
2006dd4: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
2006dd8: 30 bf ff a0 b,a 2006c58 <rtems_termios_enqueue_raw_characters+0x110><== NOT EXECUTED
* 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)
2006ddc: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
2006de0: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
2006de4: 30 bf ff 9d b,a 2006c58 <rtems_termios_enqueue_raw_characters+0x110><== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
2006de8: c4 07 20 84 ld [ %i4 + 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)(
2006dec: d2 07 20 7c ld [ %i4 + 0x7c ], %o1 <== NOT EXECUTED
2006df0: c2 07 20 a4 ld [ %i4 + 0xa4 ], %g1 <== NOT EXECUTED
2006df4: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
2006df8: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
2006dfc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006e00: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2006e04: 30 bf ff a4 b,a 2006c94 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006e08: 12 80 00 06 bne 2006e20 <rtems_termios_enqueue_raw_characters+0x2d8><== NOT EXECUTED
2006e0c: 01 00 00 00 nop <== NOT EXECUTED
2006e10: c2 07 20 94 ld [ %i4 + 0x94 ], %g1 <== NOT EXECUTED
2006e14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006e18: 12 bf ff cd bne 2006d4c <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
2006e1c: 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;
2006e20: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006e24: c2 07 20 a4 ld [ %i4 + 0xa4 ], %g1 <== NOT EXECUTED
2006e28: d0 07 20 10 ld [ %i4 + 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;
2006e2c: 84 10 a0 02 or %g2, 2, %g2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006e30: 92 10 00 12 mov %l2, %o1 <== 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;
2006e34: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006e38: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006e3c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2006e40: 30 bf ff c3 b,a 2006d4c <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
2006e44: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
2006e48: c2 07 20 ac ld [ %i4 + 0xac ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
2006e4c: 84 10 a0 04 or %g2, 4, %g2 <== NOT EXECUTED
2006e50: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
2006e54: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006e58: 02 bf ff bd be 2006d4c <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
2006e5c: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
2006e60: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006e64: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
2006e68: 30 bf ff b9 b,a 2006d4c <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
02005a18 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
2005a18: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2005a1c: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
2005a20: 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;
2005a24: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
2005a28: 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);
2005a2c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
2005a30: 92 10 20 00 clr %o1
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;
2005a34: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2005a38: 40 00 08 4a call 2007b60 <rtems_semaphore_obtain>
2005a3c: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
2005a40: b0 92 20 00 orcc %o0, 0, %i0
2005a44: 12 80 00 23 bne 2005ad0 <rtems_termios_ioctl+0xb8> <== NEVER TAKEN
2005a48: 01 00 00 00 nop
return sc;
}
switch (args->command) {
2005a4c: c2 07 20 04 ld [ %i4 + 4 ], %g1
2005a50: 80 a0 60 05 cmp %g1, 5
2005a54: 22 80 00 1a be,a 2005abc <rtems_termios_ioctl+0xa4>
2005a58: c2 06 c0 00 ld [ %i3 ], %g1
2005a5c: 18 80 00 1f bgu 2005ad8 <rtems_termios_ioctl+0xc0>
2005a60: 05 10 01 19 sethi %hi(0x40046400), %g2
2005a64: 80 a0 60 02 cmp %g1, 2
2005a68: 22 80 00 2f be,a 2005b24 <rtems_termios_ioctl+0x10c>
2005a6c: d2 07 20 08 ld [ %i4 + 8 ], %o1
2005a70: 18 80 00 bf bgu 2005d6c <rtems_termios_ioctl+0x354>
2005a74: 80 a0 60 03 cmp %g1, 3
2005a78: 80 a0 60 01 cmp %g1, 1
2005a7c: 22 80 00 d0 be,a 2005dbc <rtems_termios_ioctl+0x3a4> <== ALWAYS TAKEN
2005a80: d0 07 20 08 ld [ %i4 + 8 ], %o0
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
2005a84: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
2005a88: 03 00 80 77 sethi %hi(0x201dc00), %g1
2005a8c: 85 28 a0 05 sll %g2, 5, %g2
2005a90: 82 10 63 14 or %g1, 0x314, %g1
2005a94: 82 00 40 02 add %g1, %g2, %g1
2005a98: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
2005a9c: 80 a0 60 00 cmp %g1, 0
2005aa0: 02 80 00 0a be 2005ac8 <rtems_termios_ioctl+0xb0>
2005aa4: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
2005aa8: 90 10 00 1d mov %i5, %o0
2005aac: 9f c0 40 00 call %g1
2005ab0: 92 10 00 1c mov %i4, %o1
2005ab4: 10 80 00 05 b 2005ac8 <rtems_termios_ioctl+0xb0>
2005ab8: b0 10 00 08 mov %o0, %i0
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
2005abc: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
2005ac0: c2 06 e0 04 ld [ %i3 + 4 ], %g1
2005ac4: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
2005ac8: 40 00 08 75 call 2007c9c <rtems_semaphore_release>
2005acc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
2005ad0: 81 c7 e0 08 ret
2005ad4: 81 e8 00 00 restore
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
2005ad8: 84 10 a2 7f or %g2, 0x27f, %g2
2005adc: 80 a0 40 02 cmp %g1, %g2
2005ae0: 02 80 00 77 be 2005cbc <rtems_termios_ioctl+0x2a4> <== NEVER TAKEN
2005ae4: 01 00 00 00 nop
2005ae8: 38 80 00 81 bgu,a 2005cec <rtems_termios_ioctl+0x2d4>
2005aec: 05 10 01 1d sethi %hi(0x40047400), %g2
2005af0: 80 a0 60 06 cmp %g1, 6
2005af4: 32 bf ff e5 bne,a 2005a88 <rtems_termios_ioctl+0x70>
2005af8: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
2005afc: c2 07 20 08 ld [ %i4 + 8 ], %g1
2005b00: 80 a0 60 01 cmp %g1, 1
2005b04: 02 80 00 c3 be 2005e10 <rtems_termios_ioctl+0x3f8>
2005b08: 80 a0 60 02 cmp %g1, 2
2005b0c: 02 80 00 d1 be 2005e50 <rtems_termios_ioctl+0x438>
2005b10: 80 a0 60 00 cmp %g1, 0
2005b14: 02 80 00 d6 be 2005e6c <rtems_termios_ioctl+0x454>
2005b18: 01 00 00 00 nop
case TCIOFLUSH:
flushOutput (tty);
flushInput (tty);
break;
default:
sc = RTEMS_INVALID_NAME;
2005b1c: 10 bf ff eb b 2005ac8 <rtems_termios_ioctl+0xb0>
2005b20: b0 10 20 03 mov 3, %i0 ! 3 <PROM_START+0x3>
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
2005b24: 94 10 20 24 mov 0x24, %o2
2005b28: b8 07 60 30 add %i5, 0x30, %i4
2005b2c: 40 00 2c 7c call 2010d1c <memcpy>
2005b30: 90 10 00 1c mov %i4, %o0
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
2005b34: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b38: 80 88 62 00 btst 0x200, %g1
2005b3c: 02 80 00 19 be 2005ba0 <rtems_termios_ioctl+0x188>
2005b40: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
2005b44: 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) &&
2005b48: 80 88 64 00 btst 0x400, %g1
2005b4c: 12 80 00 15 bne 2005ba0 <rtems_termios_ioctl+0x188>
2005b50: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
2005b54: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b58: 82 08 7d ef and %g1, -529, %g1
2005b5c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
2005b60: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b64: 80 88 60 20 btst 0x20, %g1
2005b68: 02 80 00 0e be 2005ba0 <rtems_termios_ioctl+0x188> <== ALWAYS TAKEN
2005b6c: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
2005b70: 7f ff f2 a7 call 200260c <sparc_disable_interrupts> <== NOT EXECUTED
2005b74: 01 00 00 00 nop <== NOT EXECUTED
2005b78: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2005b7c: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2005b80: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
2005b84: 84 08 bf df and %g2, -33, %g2 <== NOT EXECUTED
2005b88: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2005b8c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005b90: 12 80 00 c4 bne 2005ea0 <rtems_termios_ioctl+0x488> <== NOT EXECUTED
2005b94: 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);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2005b98: 7f ff f2 a1 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
2005b9c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
2005ba0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005ba4: 80 88 64 00 btst 0x400, %g1
2005ba8: 02 80 00 0d be 2005bdc <rtems_termios_ioctl+0x1c4>
2005bac: 01 00 00 00 nop
2005bb0: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
2005bb4: 03 00 00 04 sethi %hi(0x1000), %g1
2005bb8: 80 88 80 01 btst %g2, %g1
2005bbc: 12 80 00 08 bne 2005bdc <rtems_termios_ioctl+0x1c4> <== NEVER TAKEN
2005bc0: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
2005bc4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005bc8: 82 08 7b ff and %g1, -1025, %g1
2005bcc: 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);
2005bd0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005bd4: 82 08 7f fd and %g1, -3, %g1
2005bd8: 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)) {
2005bdc: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005be0: 80 88 61 00 btst 0x100, %g1
2005be4: 02 80 00 16 be 2005c3c <rtems_termios_ioctl+0x224> <== ALWAYS TAKEN
2005be8: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
2005bec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005bf0: 06 80 00 93 bl 2005e3c <rtems_termios_ioctl+0x424> <== NOT EXECUTED
2005bf4: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
2005bf8: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
2005bfc: 84 08 be ff and %g2, -257, %g2 <== NOT EXECUTED
2005c00: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
2005c04: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
2005c08: 80 88 a0 04 btst 4, %g2 <== NOT EXECUTED
2005c0c: 02 80 00 09 be 2005c30 <rtems_termios_ioctl+0x218> <== NOT EXECUTED
2005c10: 01 00 00 00 nop <== NOT EXECUTED
2005c14: c4 07 60 b0 ld [ %i5 + 0xb0 ], %g2 <== NOT EXECUTED
2005c18: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2005c1c: 02 80 00 05 be 2005c30 <rtems_termios_ioctl+0x218> <== NOT EXECUTED
2005c20: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
2005c24: 9f c0 80 00 call %g2 <== NOT EXECUTED
2005c28: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2005c2c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
2005c30: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
2005c34: 84 08 bf fb and %g2, -5, %g2 <== NOT EXECUTED
2005c38: c4 27 60 b8 st %g2, [ %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) {
2005c3c: 80 a0 60 00 cmp %g1, 0
2005c40: 06 80 00 7f bl 2005e3c <rtems_termios_ioctl+0x424> <== NEVER TAKEN
2005c44: 01 00 00 00 nop
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
2005c48: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2005c4c: 05 00 00 04 sethi %hi(0x1000), %g2
2005c50: 80 88 40 02 btst %g1, %g2
2005c54: 02 80 00 06 be 2005c6c <rtems_termios_ioctl+0x254>
2005c58: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
2005c5c: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
2005c60: 84 10 a4 00 or %g2, 0x400, %g2
2005c64: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
2005c68: 80 88 64 00 btst 0x400, %g1
2005c6c: 22 80 00 06 be,a 2005c84 <rtems_termios_ioctl+0x26c>
2005c70: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
2005c74: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005c78: 82 10 62 00 or %g1, 0x200, %g1
2005c7c: 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) {
2005c80: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2005c84: 80 88 60 02 btst 2, %g1
2005c88: 02 80 00 51 be 2005dcc <rtems_termios_ioctl+0x3b4>
2005c8c: 01 00 00 00 nop
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005c90: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
2005c94: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
2005c98: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
2005c9c: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
2005ca0: 80 a0 60 00 cmp %g1, 0
2005ca4: 02 bf ff 89 be 2005ac8 <rtems_termios_ioctl+0xb0>
2005ca8: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
2005cac: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2005cb0: 9f c0 40 00 call %g1
2005cb4: 92 10 00 1c mov %i4, %o1
2005cb8: 30 bf ff 84 b,a 2005ac8 <rtems_termios_ioctl+0xb0>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
2005cbc: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
2005cc0: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
2005cc4: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
2005cc8: 0c 80 00 5a bneg 2005e30 <rtems_termios_ioctl+0x418> <== NOT EXECUTED
2005ccc: 01 00 00 00 nop <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
2005cd0: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
2005cd4: c4 07 60 24 ld [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
2005cd8: c6 07 20 08 ld [ %i4 + 8 ], %g3 <== NOT EXECUTED
2005cdc: 84 21 00 02 sub %g4, %g2, %g2 <== NOT EXECUTED
2005ce0: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
}
break;
2005ce4: 10 bf ff 79 b 2005ac8 <rtems_termios_ioctl+0xb0> <== NOT EXECUTED
2005ce8: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
2005cec: 84 10 a0 1a or %g2, 0x1a, %g2
2005cf0: 80 a0 40 02 cmp %g1, %g2
2005cf4: 02 80 00 2e be 2005dac <rtems_termios_ioctl+0x394>
2005cf8: 05 20 01 1d sethi %hi(0x80047400), %g2
2005cfc: 84 10 a0 1b or %g2, 0x1b, %g2 ! 8004741b <RAM_END+0x7dc4741b>
2005d00: 80 a0 40 02 cmp %g1, %g2
2005d04: 32 bf ff 61 bne,a 2005a88 <rtems_termios_ioctl+0x70> <== NEVER TAKEN
2005d08: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
2005d0c: c2 07 60 cc ld [ %i5 + 0xcc ], %g1
2005d10: 37 00 80 77 sethi %hi(0x201dc00), %i3
2005d14: 83 28 60 05 sll %g1, 5, %g1
2005d18: b6 16 e3 14 or %i3, 0x314, %i3
2005d1c: 82 06 c0 01 add %i3, %g1, %g1
2005d20: c2 00 60 04 ld [ %g1 + 4 ], %g1
2005d24: 80 a0 60 00 cmp %g1, 0
2005d28: 22 80 00 06 be,a 2005d40 <rtems_termios_ioctl+0x328>
2005d2c: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
2005d30: 9f c0 40 00 call %g1
2005d34: 90 10 00 1d mov %i5, %o0
2005d38: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
2005d3c: c2 07 20 08 ld [ %i4 + 8 ], %g1
2005d40: c2 00 40 00 ld [ %g1 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
2005d44: c0 27 60 d0 clr [ %i5 + 0xd0 ]
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
2005d48: 85 28 60 05 sll %g1, 5, %g2
2005d4c: c4 06 c0 02 ld [ %i3 + %g2 ], %g2
2005d50: 80 a0 a0 00 cmp %g2, 0
2005d54: 02 bf ff 5d be 2005ac8 <rtems_termios_ioctl+0xb0>
2005d58: c2 27 60 cc st %g1, [ %i5 + 0xcc ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
2005d5c: 9f c0 80 00 call %g2
2005d60: 90 10 00 1d mov %i5, %o0
2005d64: 10 bf ff 59 b 2005ac8 <rtems_termios_ioctl+0xb0>
2005d68: b0 10 00 08 mov %o0, %i0
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
2005d6c: 02 80 00 09 be 2005d90 <rtems_termios_ioctl+0x378>
2005d70: 80 a0 60 04 cmp %g1, 4
2005d74: 32 bf ff 45 bne,a 2005a88 <rtems_termios_ioctl+0x70> <== NEVER TAKEN
2005d78: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
2005d7c: c2 06 c0 00 ld [ %i3 ], %g1
2005d80: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
2005d84: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
2005d88: 10 bf ff 50 b 2005ac8 <rtems_termios_ioctl+0xb0>
2005d8c: c2 27 60 e0 st %g1, [ %i5 + 0xe0 ]
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
2005d90: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005d94: 80 a0 60 00 cmp %g1, 0
2005d98: 02 bf ff 4c be 2005ac8 <rtems_termios_ioctl+0xb0> <== ALWAYS TAKEN
2005d9c: 01 00 00 00 nop
2005da0: 7f ff fd 6f call 200535c <drainOutput.part.0> <== NOT EXECUTED
2005da4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2005da8: 30 bf ff 48 b,a 2005ac8 <rtems_termios_ioctl+0xb0> <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
2005dac: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
2005db0: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
2005db4: 10 bf ff 45 b 2005ac8 <rtems_termios_ioctl+0xb0>
2005db8: c4 20 40 00 st %g2, [ %g1 ]
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
2005dbc: 92 07 60 30 add %i5, 0x30, %o1
2005dc0: 40 00 2b d7 call 2010d1c <memcpy>
2005dc4: 94 10 20 24 mov 0x24, %o2
break;
2005dc8: 30 bf ff 40 b,a 2005ac8 <rtems_termios_ioctl+0xb0>
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;
2005dcc: 40 00 05 9d call 2007440 <rtems_clock_get_ticks_per_second>
2005dd0: f6 0f 60 46 ldub [ %i5 + 0x46 ], %i3
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] *
2005dd4: 40 00 4c c4 call 20190e4 <.umul>
2005dd8: 92 10 00 1b mov %i3, %o1
rtems_clock_get_ticks_per_second() / 10;
2005ddc: 40 00 4c fc call 20191cc <.udiv>
2005de0: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
2005de4: 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] *
2005de8: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
2005dec: 80 a0 60 00 cmp %g1, 0
2005df0: 02 80 00 26 be 2005e88 <rtems_termios_ioctl+0x470>
2005df4: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005df8: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
2005dfc: 80 a0 60 00 cmp %g1, 0
2005e00: 12 bf ff a6 bne 2005c98 <rtems_termios_ioctl+0x280>
2005e04: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
2005e08: 10 bf ff a5 b 2005c9c <rtems_termios_ioctl+0x284>
2005e0c: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
2005e10: 7f ff f1 ff call 200260c <sparc_disable_interrupts>
2005e14: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
2005e18: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
2005e1c: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
2005e20: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
2005e24: 7f ff f1 fe call 200261c <sparc_enable_interrupts>
2005e28: 01 00 00 00 nop
2005e2c: 30 bf ff 27 b,a 2005ac8 <rtems_termios_ioctl+0xb0>
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
2005e30: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
2005e34: 10 bf ff a7 b 2005cd0 <rtems_termios_ioctl+0x2b8> <== NOT EXECUTED
2005e38: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
2005e3c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005e40: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
2005e44: 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) {
2005e48: 10 bf ff 81 b 2005c4c <rtems_termios_ioctl+0x234> <== NOT EXECUTED
2005e4c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
2005e50: 7f ff f1 ef call 200260c <sparc_disable_interrupts>
2005e54: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
2005e58: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
2005e5c: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
2005e60: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
2005e64: 7f ff f1 ee call 200261c <sparc_enable_interrupts>
2005e68: 01 00 00 00 nop
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
2005e6c: 7f ff f1 e8 call 200260c <sparc_disable_interrupts>
2005e70: 01 00 00 00 nop
tty->rawInBuf.Tail = 0;
2005e74: c0 27 60 60 clr [ %i5 + 0x60 ]
tty->rawInBuf.Head = 0;
2005e78: c0 27 60 5c clr [ %i5 + 0x5c ]
rtems_interrupt_enable (level);
2005e7c: 7f ff f1 e8 call 200261c <sparc_enable_interrupts>
2005e80: 01 00 00 00 nop
2005e84: 30 bf ff 11 b,a 2005ac8 <rtems_termios_ioctl+0xb0>
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
2005e88: 80 a0 60 00 cmp %g1, 0
2005e8c: 32 bf ff 82 bne,a 2005c94 <rtems_termios_ioctl+0x27c> <== NEVER TAKEN
2005e90: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
2005e94: 82 10 20 01 mov 1, %g1
2005e98: 10 bf ff 81 b 2005c9c <rtems_termios_ioctl+0x284>
2005e9c: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
2005ea0: 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)(
2005ea4: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
2005ea8: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2005eac: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2005eb0: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
2005eb4: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005eb8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2005ebc: 30 bf ff 37 b,a 2005b98 <rtems_termios_ioctl+0x180> <== NOT EXECUTED
020053d8 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
20053d8: 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(
20053dc: 23 00 80 78 sethi %hi(0x201e000), %l1
20053e0: d0 04 61 d0 ld [ %l1 + 0x1d0 ], %o0 ! 201e1d0 <rtems_termios_ttyMutex>
20053e4: 92 10 20 00 clr %o1
20053e8: 94 10 20 00 clr %o2
20053ec: 40 00 09 dd call 2007b60 <rtems_semaphore_obtain>
20053f0: b8 10 00 18 mov %i0, %i4
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20053f4: 80 a2 20 00 cmp %o0, 0
20053f8: 12 80 00 28 bne 2005498 <rtems_termios_open+0xc0> <== NEVER TAKEN
20053fc: a0 10 00 08 mov %o0, %l0
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
2005400: 25 00 80 78 sethi %hi(0x201e000), %l2
2005404: f0 04 a1 d8 ld [ %l2 + 0x1d8 ], %i0 ! 201e1d8 <rtems_termios_ttyHead>
2005408: 80 a6 20 00 cmp %i0, 0
200540c: 02 80 00 25 be 20054a0 <rtems_termios_open+0xc8>
2005410: ba 10 00 18 mov %i0, %i5
if ((tty->major == major) && (tty->minor == minor))
2005414: 10 80 00 06 b 200542c <rtems_termios_open+0x54>
2005418: c2 07 60 0c ld [ %i5 + 0xc ], %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) {
200541c: 80 a7 60 00 cmp %i5, 0
2005420: 02 80 00 21 be 20054a4 <rtems_termios_open+0xcc> <== ALWAYS TAKEN
2005424: 90 10 20 01 mov 1, %o0
if ((tty->major == major) && (tty->minor == minor))
2005428: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
200542c: 80 a0 40 1c cmp %g1, %i4
2005430: 32 bf ff fb bne,a 200541c <rtems_termios_open+0x44>
2005434: fa 07 40 00 ld [ %i5 ], %i5
2005438: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200543c: 80 a0 40 19 cmp %g1, %i1
2005440: 32 bf ff f7 bne,a 200541c <rtems_termios_open+0x44> <== NEVER TAKEN
2005444: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
2005448: c4 06 80 00 ld [ %i2 ], %g2
if (!tty->refcount++) {
200544c: c2 07 60 08 ld [ %i5 + 8 ], %g1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
2005450: fa 20 a0 30 st %i5, [ %g2 + 0x30 ]
if (!tty->refcount++) {
2005454: 84 00 60 01 add %g1, 1, %g2
2005458: 80 a0 60 00 cmp %g1, 0
200545c: 12 80 00 0d bne 2005490 <rtems_termios_open+0xb8>
2005460: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (tty->device.firstOpen)
2005464: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
2005468: 80 a0 60 00 cmp %g1, 0
200546c: 02 80 00 05 be 2005480 <rtems_termios_open+0xa8>
2005470: 90 10 00 1c mov %i4, %o0
(*tty->device.firstOpen)(major, minor, arg);
2005474: 92 10 00 19 mov %i1, %o1
2005478: 9f c0 40 00 call %g1
200547c: 94 10 00 1a mov %i2, %o2
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005480: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005484: 80 a0 60 02 cmp %g1, 2
2005488: 22 80 00 9e be,a 2005700 <rtems_termios_open+0x328>
200548c: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2005490: 40 00 0a 03 call 2007c9c <rtems_semaphore_release>
2005494: d0 04 61 d0 ld [ %l1 + 0x1d0 ], %o0
return RTEMS_SUCCESSFUL;
}
2005498: 81 c7 e0 08 ret
200549c: 91 e8 00 10 restore %g0, %l0, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
20054a0: 90 10 20 01 mov 1, %o0
20054a4: 7f ff f7 c4 call 20033b4 <calloc>
20054a8: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
20054ac: ba 92 20 00 orcc %o0, 0, %i5
20054b0: 02 80 00 a9 be 2005754 <rtems_termios_open+0x37c>
20054b4: 03 00 80 76 sethi %hi(0x201d800), %g1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
20054b8: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 ! 201d828 <rtems_termios_raw_input_size>
20054bc: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
20054c0: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
20054c4: 7f ff f9 45 call 20039d8 <malloc>
20054c8: 01 00 00 00 nop
20054cc: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
20054d0: 80 a2 20 00 cmp %o0, 0
20054d4: 02 80 00 9e be 200574c <rtems_termios_open+0x374>
20054d8: a6 10 00 08 mov %o0, %l3
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
20054dc: 03 00 80 76 sethi %hi(0x201d800), %g1
20054e0: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 ! 201d82c <rtems_termios_raw_output_size>
20054e4: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
20054e8: d0 07 60 88 ld [ %i5 + 0x88 ], %o0
20054ec: 7f ff f9 3b call 20039d8 <malloc>
20054f0: 01 00 00 00 nop
20054f4: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
20054f8: 80 a2 20 00 cmp %o0, 0
20054fc: 02 80 00 92 be 2005744 <rtems_termios_open+0x36c>
2005500: a8 10 00 08 mov %o0, %l4
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
2005504: 03 00 80 76 sethi %hi(0x201d800), %g1
2005508: 7f ff f9 34 call 20039d8 <malloc>
200550c: d0 00 60 30 ld [ %g1 + 0x30 ], %o0 ! 201d830 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
2005510: 80 a2 20 00 cmp %o0, 0
2005514: 02 80 00 8a be 200573c <rtems_termios_open+0x364>
2005518: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
200551c: c0 27 60 d4 clr [ %i5 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
2005520: c0 27 60 d8 clr [ %i5 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
2005524: c0 27 60 dc clr [ %i5 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
2005528: c0 27 60 e0 clr [ %i5 + 0xe0 ]
tty->tty_rcvwakeup = 0;
200552c: c0 27 60 e4 clr [ %i5 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
2005530: f0 27 40 00 st %i0, [ %i5 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
2005534: 80 a6 20 00 cmp %i0, 0
2005538: 02 80 00 03 be 2005544 <rtems_termios_open+0x16c>
200553c: c0 27 60 04 clr [ %i5 + 4 ]
rtems_termios_ttyHead->back = tty;
2005540: fa 26 20 04 st %i5, [ %i0 + 4 ]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
2005544: 03 00 80 78 sethi %hi(0x201e000), %g1
2005548: c4 00 61 d4 ld [ %g1 + 0x1d4 ], %g2 ! 201e1d4 <rtems_termios_ttyTail>
200554c: 80 a0 a0 00 cmp %g2, 0
2005550: 02 80 00 ac be 2005800 <rtems_termios_open+0x428>
2005554: fa 24 a1 d8 st %i5, [ %l2 + 0x1d8 ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
2005558: 31 00 80 76 sethi %hi(0x201d800), %i0
200555c: d0 4e 20 34 ldsb [ %i0 + 0x34 ], %o0 ! 201d834 <c.6880>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
2005560: 03 15 14 9a sethi %hi(0x54526800), %g1
2005564: 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;
2005568: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
tty->major = major;
200556c: f8 27 60 0c st %i4, [ %i5 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
2005570: 92 10 20 01 mov 1, %o1
2005574: 94 10 20 54 mov 0x54, %o2
2005578: 90 12 00 01 or %o0, %g1, %o0
200557c: 96 10 20 00 clr %o3
2005580: 40 00 08 d0 call 20078c0 <rtems_semaphore_create>
2005584: 98 07 60 14 add %i5, 0x14, %o4
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
2005588: 80 a2 20 00 cmp %o0, 0
200558c: 12 80 00 84 bne 200579c <rtems_termios_open+0x3c4>
2005590: 03 15 14 9b sethi %hi(0x54526c00), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
2005594: d0 4e 20 34 ldsb [ %i0 + 0x34 ], %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 (
2005598: 82 10 63 00 or %g1, 0x300, %g1
200559c: 92 10 20 01 mov 1, %o1
20055a0: 94 10 20 54 mov 0x54, %o2
20055a4: 90 12 00 01 or %o0, %g1, %o0
20055a8: 96 10 20 00 clr %o3
20055ac: 40 00 08 c5 call 20078c0 <rtems_semaphore_create>
20055b0: 98 07 60 18 add %i5, 0x18, %o4
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
20055b4: 80 a2 20 00 cmp %o0, 0
20055b8: 12 80 00 79 bne 200579c <rtems_termios_open+0x3c4>
20055bc: 03 15 14 9e sethi %hi(0x54527800), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
20055c0: d0 4e 20 34 ldsb [ %i0 + 0x34 ], %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 (
20055c4: 92 10 20 00 clr %o1
20055c8: 90 12 00 01 or %o0, %g1, %o0
20055cc: 94 10 20 20 mov 0x20, %o2
20055d0: 96 10 20 00 clr %o3
20055d4: 40 00 08 bb call 20078c0 <rtems_semaphore_create>
20055d8: 98 07 60 8c add %i5, 0x8c, %o4
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
20055dc: 80 a2 20 00 cmp %o0, 0
20055e0: 12 80 00 6f bne 200579c <rtems_termios_open+0x3c4>
20055e4: 92 10 00 1b mov %i3, %o1
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
20055e8: c0 27 60 94 clr [ %i5 + 0x94 ]
/*
* Set callbacks
*/
tty->device = *callbacks;
20055ec: 90 07 60 98 add %i5, 0x98, %o0
20055f0: 40 00 2d cb call 2010d1c <memcpy>
20055f4: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
20055f8: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20055fc: 80 a0 60 02 cmp %g1, 2
2005600: 02 80 00 69 be 20057a4 <rtems_termios_open+0x3cc>
2005604: d0 4e 20 34 ldsb [ %i0 + 0x34 ], %o0
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
2005608: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
200560c: 80 a0 60 00 cmp %g1, 0
2005610: 02 80 00 58 be 2005770 <rtems_termios_open+0x398>
2005614: d0 4e 20 34 ldsb [ %i0 + 0x34 ], %o0
2005618: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
200561c: 80 a0 60 02 cmp %g1, 2
2005620: 02 80 00 55 be 2005774 <rtems_termios_open+0x39c>
2005624: 03 15 14 9c sethi %hi(0x54527000), %g1
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
2005628: c0 27 60 b8 clr [ %i5 + 0xb8 ]
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
200562c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
tty->highwater = tty->rawInBuf.Size * 3/4;
2005630: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
/*
* Bump name characer
*/
if (c++ == 'z')
2005634: c6 4e 20 34 ldsb [ %i0 + 0x34 ], %g3
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;
2005638: 89 28 60 01 sll %g1, 1, %g4
200563c: 82 01 00 01 add %g4, %g1, %g1
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
2005640: 09 00 00 06 sethi %hi(0x1800), %g4
2005644: 88 11 20 05 or %g4, 5, %g4 ! 1805 <PROM_START+0x1805>
2005648: c8 27 60 34 st %g4, [ %i5 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
200564c: 88 10 28 bd mov 0x8bd, %g4
2005650: c8 27 60 38 st %g4, [ %i5 + 0x38 ]
tty->termios.c_lflag =
2005654: 09 00 00 20 sethi %hi(0x8000), %g4
2005658: 88 11 22 3b or %g4, 0x23b, %g4 ! 823b <PROM_START+0x823b>
200565c: c8 27 60 3c st %g4, [ %i5 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
2005660: 88 10 20 03 mov 3, %g4
2005664: c8 2f 60 41 stb %g4, [ %i5 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
2005668: 88 10 20 1c mov 0x1c, %g4
200566c: c8 2f 60 42 stb %g4, [ %i5 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
2005670: 88 10 20 7f mov 0x7f, %g4
2005674: c8 2f 60 43 stb %g4, [ %i5 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
2005678: 88 10 20 15 mov 0x15, %g4
200567c: c8 2f 60 44 stb %g4, [ %i5 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
2005680: 88 10 20 04 mov 4, %g4
2005684: c8 2f 60 45 stb %g4, [ %i5 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
2005688: 88 10 20 11 mov 0x11, %g4
200568c: c8 2f 60 49 stb %g4, [ %i5 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
2005690: 88 10 20 13 mov 0x13, %g4
2005694: c8 2f 60 4a stb %g4, [ %i5 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
2005698: 88 10 20 1a mov 0x1a, %g4
200569c: c8 2f 60 4b stb %g4, [ %i5 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
20056a0: 88 10 20 12 mov 0x12, %g4
20056a4: c8 2f 60 4d stb %g4, [ %i5 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
20056a8: 88 10 20 0f mov 0xf, %g4
20056ac: c8 2f 60 4e stb %g4, [ %i5 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
20056b0: 88 10 20 17 mov 0x17, %g4
/* 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;
20056b4: 85 30 a0 01 srl %g2, 1, %g2
tty->highwater = tty->rawInBuf.Size * 3/4;
20056b8: 83 30 60 02 srl %g1, 2, %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
20056bc: 37 00 00 09 sethi %hi(0x2400), %i3
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
20056c0: c8 2f 60 4f stb %g4, [ %i5 + 0x4f ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
20056c4: b6 16 e1 02 or %i3, 0x102, %i3
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';
20056c8: 88 10 20 16 mov 0x16, %g4
/* 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;
20056cc: c4 27 60 bc st %g2, [ %i5 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
20056d0: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
20056d4: f6 27 60 30 st %i3, [ %i5 + 0x30 ]
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';
20056d8: c0 2f 60 4c clrb [ %i5 + 0x4c ]
tty->termios.c_cc[VEOL2] = '\000';
20056dc: c0 2f 60 51 clrb [ %i5 + 0x51 ]
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';
20056e0: c8 2f 60 50 stb %g4, [ %i5 + 0x50 ]
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
20056e4: 03 00 80 76 sethi %hi(0x201d800), %g1
20056e8: 80 a0 e0 7a cmp %g3, 0x7a
20056ec: 02 80 00 1e be 2005764 <rtems_termios_open+0x38c>
20056f0: c4 0e 20 34 ldub [ %i0 + 0x34 ], %g2
20056f4: 84 00 a0 01 inc %g2
20056f8: 10 bf ff 54 b 2005448 <rtems_termios_open+0x70>
20056fc: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
2005700: 94 10 00 1d mov %i5, %o2
2005704: 13 00 80 1b sethi %hi(0x2006c00), %o1
2005708: 40 00 0a 49 call 200802c <rtems_task_start>
200570c: 92 12 62 6c or %o1, 0x26c, %o1 ! 2006e6c <rtems_termios_rxdaemon>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
2005710: 80 a2 20 00 cmp %o0, 0
2005714: 12 80 00 22 bne 200579c <rtems_termios_open+0x3c4> <== NEVER TAKEN
2005718: 94 10 00 1d mov %i5, %o2
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
200571c: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
2005720: 13 00 80 14 sethi %hi(0x2005000), %o1
2005724: 40 00 0a 42 call 200802c <rtems_task_start>
2005728: 92 12 62 ec or %o1, 0x2ec, %o1 ! 20052ec <rtems_termios_txdaemon>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
200572c: 80 a2 20 00 cmp %o0, 0
2005730: 02 bf ff 58 be 2005490 <rtems_termios_open+0xb8> <== ALWAYS TAKEN
2005734: 01 00 00 00 nop
2005738: 30 80 00 19 b,a 200579c <rtems_termios_open+0x3c4> <== NOT EXECUTED
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
200573c: 7f ff f7 cd call 2003670 <free>
2005740: 90 10 00 14 mov %l4, %o0
free((void *)(tty->rawInBuf.theBuf));
2005744: 7f ff f7 cb call 2003670 <free>
2005748: 90 10 00 13 mov %l3, %o0
free(tty);
200574c: 7f ff f7 c9 call 2003670 <free>
2005750: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
2005754: d0 04 61 d0 ld [ %l1 + 0x1d0 ], %o0
2005758: 40 00 09 51 call 2007c9c <rtems_semaphore_release>
200575c: a0 10 20 1a mov 0x1a, %l0
return RTEMS_NO_MEMORY;
2005760: 30 bf ff 4e b,a 2005498 <rtems_termios_open+0xc0>
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
2005764: 84 10 20 61 mov 0x61, %g2
2005768: 10 bf ff 38 b 2005448 <rtems_termios_open+0x70>
200576c: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
2005770: 03 15 14 9c sethi %hi(0x54527000), %g1
2005774: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x52127200>
2005778: 92 10 20 00 clr %o1
200577c: 94 10 20 24 mov 0x24, %o2
2005780: 90 12 00 01 or %o0, %g1, %o0
2005784: 96 10 20 00 clr %o3
2005788: 40 00 08 4e call 20078c0 <rtems_semaphore_create>
200578c: 98 07 60 68 add %i5, 0x68, %o4
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
2005790: 80 a2 20 00 cmp %o0, 0
2005794: 02 bf ff a5 be 2005628 <rtems_termios_open+0x250> <== ALWAYS TAKEN
2005798: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
200579c: 40 00 0a d6 call 20082f4 <rtems_fatal_error_occurred>
20057a0: 01 00 00 00 nop
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
20057a4: 03 15 1e 15 sethi %hi(0x54785400), %g1
20057a8: 92 10 20 0a mov 0xa, %o1
20057ac: 90 12 00 01 or %o0, %g1, %o0
20057b0: 94 10 24 00 mov 0x400, %o2
20057b4: 96 10 25 00 mov 0x500, %o3
20057b8: 98 10 20 00 clr %o4
20057bc: 40 00 09 78 call 2007d9c <rtems_task_create>
20057c0: 9a 07 60 c8 add %i5, 0xc8, %o5
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
20057c4: 80 a2 20 00 cmp %o0, 0
20057c8: 12 bf ff f5 bne 200579c <rtems_termios_open+0x3c4> <== NEVER TAKEN
20057cc: 03 14 9e 15 sethi %hi(0x52785400), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
20057d0: d0 4e 20 34 ldsb [ %i0 + 0x34 ], %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 (
20057d4: 92 10 20 09 mov 9, %o1
20057d8: 90 12 00 01 or %o0, %g1, %o0
20057dc: 94 10 24 00 mov 0x400, %o2
20057e0: 96 10 25 00 mov 0x500, %o3
20057e4: 98 10 20 00 clr %o4
20057e8: 40 00 09 6d call 2007d9c <rtems_task_create>
20057ec: 9a 07 60 c4 add %i5, 0xc4, %o5
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
20057f0: 80 a2 20 00 cmp %o0, 0
20057f4: 22 bf ff 86 be,a 200560c <rtems_termios_open+0x234> <== ALWAYS TAKEN
20057f8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
20057fc: 30 bf ff e8 b,a 200579c <rtems_termios_open+0x3c4> <== NOT EXECUTED
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
2005800: 10 bf ff 56 b 2005558 <rtems_termios_open+0x180>
2005804: fa 20 61 d4 st %i5, [ %g1 + 0x1d4 ]
02005ec0 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
2005ec0: 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) {
2005ec4: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
2005ec8: 80 a0 60 00 cmp %g1, 0
2005ecc: 22 80 00 44 be,a 2005fdc <rtems_termios_puts+0x11c>
2005ed0: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
2005ed4: e0 06 a0 80 ld [ %i2 + 0x80 ], %l0
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
2005ed8: b6 10 20 02 mov 2, %i3
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
2005edc: 80 a6 60 00 cmp %i1, 0
2005ee0: 02 80 00 34 be 2005fb0 <rtems_termios_puts+0xf0> <== NEVER TAKEN
2005ee4: a2 10 20 01 mov 1, %l1
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
2005ee8: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
2005eec: 40 00 4d 64 call 201947c <.urem>
2005ef0: 90 04 20 01 add %l0, 1, %o0
rtems_interrupt_disable (level);
2005ef4: 7f ff f1 c6 call 200260c <sparc_disable_interrupts>
2005ef8: a0 10 00 08 mov %o0, %l0
2005efc: ba 10 00 08 mov %o0, %i5
while (newHead == tty->rawOutBuf.Tail) {
2005f00: f8 06 a0 84 ld [ %i2 + 0x84 ], %i4
2005f04: 80 a7 00 10 cmp %i4, %l0
2005f08: 32 80 00 14 bne,a 2005f58 <rtems_termios_puts+0x98>
2005f0c: c6 0e 00 00 ldub [ %i0 ], %g3
tty->rawOutBufState = rob_wait;
2005f10: f6 26 a0 94 st %i3, [ %i2 + 0x94 ]
rtems_interrupt_enable (level);
2005f14: 7f ff f1 c2 call 200261c <sparc_enable_interrupts>
2005f18: 90 10 00 1d mov %i5, %o0
sc = rtems_semaphore_obtain(
2005f1c: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
2005f20: 92 10 20 00 clr %o1
2005f24: 40 00 07 0f call 2007b60 <rtems_semaphore_obtain>
2005f28: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005f2c: 80 a2 20 00 cmp %o0, 0
2005f30: 12 80 00 31 bne 2005ff4 <rtems_termios_puts+0x134> <== NEVER TAKEN
2005f34: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
2005f38: 7f ff f1 b5 call 200260c <sparc_disable_interrupts>
2005f3c: 01 00 00 00 nop
2005f40: ba 10 00 08 mov %o0, %i5
* 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) {
2005f44: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
2005f48: 80 a0 40 1c cmp %g1, %i4
2005f4c: 22 bf ff f2 be,a 2005f14 <rtems_termios_puts+0x54> <== NEVER TAKEN
2005f50: f6 26 a0 94 st %i3, [ %i2 + 0x94 ] <== NOT EXECUTED
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++;
2005f54: c6 0e 00 00 ldub [ %i0 ], %g3
2005f58: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
2005f5c: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
2005f60: b0 06 20 01 inc %i0
2005f64: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
2005f68: 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;
2005f6c: e0 26 a0 80 st %l0, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
2005f70: 80 a0 60 00 cmp %g1, 0
2005f74: 12 80 00 0a bne 2005f9c <rtems_termios_puts+0xdc>
2005f78: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
2005f7c: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
2005f80: 80 88 60 10 btst 0x10, %g1
2005f84: 02 80 00 0d be 2005fb8 <rtems_termios_puts+0xf8> <== ALWAYS TAKEN
2005f88: 01 00 00 00 nop
(*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;
2005f8c: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
2005f90: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
2005f94: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
2005f98: e2 26 a0 94 st %l1, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
2005f9c: 7f ff f1 a0 call 200261c <sparc_enable_interrupts>
2005fa0: 90 10 00 1d mov %i5, %o0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
2005fa4: b2 86 7f ff addcc %i1, -1, %i1
2005fa8: 12 bf ff d0 bne 2005ee8 <rtems_termios_puts+0x28>
2005fac: 01 00 00 00 nop
2005fb0: 81 c7 e0 08 ret
2005fb4: 81 e8 00 00 restore
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
2005fb8: 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)(
2005fbc: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
2005fc0: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2005fc4: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005fc8: 92 02 40 02 add %o1, %g2, %o1
2005fcc: 9f c0 40 00 call %g1
2005fd0: 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;
2005fd4: 10 bf ff f2 b 2005f9c <rtems_termios_puts+0xdc>
2005fd8: e2 26 a0 94 st %l1, [ %i2 + 0x94 ]
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
2005fdc: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005fe0: 92 10 00 18 mov %i0, %o1
2005fe4: 9f c0 40 00 call %g1
2005fe8: 94 10 00 19 mov %i1, %o2
return;
2005fec: 81 c7 e0 08 ret
2005ff0: 81 e8 00 00 restore
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
2005ff4: 40 00 08 c0 call 20082f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
02006750 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
2006750: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2006754: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
2006758: 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;
200675c: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
uint32_t count = args->count;
char *buffer = args->buffer;
2006760: e4 06 20 10 ld [ %i0 + 0x10 ], %l2
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2006764: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
2006768: 92 10 20 00 clr %o1
200676c: 40 00 04 fd call 2007b60 <rtems_semaphore_obtain>
2006770: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
2006774: a0 92 20 00 orcc %o0, 0, %l0
2006778: 12 80 00 10 bne 20067b8 <rtems_termios_read+0x68> <== NEVER TAKEN
200677c: 03 00 80 77 sethi %hi(0x201dc00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
2006780: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
2006784: 85 28 a0 05 sll %g2, 5, %g2
2006788: 82 10 63 14 or %g1, 0x314, %g1
200678c: 82 00 40 02 add %g1, %g2, %g1
2006790: c2 00 60 08 ld [ %g1 + 8 ], %g1
2006794: 80 a0 60 00 cmp %g1, 0
2006798: 02 80 00 0a be 20067c0 <rtems_termios_read+0x70>
200679c: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
20067a0: 9f c0 40 00 call %g1
20067a4: 92 10 00 18 mov %i0, %o1
20067a8: a0 10 00 08 mov %o0, %l0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
20067ac: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
20067b0: 40 00 05 3b call 2007c9c <rtems_semaphore_release>
20067b4: c0 27 60 e4 clr [ %i5 + 0xe4 ]
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
20067b8: 81 c7 e0 08 ret
20067bc: 91 e8 00 10 restore %g0, %l0, %o0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
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: 22 80 00 21 be,a 2006850 <rtems_termios_read+0x100> <== ALWAYS TAKEN
20067d0: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
20067d4: 80 a6 e0 00 cmp %i3, 0
20067d8: 22 80 00 15 be,a 200682c <rtems_termios_read+0xdc> <== NEVER TAKEN
20067dc: b6 10 20 00 clr %i3 <== NOT EXECUTED
20067e0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20067e4: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
20067e8: 80 a0 40 02 cmp %g1, %g2
20067ec: 36 80 00 11 bge,a 2006830 <rtems_termios_read+0xe0>
20067f0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
20067f4: 10 80 00 06 b 200680c <rtems_termios_read+0xbc>
20067f8: a4 24 80 01 sub %l2, %g1, %l2
20067fc: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2006800: 80 a0 80 01 cmp %g2, %g1
2006804: 24 80 00 0b ble,a 2006830 <rtems_termios_read+0xe0>
2006808: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
*buffer++ = tty->cbuf[tty->cindex++];
200680c: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2006810: b6 86 ff ff addcc %i3, -1, %i3
*buffer++ = tty->cbuf[tty->cindex++];
2006814: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
2006818: c4 2c 80 01 stb %g2, [ %l2 + %g1 ]
200681c: 82 00 60 01 inc %g1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2006820: 12 bf ff f7 bne 20067fc <rtems_termios_read+0xac>
2006824: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
2006828: b6 10 20 00 clr %i3
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
200682c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
2006830: 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;
2006834: b6 20 40 1b sub %g1, %i3, %i3
2006838: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
tty->tty_rcvwakeup = 0;
200683c: c0 27 60 e4 clr [ %i5 + 0xe4 ]
rtems_semaphore_release (tty->isem);
2006840: 40 00 05 17 call 2007c9c <rtems_semaphore_release>
2006844: b0 10 00 10 mov %l0, %i0
return sc;
}
2006848: 81 c7 e0 08 ret
200684c: 81 e8 00 00 restore
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
2006850: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
2006854: c0 27 60 20 clr [ %i5 + 0x20 ]
2006858: c0 27 60 24 clr [ %i5 + 0x24 ]
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
200685c: 80 a0 60 00 cmp %g1, 0
2006860: 02 80 00 06 be 2006878 <rtems_termios_read+0x128>
2006864: c4 27 60 2c st %g2, [ %i5 + 0x2c ]
2006868: c4 07 60 b4 ld [ %i5 + 0xb4 ], %g2
200686c: 80 a0 a0 00 cmp %g2, 0
2006870: 22 80 00 6d be,a 2006a24 <rtems_termios_read+0x2d4>
2006874: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
2006878: f8 07 60 74 ld [ %i5 + 0x74 ], %i4
rtems_status_code sc;
int wait = 1;
200687c: b2 10 20 01 mov 1, %i1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
2006880: 23 00 80 76 sethi %hi(0x201d800), %l1
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
2006884: a6 07 60 49 add %i5, 0x49, %l3
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006888: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
200688c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2006890: 80 a0 80 01 cmp %g2, %g1
2006894: 02 80 00 42 be 200699c <rtems_termios_read+0x24c>
2006898: c4 04 60 30 ld [ %l1 + 0x30 ], %g2
200689c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
(tty->ccount < (CBUFSIZE-1))) {
20068a0: 84 00 bf ff add %g2, -1, %g2
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
20068a4: 80 a0 80 01 cmp %g2, %g1
20068a8: 08 80 00 3d bleu 200699c <rtems_termios_read+0x24c> <== NEVER TAKEN
20068ac: b4 14 60 30 or %l1, 0x30, %i2
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
20068b0: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
20068b4: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
20068b8: 40 00 4a f1 call 201947c <.urem>
20068bc: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
20068c0: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
20068c4: f8 08 40 08 ldub [ %g1 + %o0 ], %i4
tty->rawInBuf.Head = newHead;
20068c8: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
20068cc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
20068d0: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
20068d4: 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)
20068d8: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
20068dc: 40 00 4a e8 call 201947c <.urem>
20068e0: 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)
20068e4: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
20068e8: 80 a2 00 01 cmp %o0, %g1
20068ec: 3a 80 00 18 bcc,a 200694c <rtems_termios_read+0x1fc> <== NEVER TAKEN
20068f0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
20068f4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20068f8: 82 08 7f fe and %g1, -2, %g1
20068fc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
2006900: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006904: 82 08 62 02 and %g1, 0x202, %g1
2006908: 80 a0 62 02 cmp %g1, 0x202
200690c: 22 80 00 38 be,a 20069ec <rtems_termios_read+0x29c> <== NEVER TAKEN
2006910: c2 07 60 94 ld [ %i5 + 0x94 ], %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) {
2006914: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006918: 80 88 61 00 btst 0x100, %g1
200691c: 22 80 00 0c be,a 200694c <rtems_termios_read+0x1fc> <== ALWAYS TAKEN
2006920: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
2006924: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
2006928: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
200692c: 84 08 bf fb and %g2, -5, %g2 <== NOT EXECUTED
2006930: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
2006934: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006938: 22 80 00 05 be,a 200694c <rtems_termios_read+0x1fc> <== NOT EXECUTED
200693c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
2006940: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006944: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006948: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
200694c: 90 0f 20 ff and %i4, 0xff, %o0
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006950: 80 88 60 02 btst 2, %g1
2006954: 02 80 00 1d be 20069c8 <rtems_termios_read+0x278> <== NEVER TAKEN
2006958: 92 10 00 1d mov %i5, %o1
if (siproc (c, tty))
200695c: 7f ff ff 36 call 2006634 <siproc>
2006960: 01 00 00 00 nop
2006964: 80 a2 20 00 cmp %o0, 0
2006968: 32 80 00 02 bne,a 2006970 <rtems_termios_read+0x220>
200696c: b2 10 20 00 clr %i1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006970: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
2006974: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2006978: 80 a0 80 01 cmp %g2, %g1
200697c: 02 80 00 08 be 200699c <rtems_termios_read+0x24c>
2006980: f8 07 60 70 ld [ %i5 + 0x70 ], %i4
(tty->ccount < (CBUFSIZE-1))) {
2006984: c2 06 80 00 ld [ %i2 ], %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006988: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
200698c: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006990: 80 a0 80 01 cmp %g2, %g1
2006994: 0a bf ff c7 bcs 20068b0 <rtems_termios_read+0x160> <== ALWAYS TAKEN
2006998: 01 00 00 00 nop
}
/*
* Wait for characters
*/
if ( wait ) {
200699c: 80 a6 60 00 cmp %i1, 0
20069a0: 02 bf ff 8e be 20067d8 <rtems_termios_read+0x88>
20069a4: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
20069a8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
20069ac: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
20069b0: 40 00 04 6c call 2007b60 <rtems_semaphore_obtain>
20069b4: 94 10 00 1c mov %i4, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
20069b8: 80 a2 20 00 cmp %o0, 0
20069bc: 02 bf ff b3 be 2006888 <rtems_termios_read+0x138> <== ALWAYS TAKEN
20069c0: 80 a6 e0 00 cmp %i3, 0
20069c4: 30 bf ff 85 b,a 20067d8 <rtems_termios_read+0x88> <== NOT EXECUTED
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
20069c8: 7f ff ff 1b call 2006634 <siproc> <== NOT EXECUTED
20069cc: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
20069d0: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
20069d4: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
20069d8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20069dc: 06 bf ff e5 bl 2006970 <rtems_termios_read+0x220> <== NOT EXECUTED
20069e0: 01 00 00 00 nop <== NOT EXECUTED
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
20069e4: 10 bf ff e3 b 2006970 <rtems_termios_read+0x220> <== NOT EXECUTED
20069e8: b2 10 20 00 clr %i1 ! 0 <PROM_START> <== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
20069ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20069f0: 22 80 00 07 be,a 2006a0c <rtems_termios_read+0x2bc> <== NOT EXECUTED
20069f4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
20069f8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
20069fc: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006a00: 02 bf ff c5 be 2006914 <rtems_termios_read+0x1c4> <== NOT EXECUTED
2006a04: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
2006a08: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2006a0c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2006a10: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2006a14: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006a18: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006a1c: 10 bf ff cc b 200694c <rtems_termios_read+0x1fc> <== NOT EXECUTED
2006a20: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
2006a24: 80 88 a0 02 btst 2, %g2
2006a28: 02 80 00 0e be 2006a60 <rtems_termios_read+0x310>
2006a2c: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006a30: 9f c0 40 00 call %g1
2006a34: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
2006a38: 80 a2 20 00 cmp %o0, 0
2006a3c: 06 80 00 3a bl 2006b24 <rtems_termios_read+0x3d4>
2006a40: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
2006a44: 7f ff fe fc call 2006634 <siproc>
2006a48: 92 10 00 1d mov %i5, %o1
2006a4c: 80 a2 20 00 cmp %o0, 0
2006a50: 12 bf ff 62 bne 20067d8 <rtems_termios_read+0x88>
2006a54: 80 a6 e0 00 cmp %i3, 0
2006a58: 10 bf ff f6 b 2006a30 <rtems_termios_read+0x2e0>
2006a5c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
2006a60: 40 00 02 80 call 2007460 <rtems_clock_get_ticks_since_boot>
2006a64: 01 00 00 00 nop
2006a68: b8 10 00 08 mov %o0, %i4
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006a6c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2006a70: 9f c0 40 00 call %g1
2006a74: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
2006a78: 80 a2 20 00 cmp %o0, 0
2006a7c: 06 80 00 10 bl 2006abc <rtems_termios_read+0x36c>
2006a80: 90 0a 20 ff and %o0, 0xff, %o0
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
2006a84: 7f ff fe ec call 2006634 <siproc>
2006a88: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
2006a8c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
2006a90: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2006a94: 80 a0 80 01 cmp %g2, %g1
2006a98: 16 bf ff 4f bge 20067d4 <rtems_termios_read+0x84>
2006a9c: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
2006aa0: 22 bf ff f4 be,a 2006a70 <rtems_termios_read+0x320> <== NEVER TAKEN
2006aa4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
2006aa8: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
2006aac: 80 a0 60 00 cmp %g1, 0
2006ab0: 22 bf ff f0 be,a 2006a70 <rtems_termios_read+0x320> <== NEVER TAKEN
2006ab4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
2006ab8: 30 bf ff ea b,a 2006a60 <rtems_termios_read+0x310>
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
2006abc: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
2006ac0: 80 a0 60 00 cmp %g1, 0
2006ac4: 02 80 00 0d be 2006af8 <rtems_termios_read+0x3a8>
2006ac8: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
2006acc: 80 a0 60 00 cmp %g1, 0
2006ad0: 02 80 00 06 be 2006ae8 <rtems_termios_read+0x398> <== NEVER TAKEN
2006ad4: 01 00 00 00 nop
2006ad8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
2006adc: 80 a0 60 00 cmp %g1, 0
2006ae0: 12 80 00 09 bne 2006b04 <rtems_termios_read+0x3b4>
2006ae4: 01 00 00 00 nop
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
2006ae8: 40 00 05 6f call 20080a4 <rtems_task_wake_after>
2006aec: 90 10 20 01 mov 1, %o0 ! 1 <PROM_START+0x1>
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006af0: 10 bf ff e0 b 2006a70 <rtems_termios_read+0x320>
2006af4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
2006af8: 80 a0 60 00 cmp %g1, 0
2006afc: 02 bf ff 37 be 20067d8 <rtems_termios_read+0x88> <== NEVER TAKEN
2006b00: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
2006b04: 40 00 02 57 call 2007460 <rtems_clock_get_ticks_since_boot>
2006b08: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
2006b0c: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
2006b10: 90 22 00 1c sub %o0, %i4, %o0
2006b14: 80 a2 00 01 cmp %o0, %g1
2006b18: 08 bf ff f4 bleu 2006ae8 <rtems_termios_read+0x398>
2006b1c: 80 a6 e0 00 cmp %i3, 0
2006b20: 30 bf ff 2e b,a 20067d8 <rtems_termios_read+0x88>
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
2006b24: 40 00 05 60 call 20080a4 <rtems_task_wake_after>
2006b28: 90 10 20 01 mov 1, %o0
2006b2c: 10 bf ff c1 b 2006a30 <rtems_termios_read+0x2e0>
2006b30: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
020050ec <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)
{
20050ec: 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))
20050f0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
20050f4: 82 08 64 03 and %g1, 0x403, %g1
20050f8: 80 a0 64 01 cmp %g1, 0x401
20050fc: 02 80 00 44 be 200520c <rtems_termios_refill_transmitter+0x120><== NEVER TAKEN
2005100: ba 10 00 18 mov %i0, %i5
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
2005104: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
2005108: 82 08 60 03 and %g1, 3, %g1
200510c: 80 a0 60 02 cmp %g1, 2
2005110: 22 80 00 50 be,a 2005250 <rtems_termios_refill_transmitter+0x164><== NEVER TAKEN
2005114: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
2005118: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
200511c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2005120: 80 a0 80 01 cmp %g2, %g1
2005124: 22 80 00 30 be,a 20051e4 <rtems_termios_refill_transmitter+0xf8>
2005128: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
200512c: 7f ff f5 38 call 200260c <sparc_disable_interrupts>
2005130: 01 00 00 00 nop
len = tty->t_dqlen;
2005134: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
2005138: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
200513c: 7f ff f5 38 call 200261c <sparc_enable_interrupts>
2005140: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
2005144: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
2005148: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
200514c: 40 00 50 cc call 201947c <.urem>
2005150: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
2005154: 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;
2005158: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
200515c: 80 a0 60 02 cmp %g1, 2
2005160: 02 80 00 55 be 20052b4 <rtems_termios_refill_transmitter+0x1c8>
2005164: b8 10 00 08 mov %o0, %i4
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
2005168: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
200516c: 80 a0 40 1c cmp %g1, %i4
2005170: 22 80 00 48 be,a 2005290 <rtems_termios_refill_transmitter+0x1a4>
2005174: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
2005178: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
200517c: 82 08 62 10 and %g1, 0x210, %g1
2005180: 80 a0 62 10 cmp %g1, 0x210
2005184: 02 80 00 4f be 20052c0 <rtems_termios_refill_transmitter+0x1d4><== NEVER TAKEN
2005188: 01 00 00 00 nop
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
200518c: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2005190: 80 a7 00 01 cmp %i4, %g1
2005194: 18 80 00 1b bgu 2005200 <rtems_termios_refill_transmitter+0x114>
2005198: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
200519c: f0 07 60 80 ld [ %i5 + 0x80 ], %i0
20051a0: b0 26 00 1c sub %i0, %i4, %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)) {
20051a4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20051a8: 80 88 66 00 btst 0x600, %g1
20051ac: 02 80 00 04 be 20051bc <rtems_termios_refill_transmitter+0xd0>
20051b0: 94 10 00 18 mov %i0, %o2
20051b4: 94 10 20 01 mov 1, %o2
nToSend = 1;
20051b8: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
20051bc: d2 07 60 7c ld [ %i5 + 0x7c ], %o1
20051c0: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
20051c4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
/* 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*/
20051c8: 84 10 20 01 mov 1, %g2
(*tty->device.write)(
20051cc: 92 02 40 1c add %o1, %i4, %o1
20051d0: 9f c0 40 00 call %g1
20051d4: c4 27 60 94 st %g2, [ %i5 + 0x94 ]
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
20051d8: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
20051dc: 81 c7 e0 08 ret
20051e0: 81 e8 00 00 restore
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
20051e4: 80 a0 60 02 cmp %g1, 2
20051e8: 12 bf ff fd bne 20051dc <rtems_termios_refill_transmitter+0xf0><== ALWAYS TAKEN
20051ec: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
20051f0: 40 00 0a ab call 2007c9c <rtems_semaphore_release> <== NOT EXECUTED
20051f4: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
20051f8: 81 c7 e0 08 ret <== NOT EXECUTED
20051fc: 81 e8 00 00 restore <== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
2005200: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
2005204: 10 bf ff e8 b 20051a4 <rtems_termios_refill_transmitter+0xb8>
2005208: b0 26 00 1c sub %i0, %i4, %i0
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
200520c: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
2005210: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2005214: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
2005218: 9f c0 40 00 call %g1 <== NOT EXECUTED
200521c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
2005220: 7f ff f4 fb call 200260c <sparc_disable_interrupts> <== NOT EXECUTED
2005224: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
2005228: c4 06 20 90 ld [ %i0 + 0x90 ], %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
200522c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
2005230: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
2005234: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
2005238: c4 27 60 90 st %g2, [ %i5 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
200523c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
2005240: 7f ff f4 f7 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
2005244: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2005248: 81 c7 e0 08 ret <== NOT EXECUTED
200524c: 81 e8 00 00 restore <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
2005250: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2005254: 92 06 20 49 add %i0, 0x49, %o1 <== NOT EXECUTED
2005258: 9f c0 40 00 call %g1 <== NOT EXECUTED
200525c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
2005260: 7f ff f4 eb call 200260c <sparc_disable_interrupts> <== NOT EXECUTED
2005264: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
2005268: c4 06 20 90 ld [ %i0 + 0x90 ], %g2 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
200526c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
2005270: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
2005274: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
2005278: c4 27 60 90 st %g2, [ %i5 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
200527c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
2005280: 7f ff f4 e7 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
2005284: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2005288: 81 c7 e0 08 ret <== NOT EXECUTED
200528c: 81 e8 00 00 restore <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
2005290: 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) {
2005294: 80 a0 60 00 cmp %g1, 0
2005298: 02 bf ff d0 be 20051d8 <rtems_termios_refill_transmitter+0xec><== ALWAYS TAKEN
200529c: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
20052a0: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
20052a4: 9f c0 40 00 call %g1 <== NOT EXECUTED
20052a8: 90 07 60 30 add %i5, 0x30, %o0 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
20052ac: f8 27 60 84 st %i4, [ %i5 + 0x84 ] <== NOT EXECUTED
20052b0: 30 bf ff f6 b,a 2005288 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
20052b4: 40 00 0a 7a call 2007c9c <rtems_semaphore_release>
20052b8: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
20052bc: 30 bf ff ab b,a 2005168 <rtems_termios_refill_transmitter+0x7c>
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
20052c0: 7f ff f4 d3 call 200260c <sparc_disable_interrupts> <== NOT EXECUTED
20052c4: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
20052c8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
20052cc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
20052d0: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
20052d4: c4 27 60 94 st %g2, [ %i5 + 0x94 ] <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
20052d8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
rtems_interrupt_enable(level);
20052dc: 7f ff f4 d0 call 200261c <sparc_enable_interrupts> <== NOT EXECUTED
20052e0: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
20052e4: f8 27 60 84 st %i4, [ %i5 + 0x84 ] <== NOT EXECUTED
20052e8: 30 bf ff e8 b,a 2005288 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
02006e6c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
2006e6c: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006e70: 10 80 00 08 b 2006e90 <rtems_termios_rxdaemon+0x24>
2006e74: 96 07 bf fc add %fp, -4, %o3
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
2006e78: 9f c0 40 00 call %g1
2006e7c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
2006e80: 80 a2 3f ff cmp %o0, -1
2006e84: 32 80 00 15 bne,a 2006ed8 <rtems_termios_rxdaemon+0x6c>
2006e88: d0 2f bf fb stb %o0, [ %fp + -5 ]
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006e8c: 96 07 bf fc add %fp, -4, %o3
2006e90: 92 10 20 02 mov 2, %o1
2006e94: 94 10 20 00 clr %o2
2006e98: 40 00 01 95 call 20074ec <rtems_event_receive>
2006e9c: 90 10 20 03 mov 3, %o0
(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) {
2006ea0: c2 07 bf fc ld [ %fp + -4 ], %g1
2006ea4: 80 88 60 01 btst 1, %g1
2006ea8: 22 bf ff f4 be,a 2006e78 <rtems_termios_rxdaemon+0xc> <== ALWAYS TAKEN
2006eac: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
2006eb0: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
2006eb4: 40 00 04 03 call 2007ec0 <rtems_task_delete> <== NOT EXECUTED
2006eb8: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
2006ebc: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
2006ec0: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006ec4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
if (c != EOF) {
2006ec8: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2006ecc: 22 bf ff f1 be,a 2006e90 <rtems_termios_rxdaemon+0x24> <== NOT EXECUTED
2006ed0: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
2006ed4: d0 2f bf fb stb %o0, [ %fp + -5 ] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
2006ed8: 92 07 bf fb add %fp, -5, %o1
2006edc: 90 10 00 18 mov %i0, %o0
2006ee0: 7f ff ff 1a call 2006b48 <rtems_termios_enqueue_raw_characters>
2006ee4: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006ee8: 10 bf ff ea b 2006e90 <rtems_termios_rxdaemon+0x24>
2006eec: 96 07 bf fc add %fp, -4, %o3
020052ec <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
20052ec: 9d e3 bf 98 save %sp, -104, %sp
20052f0: 3b 00 80 77 sethi %hi(0x201dc00), %i5
20052f4: 10 80 00 0c b 2005324 <rtems_termios_txdaemon+0x38>
20052f8: ba 17 63 14 or %i5, 0x314, %i5 ! 201df14 <rtems_termios_linesw>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
20052fc: 83 28 60 05 sll %g1, 5, %g1
2005300: 82 07 40 01 add %i5, %g1, %g1
2005304: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2005308: 80 a0 60 00 cmp %g1, 0
200530c: 02 80 00 04 be 200531c <rtems_termios_txdaemon+0x30> <== ALWAYS TAKEN
2005310: 90 10 00 18 mov %i0, %o0
rtems_termios_linesw[tty->t_line].l_start(tty);
2005314: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005318: 01 00 00 00 nop <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
200531c: 7f ff ff 74 call 20050ec <rtems_termios_refill_transmitter>
2005320: 90 10 00 18 mov %i0, %o0
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2005324: 92 10 20 02 mov 2, %o1
2005328: 94 10 20 00 clr %o2
200532c: 96 07 bf fc add %fp, -4, %o3
2005330: 40 00 08 6f call 20074ec <rtems_event_receive>
2005334: 90 10 20 03 mov 3, %o0
(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) {
2005338: c2 07 bf fc ld [ %fp + -4 ], %g1
200533c: 80 88 60 01 btst 1, %g1
2005340: 22 bf ff ef be,a 20052fc <rtems_termios_txdaemon+0x10> <== ALWAYS TAKEN
2005344: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
2005348: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
200534c: 40 00 0a dd call 2007ec0 <rtems_task_delete> <== NOT EXECUTED
2005350: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2005354: 10 bf ff ea b 20052fc <rtems_termios_txdaemon+0x10> <== NOT EXECUTED
2005358: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
0200667c <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
200667c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2006680: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2006684: 92 10 20 00 clr %o1
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2006688: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200668c: 94 10 20 00 clr %o2
2006690: 40 00 05 34 call 2007b60 <rtems_semaphore_obtain>
2006694: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2006698: b4 92 20 00 orcc %o0, 0, %i2
200669c: 12 80 00 0f bne 20066d8 <rtems_termios_write+0x5c> <== NEVER TAKEN
20066a0: 03 00 80 77 sethi %hi(0x201dc00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
20066a4: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
20066a8: 85 28 a0 05 sll %g2, 5, %g2
20066ac: 82 10 63 14 or %g1, 0x314, %g1
20066b0: 82 00 40 02 add %g1, %g2, %g1
20066b4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20066b8: 80 a0 60 00 cmp %g1, 0
20066bc: 02 80 00 09 be 20066e0 <rtems_termios_write+0x64>
20066c0: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
20066c4: 9f c0 40 00 call %g1
20066c8: 92 10 00 18 mov %i0, %o1
20066cc: b4 10 00 08 mov %o0, %i2
rtems_semaphore_release (tty->osem);
20066d0: 40 00 05 73 call 2007c9c <rtems_semaphore_release>
20066d4: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
20066d8: 81 c7 e0 08 ret
20066dc: 91 e8 00 1a restore %g0, %i2, %o0
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) {
20066e0: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
20066e4: 80 88 60 01 btst 1, %g1
20066e8: 22 80 00 14 be,a 2006738 <rtems_termios_write+0xbc> <== NEVER TAKEN
20066ec: d0 1e 20 10 ldd [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
uint32_t count = args->count;
20066f0: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
char *buffer = args->buffer;
while (count--)
20066f4: 80 a7 20 00 cmp %i4, 0
20066f8: 02 80 00 14 be 2006748 <rtems_termios_write+0xcc> <== NEVER TAKEN
20066fc: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
oproc (*buffer++, tty);
2006700: d0 0e c0 00 ldub [ %i3 ], %o0
2006704: 92 10 00 1d mov %i5, %o1
2006708: 7f ff fe 3e call 2006000 <oproc>
200670c: 90 0a 20 ff and %o0, 0xff, %o0
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
2006710: b8 87 3f ff addcc %i4, -1, %i4
2006714: 12 bf ff fb bne 2006700 <rtems_termios_write+0x84>
2006718: b6 06 e0 01 inc %i3
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
200671c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
}
rtems_semaphore_release (tty->osem);
2006720: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
2006724: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
}
rtems_semaphore_release (tty->osem);
2006728: 40 00 05 5d call 2007c9c <rtems_semaphore_release>
200672c: b0 10 00 1a mov %i2, %i0
return sc;
}
2006730: 81 c7 e0 08 ret
2006734: 81 e8 00 00 restore
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
2006738: 7f ff fd e2 call 2005ec0 <rtems_termios_puts> <== NOT EXECUTED
200673c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
2006740: 10 bf ff f8 b 2006720 <rtems_termios_write+0xa4> <== NOT EXECUTED
2006744: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
2006748: 10 bf ff f6 b 2006720 <rtems_termios_write+0xa4> <== NOT EXECUTED
200674c: 82 10 20 00 clr %g1 <== NOT EXECUTED
02017850 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
2017850: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
2017854: 11 00 80 f4 sethi %hi(0x203d000), %o0
2017858: 92 10 00 18 mov %i0, %o1
201785c: 90 12 22 a8 or %o0, 0x2a8, %o0
2017860: 40 00 0c fe call 201ac58 <_Objects_Get>
2017864: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2017868: c2 07 bf fc ld [ %fp + -4 ], %g1
201786c: 80 a0 60 00 cmp %g1, 0
2017870: 12 80 00 0c bne 20178a0 <rtems_timer_cancel+0x50>
2017874: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
2017878: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
201787c: 80 a0 60 04 cmp %g1, 4
2017880: 02 80 00 04 be 2017890 <rtems_timer_cancel+0x40> <== NEVER TAKEN
2017884: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
2017888: 40 00 15 41 call 201cd8c <_Watchdog_Remove>
201788c: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
2017890: 40 00 11 0c call 201bcc0 <_Thread_Enable_dispatch>
2017894: b0 10 20 00 clr %i0
2017898: 81 c7 e0 08 ret
201789c: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
20178a0: 81 c7 e0 08 ret
20178a4: 91 e8 20 04 restore %g0, 4, %o0
02017da8 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2017da8: 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;
2017dac: 03 00 80 f4 sethi %hi(0x203d000), %g1
2017db0: fa 00 62 e8 ld [ %g1 + 0x2e8 ], %i5 ! 203d2e8 <_Timer_server>
if ( !timer_server )
2017db4: 80 a7 60 00 cmp %i5, 0
2017db8: 02 80 00 08 be 2017dd8 <rtems_timer_server_fire_when+0x30>
2017dbc: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
2017dc0: 39 00 80 f2 sethi %hi(0x203c800), %i4
2017dc4: 82 17 20 78 or %i4, 0x78, %g1 ! 203c878 <_TOD>
2017dc8: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
2017dcc: 80 a0 a0 00 cmp %g2, 0
2017dd0: 12 80 00 04 bne 2017de0 <rtems_timer_server_fire_when+0x38><== ALWAYS TAKEN
2017dd4: 82 10 20 0b mov 0xb, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2017dd8: 81 c7 e0 08 ret
2017ddc: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
2017de0: 80 a6 a0 00 cmp %i2, 0
2017de4: 02 bf ff fd be 2017dd8 <rtems_timer_server_fire_when+0x30>
2017de8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
2017dec: 7f ff f3 1e call 2014a64 <_TOD_Validate>
2017df0: 90 10 00 19 mov %i1, %o0
2017df4: 80 8a 20 ff btst 0xff, %o0
2017df8: 12 80 00 04 bne 2017e08 <rtems_timer_server_fire_when+0x60>
2017dfc: 82 10 20 14 mov 0x14, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2017e00: 81 c7 e0 08 ret
2017e04: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
2017e08: 7f ff f2 dd call 201497c <_TOD_To_seconds>
2017e0c: 90 10 00 19 mov %i1, %o0
2017e10: b2 10 00 08 mov %o0, %i1
2017e14: d0 1f 20 78 ldd [ %i4 + 0x78 ], %o0
2017e18: 94 10 20 00 clr %o2
2017e1c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2017e20: 40 00 52 17 call 202c67c <__divdi3>
2017e24: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
2017e28: 80 a6 40 09 cmp %i1, %o1
2017e2c: 08 bf ff f5 bleu 2017e00 <rtems_timer_server_fire_when+0x58>
2017e30: 82 10 20 14 mov 0x14, %g1
2017e34: 92 10 00 18 mov %i0, %o1
2017e38: 11 00 80 f4 sethi %hi(0x203d000), %o0
2017e3c: 94 07 bf fc add %fp, -4, %o2
2017e40: 40 00 0b 86 call 201ac58 <_Objects_Get>
2017e44: 90 12 22 a8 or %o0, 0x2a8, %o0
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2017e48: c2 07 bf fc ld [ %fp + -4 ], %g1
2017e4c: 80 a0 60 00 cmp %g1, 0
2017e50: 12 80 00 19 bne 2017eb4 <rtems_timer_server_fire_when+0x10c>
2017e54: a0 10 00 08 mov %o0, %l0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
2017e58: 40 00 13 cd call 201cd8c <_Watchdog_Remove>
2017e5c: 90 02 20 10 add %o0, 0x10, %o0
2017e60: d0 1f 20 78 ldd [ %i4 + 0x78 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
2017e64: 82 10 20 03 mov 3, %g1
2017e68: 94 10 20 00 clr %o2
2017e6c: c2 24 20 38 st %g1, [ %l0 + 0x38 ]
2017e70: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2017e74: c0 24 20 18 clr [ %l0 + 0x18 ]
2017e78: 96 12 e2 00 or %o3, 0x200, %o3
the_watchdog->routine = routine;
2017e7c: f4 24 20 2c st %i2, [ %l0 + 0x2c ]
the_watchdog->id = id;
2017e80: f0 24 20 30 st %i0, [ %l0 + 0x30 ]
2017e84: 40 00 51 fe call 202c67c <__divdi3>
2017e88: f6 24 20 34 st %i3, [ %l0 + 0x34 ]
_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 );
2017e8c: c2 07 60 04 ld [ %i5 + 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();
2017e90: b2 26 40 09 sub %i1, %o1, %i1
(*timer_server->schedule_operation)( timer_server, the_timer );
2017e94: 90 10 00 1d mov %i5, %o0
2017e98: 92 10 00 10 mov %l0, %o1
2017e9c: 9f c0 40 00 call %g1
2017ea0: f2 24 20 1c st %i1, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
2017ea4: 40 00 0f 87 call 201bcc0 <_Thread_Enable_dispatch>
2017ea8: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2017eac: 10 bf ff cb b 2017dd8 <rtems_timer_server_fire_when+0x30>
2017eb0: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2017eb4: 10 bf ff c9 b 2017dd8 <rtems_timer_server_fire_when+0x30>
2017eb8: 82 10 20 04 mov 4, %g1
02003420 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
2003420: 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) {
2003424: 03 08 00 00 sethi %hi(0x20000000), %g1
2003428: 80 8e 00 01 btst %i0, %g1
200342c: 02 80 00 10 be 200346c <rtems_verror+0x4c>
2003430: b8 10 00 18 mov %i0, %i4
if (rtems_panic_in_progress++)
2003434: 05 00 80 78 sethi %hi(0x201e000), %g2
2003438: c6 00 a1 90 ld [ %g2 + 0x190 ], %g3 ! 201e190 <rtems_panic_in_progress>
200343c: 82 00 e0 01 add %g3, 1, %g1
2003440: 80 a0 e0 00 cmp %g3, 0
2003444: 02 80 00 07 be 2003460 <rtems_verror+0x40> <== ALWAYS TAKEN
2003448: c2 20 a1 90 st %g1, [ %g2 + 0x190 ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200344c: 03 00 80 78 sethi %hi(0x201e000), %g1 <== NOT EXECUTED
2003450: c6 00 63 20 ld [ %g1 + 0x320 ], %g3 ! 201e320 <_Thread_Dispatch_disable_level><== NOT EXECUTED
++level;
2003454: 86 00 e0 01 inc %g3 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
2003458: c6 20 63 20 st %g3, [ %g1 + 0x320 ] <== NOT EXECUTED
void _Thread_Disable_dispatch( void );
#else
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )
{
_Thread_Dispatch_increment_disable_level();
RTEMS_COMPILER_MEMORY_BARRIER();
200345c: c2 00 a1 90 ld [ %g2 + 0x190 ], %g1 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
2003460: 80 a0 60 02 cmp %g1, 2
2003464: 14 80 00 30 bg 2003524 <rtems_verror+0x104> <== NEVER TAKEN
2003468: b0 10 20 00 clr %i0
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
200346c: 3b 00 80 76 sethi %hi(0x201d800), %i5
2003470: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1 ! 201d9b0 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
2003474: 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 */
2003478: d0 00 60 08 ld [ %g1 + 8 ], %o0
200347c: 40 00 34 da call 20107e4 <fflush>
2003480: b6 2f 00 1b andn %i4, %i3, %i3
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
2003484: 03 10 00 00 sethi %hi(0x40000000), %g1
2003488: 80 8f 00 01 btst %i4, %g1
200348c: 12 80 00 34 bne 200355c <rtems_verror+0x13c>
2003490: 01 00 00 00 nop
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
2003494: b8 10 20 00 clr %i4 ! 0 <PROM_START>
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
2003498: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
200349c: 92 10 00 19 mov %i1, %o1
20034a0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20034a4: 40 00 48 e2 call 201582c <vfprintf>
20034a8: 94 10 00 1a mov %i2, %o2
if (status)
20034ac: 80 a6 e0 00 cmp %i3, 0
20034b0: 12 80 00 1f bne 200352c <rtems_verror+0x10c>
20034b4: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
20034b8: 80 a7 20 00 cmp %i4, 0
20034bc: 02 80 00 12 be 2003504 <rtems_verror+0xe4>
20034c0: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
if ((local_errno > 0) && *strerror(local_errno))
20034c4: 80 a7 20 00 cmp %i4, 0
20034c8: 04 80 00 09 ble 20034ec <rtems_verror+0xcc>
20034cc: 13 00 80 6e sethi %hi(0x201b800), %o1
20034d0: 40 00 39 1f call 201194c <strerror>
20034d4: 90 10 00 1c mov %i4, %o0
20034d8: c2 4a 00 00 ldsb [ %o0 ], %g1
20034dc: 80 a0 60 00 cmp %g1, 0
20034e0: 12 80 00 23 bne 200356c <rtems_verror+0x14c> <== ALWAYS TAKEN
20034e4: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
20034e8: 13 00 80 6e sethi %hi(0x201b800), %o1 <== NOT EXECUTED
20034ec: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20034f0: 92 12 63 90 or %o1, 0x390, %o1
20034f4: 40 00 35 b8 call 2010bd4 <fprintf>
20034f8: 94 10 00 1c mov %i4, %o2
20034fc: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
2003500: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
2003504: 13 00 80 6e sethi %hi(0x201b800), %o1
2003508: d0 00 60 0c ld [ %g1 + 0xc ], %o0
200350c: 40 00 35 b2 call 2010bd4 <fprintf>
2003510: 92 12 61 c8 or %o1, 0x1c8, %o1
(void) fflush(stderr);
2003514: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %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");
2003518: b0 02 00 18 add %o0, %i0, %i0
(void) fflush(stderr);
200351c: 40 00 34 b2 call 20107e4 <fflush>
2003520: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
2003524: 81 c7 e0 08 ret
2003528: 81 e8 00 00 restore
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
200352c: 03 00 80 76 sethi %hi(0x201d800), %g1
2003530: c2 00 61 b0 ld [ %g1 + 0x1b0 ], %g1 ! 201d9b0 <_impure_ptr>
2003534: 90 10 00 1b mov %i3, %o0
2003538: 7f ff ff b4 call 2003408 <rtems_status_text>
200353c: f6 00 60 0c ld [ %g1 + 0xc ], %i3
2003540: 13 00 80 6e sethi %hi(0x201b800), %o1
2003544: 94 10 00 08 mov %o0, %o2
2003548: 92 12 63 70 or %o1, 0x370, %o1
200354c: 40 00 35 a2 call 2010bd4 <fprintf>
2003550: 90 10 00 1b mov %i3, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
2003554: 10 bf ff d9 b 20034b8 <rtems_verror+0x98>
2003558: b0 06 00 08 add %i0, %o0, %i0
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
200355c: 40 00 33 9f call 20103d8 <__errno>
2003560: 01 00 00 00 nop
2003564: 10 bf ff cd b 2003498 <rtems_verror+0x78>
2003568: f8 02 00 00 ld [ %o0 ], %i4
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
200356c: 90 10 00 1c mov %i4, %o0
2003570: 40 00 38 f7 call 201194c <strerror>
2003574: f8 00 60 0c ld [ %g1 + 0xc ], %i4
2003578: 13 00 80 6e sethi %hi(0x201b800), %o1
200357c: 94 10 00 08 mov %o0, %o2
2003580: 92 12 63 80 or %o1, 0x380, %o1
2003584: 40 00 35 94 call 2010bd4 <fprintf>
2003588: 90 10 00 1c mov %i4, %o0
200358c: 10 bf ff dd b 2003500 <rtems_verror+0xe0>
2003590: b0 06 00 08 add %i0, %o0, %i0
02027850 <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
2027850: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2027854: 35 1f ff ff sethi %hi(0x7ffffc00), %i2
int sign = 0;
2027858: b6 10 20 00 clr %i3
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
202785c: b4 16 a3 ff or %i2, 0x3ff, %i2
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
2027860: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2027864: 23 00 81 8e sethi %hi(0x2063800), %l1
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
2027868: 21 00 81 8e sethi %hi(0x2063800), %l0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
202786c: c2 06 20 04 ld [ %i0 + 4 ], %g1
2027870: 82 00 7f ff add %g1, -1, %g1
2027874: 80 a0 60 00 cmp %g1, 0
2027878: 06 80 00 26 bl 2027910 <scanInt+0xc0> <== NEVER TAKEN
202787c: c2 26 20 04 st %g1, [ %i0 + 4 ]
2027880: c4 06 00 00 ld [ %i0 ], %g2
2027884: d0 08 80 00 ldub [ %g2 ], %o0
2027888: 84 00 a0 01 inc %g2
if (c == ':')
202788c: 80 a2 20 3a cmp %o0, 0x3a
2027890: 02 80 00 26 be 2027928 <scanInt+0xd8>
2027894: c4 26 00 00 st %g2, [ %i0 ]
break;
if (sign == 0) {
2027898: 80 a6 e0 00 cmp %i3, 0
202789c: 32 80 00 06 bne,a 20278b4 <scanInt+0x64>
20278a0: c4 04 22 68 ld [ %l0 + 0x268 ], %g2
if (c == '-') {
20278a4: 80 a2 20 2d cmp %o0, 0x2d
20278a8: 02 80 00 32 be 2027970 <scanInt+0x120>
20278ac: b6 10 20 01 mov 1, %i3
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
20278b0: c4 04 22 68 ld [ %l0 + 0x268 ], %g2
20278b4: 84 00 80 08 add %g2, %o0, %g2
20278b8: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
20278bc: 80 88 a0 04 btst 4, %g2
20278c0: 22 80 00 22 be,a 2027948 <scanInt+0xf8>
20278c4: b0 10 20 00 clr %i0
return 0;
d = c - '0';
20278c8: b8 02 3f d0 add %o0, -48, %i4
if ((i > (limit / 10))
20278cc: 92 10 20 0a mov 0xa, %o1
20278d0: 40 00 b6 77 call 20552ac <.udiv>
20278d4: 90 10 00 1a mov %i2, %o0
20278d8: 80 a7 40 08 cmp %i5, %o0
20278dc: 38 80 00 1b bgu,a 2027948 <scanInt+0xf8>
20278e0: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
20278e4: 02 80 00 1b be 2027950 <scanInt+0x100>
20278e8: 90 10 00 1a mov %i2, %o0
return 0;
i = i * 10 + d;
20278ec: 83 2f 60 01 sll %i5, 1, %g1
20278f0: bb 2f 60 03 sll %i5, 3, %i5
20278f4: ba 00 40 1d add %g1, %i5, %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
20278f8: c2 06 20 04 ld [ %i0 + 4 ], %g1
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
20278fc: ba 07 00 1d add %i4, %i5, %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2027900: 82 00 7f ff add %g1, -1, %g1
2027904: 80 a0 60 00 cmp %g1, 0
2027908: 16 bf ff de bge 2027880 <scanInt+0x30> <== ALWAYS TAKEN
202790c: c2 26 20 04 st %g1, [ %i0 + 4 ]
2027910: d0 04 62 78 ld [ %l1 + 0x278 ], %o0 <== NOT EXECUTED
2027914: 40 00 67 cb call 2041840 <__srget_r> <== NOT EXECUTED
2027918: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
202791c: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
2027920: 12 bf ff df bne 202789c <scanInt+0x4c> <== NOT EXECUTED
2027924: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
2027928: 80 a6 e0 00 cmp %i3, 0
202792c: 02 80 00 07 be 2027948 <scanInt+0xf8> <== NEVER TAKEN
2027930: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
2027934: 90 10 00 1b mov %i3, %o0
2027938: 92 10 00 1d mov %i5, %o1
202793c: 40 00 b6 22 call 20551c4 <.umul>
2027940: b0 10 20 01 mov 1, %i0
2027944: d0 26 40 00 st %o0, [ %i1 ]
return 1;
2027948: 81 c7 e0 08 ret
202794c: 81 e8 00 00 restore
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
2027950: 40 00 b7 03 call 205555c <.urem>
2027954: 92 10 20 0a mov 0xa, %o1
2027958: 80 a7 00 08 cmp %i4, %o0
202795c: 08 bf ff e5 bleu 20278f0 <scanInt+0xa0> <== NEVER TAKEN
2027960: 83 2f 60 01 sll %i5, 1, %g1
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
2027964: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
2027968: 81 c7 e0 08 ret
202796c: 81 e8 00 00 restore
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
limit++;
2027970: b4 06 a0 01 inc %i2
continue;
2027974: 10 bf ff be b 202786c <scanInt+0x1c>
2027978: b6 10 3f ff mov -1, %i3
0202797c <scanString>:
/**
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
202797c: 9d e3 bf a0 save %sp, -96, %sp
int c;
*name = *bufp;
2027980: c2 06 80 00 ld [ %i2 ], %g1
for (;;) {
c = getc(fp);
2027984: 3b 00 81 8e sethi %hi(0x2063800), %i5
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
int c;
*name = *bufp;
2027988: 10 80 00 19 b 20279ec <scanString+0x70>
202798c: c2 26 40 00 st %g1, [ %i1 ]
for (;;) {
c = getc(fp);
2027990: c2 06 00 00 ld [ %i0 ], %g1
2027994: d0 08 40 00 ldub [ %g1 ], %o0
2027998: 82 00 60 01 inc %g1
if (c == ':') {
202799c: 80 a2 20 3a cmp %o0, 0x3a
20279a0: 02 80 00 1e be 2027a18 <scanString+0x9c>
20279a4: c2 26 00 00 st %g1, [ %i0 ]
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
20279a8: 80 a2 20 0a cmp %o0, 0xa
20279ac: 02 80 00 2a be 2027a54 <scanString+0xd8>
20279b0: 80 a2 3f ff cmp %o0, -1
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
20279b4: 02 80 00 26 be 2027a4c <scanString+0xd0>
20279b8: 01 00 00 00 nop
return 0;
if (*nleft < 2)
20279bc: c2 06 c0 00 ld [ %i3 ], %g1
20279c0: 80 a0 60 01 cmp %g1, 1
20279c4: 08 80 00 22 bleu 2027a4c <scanString+0xd0>
20279c8: 01 00 00 00 nop
return 0;
**bufp = c;
20279cc: c2 06 80 00 ld [ %i2 ], %g1
20279d0: d0 28 40 00 stb %o0, [ %g1 ]
++(*bufp);
20279d4: c4 06 80 00 ld [ %i2 ], %g2
--(*nleft);
20279d8: c2 06 c0 00 ld [ %i3 ], %g1
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
20279dc: 84 00 a0 01 inc %g2
20279e0: c4 26 80 00 st %g2, [ %i2 ]
--(*nleft);
20279e4: 82 00 7f ff add %g1, -1, %g1
20279e8: c2 26 c0 00 st %g1, [ %i3 ]
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
20279ec: c2 06 20 04 ld [ %i0 + 4 ], %g1
20279f0: 82 00 7f ff add %g1, -1, %g1
20279f4: 80 a0 60 00 cmp %g1, 0
20279f8: 16 bf ff e6 bge 2027990 <scanString+0x14>
20279fc: c2 26 20 04 st %g1, [ %i0 + 4 ]
2027a00: d0 07 62 78 ld [ %i5 + 0x278 ], %o0
2027a04: 40 00 67 8f call 2041840 <__srget_r>
2027a08: 92 10 00 18 mov %i0, %o1
if (c == ':') {
2027a0c: 80 a2 20 3a cmp %o0, 0x3a
2027a10: 12 bf ff e7 bne 20279ac <scanString+0x30> <== ALWAYS TAKEN
2027a14: 80 a2 20 0a cmp %o0, 0xa
if (nlFlag)
2027a18: 80 a7 20 00 cmp %i4, 0
2027a1c: 12 80 00 11 bne 2027a60 <scanString+0xe4>
2027a20: b0 10 20 00 clr %i0
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
2027a24: c2 06 80 00 ld [ %i2 ], %g1
2027a28: c0 28 40 00 clrb [ %g1 ]
++(*bufp);
2027a2c: c4 06 80 00 ld [ %i2 ], %g2
--(*nleft);
2027a30: c2 06 c0 00 ld [ %i3 ], %g1
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
2027a34: 84 00 a0 01 inc %g2
2027a38: c4 26 80 00 st %g2, [ %i2 ]
--(*nleft);
2027a3c: 82 00 7f ff add %g1, -1, %g1
2027a40: c2 26 c0 00 st %g1, [ %i3 ]
return 1;
2027a44: 81 c7 e0 08 ret
2027a48: 91 e8 20 01 restore %g0, 1, %o0
}
2027a4c: 81 c7 e0 08 ret
2027a50: 91 e8 20 00 restore %g0, 0, %o0
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
2027a54: 80 a7 20 00 cmp %i4, 0
2027a58: 12 bf ff f3 bne 2027a24 <scanString+0xa8>
2027a5c: b0 10 20 00 clr %i0
2027a60: 81 c7 e0 08 ret
2027a64: 81 e8 00 00 restore
02027a68 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2027a68: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2027a6c: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2027a70: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2027a74: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2027a78: 90 10 00 18 mov %i0, %o0
2027a7c: 92 10 00 19 mov %i1, %o1
2027a80: 94 07 a0 4c add %fp, 0x4c, %o2
2027a84: 7f ff ff be call 202797c <scanString>
2027a88: 96 07 a0 50 add %fp, 0x50, %o3
2027a8c: 80 a2 20 00 cmp %o0, 0
2027a90: 12 80 00 04 bne 2027aa0 <scangr+0x38>
2027a94: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
2027a98: 81 c7 e0 08 ret
2027a9c: 91 e8 20 00 restore %g0, 0, %o0
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
2027aa0: 92 06 60 04 add %i1, 4, %o1
2027aa4: 94 07 a0 4c add %fp, 0x4c, %o2
2027aa8: 96 07 a0 50 add %fp, 0x50, %o3
2027aac: 7f ff ff b4 call 202797c <scanString>
2027ab0: 98 10 20 00 clr %o4
2027ab4: 80 a2 20 00 cmp %o0, 0
2027ab8: 02 bf ff f8 be 2027a98 <scangr+0x30> <== NEVER TAKEN
2027abc: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
2027ac0: 7f ff ff 64 call 2027850 <scanInt>
2027ac4: 92 07 bf f8 add %fp, -8, %o1
2027ac8: 80 a2 20 00 cmp %o0, 0
2027acc: 02 bf ff f3 be 2027a98 <scangr+0x30> <== NEVER TAKEN
2027ad0: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
2027ad4: 92 07 bf fc add %fp, -4, %o1
2027ad8: 94 07 a0 4c add %fp, 0x4c, %o2
2027adc: 96 07 a0 50 add %fp, 0x50, %o3
2027ae0: 7f ff ff a7 call 202797c <scanString>
2027ae4: 98 10 20 01 mov 1, %o4
2027ae8: 80 a2 20 00 cmp %o0, 0
2027aec: 02 bf ff eb be 2027a98 <scangr+0x30> <== NEVER TAKEN
2027af0: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027af4: fa 07 bf fc ld [ %fp + -4 ], %i5
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;
2027af8: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027afc: c6 0f 40 00 ldub [ %i5 ], %g3
2027b00: 83 28 e0 18 sll %g3, 0x18, %g1
2027b04: 80 a0 60 00 cmp %g1, 0
2027b08: 02 80 00 10 be 2027b48 <scangr+0xe0> <== NEVER TAKEN
2027b0c: 88 10 20 17 mov 0x17, %g4
2027b10: 84 10 00 1d mov %i5, %g2
2027b14: 88 10 20 01 mov 1, %g4
2027b18: 84 00 a0 01 inc %g2
2027b1c: c6 08 80 00 ldub [ %g2 ], %g3
if(*cp == ',')
2027b20: 83 38 60 18 sra %g1, 0x18, %g1
memcount++;
2027b24: 82 18 60 2c xor %g1, 0x2c, %g1
2027b28: 80 a0 00 01 cmp %g0, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027b2c: 83 28 e0 18 sll %g3, 0x18, %g1
if(*cp == ',')
memcount++;
2027b30: 88 61 3f ff subx %g4, -1, %g4
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027b34: 80 a0 60 00 cmp %g1, 0
2027b38: 32 bf ff f9 bne,a 2027b1c <scangr+0xb4>
2027b3c: 84 00 a0 01 inc %g2
2027b40: 89 29 20 02 sll %g4, 2, %g4
2027b44: 88 01 20 13 add %g4, 0x13, %g4
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
2027b48: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
2027b4c: 80 a0 40 04 cmp %g1, %g4
2027b50: 0a bf ff d2 bcs 2027a98 <scangr+0x30> <== NEVER TAKEN
2027b54: c2 07 a0 4c ld [ %fp + 0x4c ], %g1
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
2027b58: 82 00 60 0f add %g1, 0xf, %g1
2027b5c: 82 08 7f f0 and %g1, -16, %g1
2027b60: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
2027b64: fa 20 40 00 st %i5, [ %g1 ]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027b68: c2 07 bf fc ld [ %fp + -4 ], %g1
2027b6c: c4 08 40 00 ldub [ %g1 ], %g2
2027b70: 85 28 a0 18 sll %g2, 0x18, %g2
2027b74: 80 a0 a0 00 cmp %g2, 0
2027b78: 02 80 00 18 be 2027bd8 <scangr+0x170> <== NEVER TAKEN
2027b7c: 82 00 60 01 inc %g1
2027b80: 10 80 00 07 b 2027b9c <scangr+0x134>
2027b84: 86 10 20 01 mov 1, %g3
2027b88: c4 08 40 00 ldub [ %g1 ], %g2
2027b8c: 85 28 a0 18 sll %g2, 0x18, %g2
2027b90: 80 a0 a0 00 cmp %g2, 0
2027b94: 02 80 00 0c be 2027bc4 <scangr+0x15c>
2027b98: 82 00 60 01 inc %g1
if(*cp == ',') {
2027b9c: 85 38 a0 18 sra %g2, 0x18, %g2
2027ba0: 80 a0 a0 2c cmp %g2, 0x2c
2027ba4: 32 bf ff fa bne,a 2027b8c <scangr+0x124>
2027ba8: c4 08 40 00 ldub [ %g1 ], %g2
*cp = '\0';
2027bac: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
2027bb0: c8 06 60 0c ld [ %i1 + 0xc ], %g4
2027bb4: 85 28 e0 02 sll %g3, 2, %g2
2027bb8: 86 00 e0 01 inc %g3
2027bbc: 10 bf ff f3 b 2027b88 <scangr+0x120>
2027bc0: c2 21 00 02 st %g1, [ %g4 + %g2 ]
2027bc4: 87 28 e0 02 sll %g3, 2, %g3
}
}
grp->gr_mem[memcount] = NULL;
2027bc8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2027bcc: c0 20 40 03 clr [ %g1 + %g3 ]
return 1;
}
2027bd0: 81 c7 e0 08 ret
2027bd4: 91 e8 20 01 restore %g0, 1, %o0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2027bd8: 10 bf ff fc b 2027bc8 <scangr+0x160> <== NOT EXECUTED
2027bdc: 86 10 20 04 mov 4, %g3 <== NOT EXECUTED
02027be0 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2027be0: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2027be4: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2027be8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2027bec: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2027bf0: 90 10 00 18 mov %i0, %o0
2027bf4: 92 10 00 19 mov %i1, %o1
2027bf8: 94 07 a0 4c add %fp, 0x4c, %o2
2027bfc: 7f ff ff 60 call 202797c <scanString>
2027c00: 96 07 a0 50 add %fp, 0x50, %o3
2027c04: 80 a2 20 00 cmp %o0, 0
2027c08: 12 80 00 04 bne 2027c18 <scanpw+0x38>
2027c0c: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
2027c10: 81 c7 e0 08 ret
2027c14: 91 e8 20 00 restore %g0, 0, %o0
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
2027c18: 92 06 60 04 add %i1, 4, %o1
2027c1c: 94 07 a0 4c add %fp, 0x4c, %o2
2027c20: 96 07 a0 50 add %fp, 0x50, %o3
2027c24: 7f ff ff 56 call 202797c <scanString>
2027c28: 98 10 20 00 clr %o4
2027c2c: 80 a2 20 00 cmp %o0, 0
2027c30: 02 bf ff f8 be 2027c10 <scanpw+0x30> <== NEVER TAKEN
2027c34: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
2027c38: 7f ff ff 06 call 2027850 <scanInt>
2027c3c: 92 07 bf f8 add %fp, -8, %o1
2027c40: 80 a2 20 00 cmp %o0, 0
2027c44: 02 bf ff f3 be 2027c10 <scanpw+0x30>
2027c48: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
2027c4c: 7f ff ff 01 call 2027850 <scanInt>
2027c50: 92 07 bf fc add %fp, -4, %o1
2027c54: 80 a2 20 00 cmp %o0, 0
2027c58: 02 bf ff ee be 2027c10 <scanpw+0x30>
2027c5c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
2027c60: 92 06 60 0c add %i1, 0xc, %o1
2027c64: 94 07 a0 4c add %fp, 0x4c, %o2
2027c68: 96 07 a0 50 add %fp, 0x50, %o3
2027c6c: 7f ff ff 44 call 202797c <scanString>
2027c70: 98 10 20 00 clr %o4
2027c74: 80 a2 20 00 cmp %o0, 0
2027c78: 02 bf ff e6 be 2027c10 <scanpw+0x30> <== NEVER TAKEN
2027c7c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
2027c80: 92 06 60 10 add %i1, 0x10, %o1
2027c84: 94 07 a0 4c add %fp, 0x4c, %o2
2027c88: 96 07 a0 50 add %fp, 0x50, %o3
2027c8c: 7f ff ff 3c call 202797c <scanString>
2027c90: 98 10 20 00 clr %o4
2027c94: 80 a2 20 00 cmp %o0, 0
2027c98: 02 bf ff de be 2027c10 <scanpw+0x30> <== NEVER TAKEN
2027c9c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
2027ca0: 92 06 60 14 add %i1, 0x14, %o1
2027ca4: 94 07 a0 4c add %fp, 0x4c, %o2
2027ca8: 96 07 a0 50 add %fp, 0x50, %o3
2027cac: 7f ff ff 34 call 202797c <scanString>
2027cb0: 98 10 20 00 clr %o4
2027cb4: 80 a2 20 00 cmp %o0, 0
2027cb8: 02 bf ff d6 be 2027c10 <scanpw+0x30> <== NEVER TAKEN
2027cbc: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
2027cc0: 92 06 60 18 add %i1, 0x18, %o1
2027cc4: 94 07 a0 4c add %fp, 0x4c, %o2
2027cc8: 96 07 a0 50 add %fp, 0x50, %o3
2027ccc: 7f ff ff 2c call 202797c <scanString>
2027cd0: 98 10 20 01 mov 1, %o4
2027cd4: 80 a2 20 00 cmp %o0, 0
2027cd8: 02 bf ff ce be 2027c10 <scanpw+0x30>
2027cdc: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
2027ce0: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
2027ce4: c2 07 bf fc ld [ %fp + -4 ], %g1
2027ce8: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
2027cec: 81 c7 e0 08 ret
2027cf0: 91 e8 20 01 restore %g0, 1, %o0
020082a0 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
20082a0: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
20082a4: 80 a6 20 04 cmp %i0, 4
20082a8: 08 80 00 08 bleu 20082c8 <sched_get_priority_max+0x28>
20082ac: 82 10 20 01 mov 1, %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
20082b0: 40 00 23 bc call 20111a0 <__errno>
20082b4: b0 10 3f ff mov -1, %i0
20082b8: 82 10 20 16 mov 0x16, %g1
20082bc: c2 22 00 00 st %g1, [ %o0 ]
20082c0: 81 c7 e0 08 ret
20082c4: 81 e8 00 00 restore
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
20082c8: b1 28 40 18 sll %g1, %i0, %i0
20082cc: 80 8e 20 17 btst 0x17, %i0
20082d0: 02 bf ff f8 be 20082b0 <sched_get_priority_max+0x10> <== NEVER TAKEN
20082d4: 03 00 80 89 sethi %hi(0x2022400), %g1
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
20082d8: f0 08 61 bc ldub [ %g1 + 0x1bc ], %i0 ! 20225bc <rtems_maximum_priority>
}
20082dc: 81 c7 e0 08 ret
20082e0: 91 ee 3f ff restore %i0, -1, %o0
020082e4 <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
20082e4: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
20082e8: 80 a6 20 04 cmp %i0, 4
20082ec: 08 80 00 08 bleu 200830c <sched_get_priority_min+0x28>
20082f0: 82 10 00 18 mov %i0, %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
20082f4: 40 00 23 ab call 20111a0 <__errno>
20082f8: b0 10 3f ff mov -1, %i0
20082fc: 82 10 20 16 mov 0x16, %g1
2008300: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
2008304: 81 c7 e0 08 ret
2008308: 81 e8 00 00 restore
*/
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
200830c: 84 10 20 01 mov 1, %g2
2008310: 83 28 80 01 sll %g2, %g1, %g1
2008314: 80 88 60 17 btst 0x17, %g1
2008318: 02 bf ff f7 be 20082f4 <sched_get_priority_min+0x10> <== NEVER TAKEN
200831c: b0 10 20 01 mov 1, %i0
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
2008320: 81 c7 e0 08 ret
2008324: 81 e8 00 00 restore
02008328 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
2008328: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
200832c: 80 a6 20 00 cmp %i0, 0
2008330: 12 80 00 0a bne 2008358 <sched_rr_get_interval+0x30> <== ALWAYS TAKEN
2008334: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
2008338: 02 80 00 13 be 2008384 <sched_rr_get_interval+0x5c>
200833c: 03 00 80 8c sethi %hi(0x2023000), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
2008340: d0 00 61 b0 ld [ %g1 + 0x1b0 ], %o0 ! 20231b0 <_Thread_Ticks_per_timeslice>
2008344: 92 10 00 19 mov %i1, %o1
2008348: 40 00 0f b8 call 200c228 <_Timespec_From_ticks>
200834c: b0 10 20 00 clr %i0
return 0;
}
2008350: 81 c7 e0 08 ret
2008354: 81 e8 00 00 restore
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
2008358: 7f ff ee 68 call 2003cf8 <getpid>
200835c: 01 00 00 00 nop
2008360: 80 a2 00 18 cmp %o0, %i0
2008364: 02 bf ff f5 be 2008338 <sched_rr_get_interval+0x10>
2008368: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
200836c: 40 00 23 8d call 20111a0 <__errno>
2008370: b0 10 3f ff mov -1, %i0
2008374: 82 10 20 03 mov 3, %g1
2008378: c2 22 00 00 st %g1, [ %o0 ]
200837c: 81 c7 e0 08 ret
2008380: 81 e8 00 00 restore
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
2008384: 40 00 23 87 call 20111a0 <__errno>
2008388: b0 10 3f ff mov -1, %i0
200838c: 82 10 20 16 mov 0x16, %g1
2008390: c2 22 00 00 st %g1, [ %o0 ]
2008394: 81 c7 e0 08 ret
2008398: 81 e8 00 00 restore
02008900 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
2008900: 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)
{
uint32_t level = _Thread_Dispatch_disable_level;
2008904: 03 00 80 8b sethi %hi(0x2022c00), %g1
2008908: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 2022dd0 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
200890c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
2008910: 84 00 a0 01 inc %g2
2008914: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2008918: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
200891c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
2008920: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
2008924: b4 8e 62 00 andcc %i1, 0x200, %i2
2008928: 12 80 00 27 bne 20089c4 <sem_open+0xc4>
200892c: b6 10 20 00 clr %i3
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
2008930: 39 00 80 8c sethi %hi(0x2023000), %i4
2008934: 92 10 00 18 mov %i0, %o1
2008938: 90 17 20 a4 or %i4, 0xa4, %o0
200893c: 94 07 bf f0 add %fp, -16, %o2
2008940: 7f ff fe 5c call 20082b0 <_POSIX_Name_to_id>
2008944: 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 ) {
2008948: ba 92 20 00 orcc %o0, 0, %i5
200894c: 22 80 00 0e be,a 2008984 <sem_open+0x84>
2008950: 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) ) ) {
2008954: 80 a7 60 02 cmp %i5, 2
2008958: 12 80 00 04 bne 2008968 <sem_open+0x68>
200895c: 80 a6 a0 00 cmp %i2, 0
2008960: 12 80 00 1d bne 20089d4 <sem_open+0xd4>
2008964: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
2008968: 40 00 0e aa call 200c410 <_Thread_Enable_dispatch>
200896c: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
2008970: 40 00 26 61 call 20122f4 <__errno>
2008974: 01 00 00 00 nop
2008978: fa 22 00 00 st %i5, [ %o0 ]
200897c: 81 c7 e0 08 ret
2008980: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
2008984: 80 a6 6a 00 cmp %i1, 0xa00
2008988: 02 80 00 1f be 2008a04 <sem_open+0x104>
200898c: d2 07 bf f0 ld [ %fp + -16 ], %o1
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
2008990: 94 07 bf f8 add %fp, -8, %o2
2008994: 40 00 0a 7a call 200b37c <_Objects_Get>
2008998: 90 17 20 a4 or %i4, 0xa4, %o0
_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 );
the_semaphore->open_count += 1;
200899c: 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 );
20089a0: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
20089a4: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
20089a8: 40 00 0e 9a call 200c410 <_Thread_Enable_dispatch>
20089ac: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
20089b0: 40 00 0e 98 call 200c410 <_Thread_Enable_dispatch>
20089b4: 01 00 00 00 nop
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;
20089b8: f0 07 bf f4 ld [ %fp + -12 ], %i0
20089bc: 81 c7 e0 08 ret
20089c0: 91 ee 20 08 restore %i0, 8, %o0
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
20089c4: 82 07 a0 4c add %fp, 0x4c, %g1
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
20089c8: f6 07 a0 50 ld [ %fp + 0x50 ], %i3
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
20089cc: 10 bf ff d9 b 2008930 <sem_open+0x30>
20089d0: c2 27 bf ec st %g1, [ %fp + -20 ]
/*
* 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(
20089d4: 94 10 20 00 clr %o2
20089d8: 96 10 00 1b mov %i3, %o3
20089dc: 98 07 bf f4 add %fp, -12, %o4
20089e0: 40 00 1b 4f call 200f71c <_POSIX_Semaphore_Create_support>
20089e4: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
20089e8: 40 00 0e 8a call 200c410 <_Thread_Enable_dispatch>
20089ec: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
20089f0: 80 a7 7f ff cmp %i5, -1
20089f4: 32 bf ff f2 bne,a 20089bc <sem_open+0xbc> <== ALWAYS TAKEN
20089f8: f0 07 bf f4 ld [ %fp + -12 ], %i0
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
#endif
}
20089fc: 81 c7 e0 08 ret <== NOT EXECUTED
2008a00: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
2008a04: 40 00 0e 83 call 200c410 <_Thread_Enable_dispatch>
2008a08: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
2008a0c: 40 00 26 3a call 20122f4 <__errno>
2008a10: 01 00 00 00 nop
2008a14: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
2008a18: c2 22 00 00 st %g1, [ %o0 ]
2008a1c: 81 c7 e0 08 ret
2008a20: 81 e8 00 00 restore
0200ad48 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
200ad48: 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 );
200ad4c: 90 10 00 19 mov %i1, %o0
200ad50: 40 00 17 47 call 2010a6c <_POSIX_Absolute_timeout_to_ticks>
200ad54: 92 07 bf fc add %fp, -4, %o1
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
200ad58: d4 07 bf fc ld [ %fp + -4 ], %o2
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
200ad5c: 80 a2 20 03 cmp %o0, 3
200ad60: 02 80 00 06 be 200ad78 <sem_timedwait+0x30> <== ALWAYS TAKEN
200ad64: 90 10 00 18 mov %i0, %o0
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
200ad68: 40 00 1a 41 call 201166c <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
200ad6c: 92 10 20 00 clr %o1 <== NOT EXECUTED
200ad70: 81 c7 e0 08 ret <== NOT EXECUTED
200ad74: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
200ad78: 40 00 1a 3d call 201166c <_POSIX_Semaphore_Wait_support>
200ad7c: 92 10 20 01 mov 1, %o1
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
200ad80: 81 c7 e0 08 ret
200ad84: 91 e8 00 08 restore %g0, %o0, %o0
02008254 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
2008254: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
2008258: 80 a6 a0 00 cmp %i2, 0
200825c: 02 80 00 0d be 2008290 <sigaction+0x3c>
2008260: 87 2e 20 02 sll %i0, 2, %g3
*oact = _POSIX_signals_Vectors[ sig ];
2008264: 05 00 80 87 sethi %hi(0x2021c00), %g2
2008268: 83 2e 20 04 sll %i0, 4, %g1
200826c: 84 10 a3 10 or %g2, 0x310, %g2
2008270: 82 20 40 03 sub %g1, %g3, %g1
2008274: c6 00 80 01 ld [ %g2 + %g1 ], %g3
2008278: 82 00 80 01 add %g2, %g1, %g1
200827c: c6 26 80 00 st %g3, [ %i2 ]
2008280: c4 00 60 04 ld [ %g1 + 4 ], %g2
2008284: c4 26 a0 04 st %g2, [ %i2 + 4 ]
2008288: c2 00 60 08 ld [ %g1 + 8 ], %g1
200828c: c2 26 a0 08 st %g1, [ %i2 + 8 ]
if ( !sig )
2008290: 80 a6 20 00 cmp %i0, 0
2008294: 02 80 00 33 be 2008360 <sigaction+0x10c>
2008298: 01 00 00 00 nop
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
200829c: 82 06 3f ff add %i0, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
20082a0: 80 a0 60 1f cmp %g1, 0x1f
20082a4: 18 80 00 2f bgu 2008360 <sigaction+0x10c>
20082a8: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
20082ac: 02 80 00 2d be 2008360 <sigaction+0x10c>
20082b0: 80 a6 60 00 cmp %i1, 0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
20082b4: 02 80 00 1a be 200831c <sigaction+0xc8> <== NEVER TAKEN
20082b8: 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 );
20082bc: 7f ff e9 c0 call 20029bc <sparc_disable_interrupts>
20082c0: 01 00 00 00 nop
20082c4: ba 10 00 08 mov %o0, %i5
if ( act->sa_handler == SIG_DFL ) {
20082c8: c2 06 60 08 ld [ %i1 + 8 ], %g1
20082cc: 80 a0 60 00 cmp %g1, 0
20082d0: 02 80 00 15 be 2008324 <sigaction+0xd0>
20082d4: 83 2e 20 02 sll %i0, 2, %g1
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
20082d8: 40 00 18 98 call 200e538 <_POSIX_signals_Clear_process_signals>
20082dc: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
20082e0: c4 06 40 00 ld [ %i1 ], %g2
20082e4: 87 2e 20 02 sll %i0, 2, %g3
20082e8: 03 00 80 87 sethi %hi(0x2021c00), %g1
20082ec: b1 2e 20 04 sll %i0, 4, %i0
20082f0: 82 10 63 10 or %g1, 0x310, %g1
20082f4: b0 26 00 03 sub %i0, %g3, %i0
20082f8: c4 20 40 18 st %g2, [ %g1 + %i0 ]
20082fc: c4 06 60 04 ld [ %i1 + 4 ], %g2
2008300: b0 00 40 18 add %g1, %i0, %i0
2008304: c4 26 20 04 st %g2, [ %i0 + 4 ]
2008308: c2 06 60 08 ld [ %i1 + 8 ], %g1
200830c: c2 26 20 08 st %g1, [ %i0 + 8 ]
}
_ISR_Enable( level );
2008310: 7f ff e9 af call 20029cc <sparc_enable_interrupts>
2008314: 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;
2008318: 82 10 20 00 clr %g1
}
200831c: 81 c7 e0 08 ret
2008320: 91 e8 00 01 restore %g0, %g1, %o0
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
2008324: b1 2e 20 04 sll %i0, 4, %i0
2008328: b0 26 00 01 sub %i0, %g1, %i0
200832c: 03 00 80 7e sethi %hi(0x201f800), %g1
2008330: 82 10 62 9c or %g1, 0x29c, %g1 ! 201fa9c <_POSIX_signals_Default_vectors>
2008334: c8 00 40 18 ld [ %g1 + %i0 ], %g4
2008338: 82 00 40 18 add %g1, %i0, %g1
200833c: c6 00 60 04 ld [ %g1 + 4 ], %g3
2008340: c4 00 60 08 ld [ %g1 + 8 ], %g2
2008344: 03 00 80 87 sethi %hi(0x2021c00), %g1
2008348: 82 10 63 10 or %g1, 0x310, %g1 ! 2021f10 <_POSIX_signals_Vectors>
200834c: c8 20 40 18 st %g4, [ %g1 + %i0 ]
2008350: b0 00 40 18 add %g1, %i0, %i0
2008354: c6 26 20 04 st %g3, [ %i0 + 4 ]
2008358: 10 bf ff ee b 2008310 <sigaction+0xbc>
200835c: c4 26 20 08 st %g2, [ %i0 + 8 ]
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
2008360: 40 00 24 a6 call 20115f8 <__errno>
2008364: 01 00 00 00 nop
2008368: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
200836c: 82 10 3f ff mov -1, %g1
2008370: 10 bf ff eb b 200831c <sigaction+0xc8>
2008374: c4 22 00 00 st %g2, [ %o0 ]
020087e4 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
20087e4: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
20087e8: ba 96 20 00 orcc %i0, 0, %i5
20087ec: 02 80 00 83 be 20089f8 <sigtimedwait+0x214>
20087f0: 80 a6 a0 00 cmp %i2, 0
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
20087f4: 02 80 00 5b be 2008960 <sigtimedwait+0x17c>
20087f8: 80 a6 60 00 cmp %i1, 0
if ( !_Timespec_Is_valid( timeout ) )
20087fc: 40 00 0f fc call 200c7ec <_Timespec_Is_valid>
2008800: 90 10 00 1a mov %i2, %o0
2008804: 80 8a 20 ff btst 0xff, %o0
2008808: 02 80 00 7c be 20089f8 <sigtimedwait+0x214>
200880c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
2008810: 40 00 10 0a call 200c838 <_Timespec_To_ticks>
2008814: 90 10 00 1a mov %i2, %o0
if ( !interval )
2008818: b0 92 20 00 orcc %o0, 0, %i0
200881c: 02 80 00 77 be 20089f8 <sigtimedwait+0x214> <== NEVER TAKEN
2008820: 80 a6 60 00 cmp %i1, 0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
2008824: 02 80 00 52 be 200896c <sigtimedwait+0x188> <== NEVER TAKEN
2008828: 35 00 80 88 sethi %hi(0x2022000), %i2
the_thread = _Thread_Executing;
200882c: 35 00 80 88 sethi %hi(0x2022000), %i2
2008830: b4 16 a3 d0 or %i2, 0x3d0, %i2 ! 20223d0 <_Per_CPU_Information>
2008834: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
2008838: 7f ff e9 3c call 2002d28 <sparc_disable_interrupts>
200883c: f6 07 21 5c ld [ %i4 + 0x15c ], %i3
2008840: a0 10 00 08 mov %o0, %l0
if ( *set & api->signals_pending ) {
2008844: c2 07 40 00 ld [ %i5 ], %g1
2008848: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2
200884c: 80 88 40 02 btst %g1, %g2
2008850: 12 80 00 52 bne 2008998 <sigtimedwait+0x1b4>
2008854: 01 00 00 00 nop
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
2008858: 05 00 80 89 sethi %hi(0x2022400), %g2
200885c: c4 00 a2 24 ld [ %g2 + 0x224 ], %g2 ! 2022624 <_POSIX_signals_Pending>
2008860: 80 88 40 02 btst %g1, %g2
2008864: 12 80 00 2e bne 200891c <sigtimedwait+0x138>
2008868: 03 00 80 87 sethi %hi(0x2021c00), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200886c: c4 00 62 b0 ld [ %g1 + 0x2b0 ], %g2 ! 2021eb0 <_Thread_Dispatch_disable_level>
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
2008870: 86 10 3f ff mov -1, %g3
2008874: c6 26 40 00 st %g3, [ %i1 ]
++level;
2008878: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
200887c: c4 20 62 b0 st %g2, [ %g1 + 0x2b0 ]
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
2008880: 82 10 20 04 mov 4, %g1
2008884: c2 27 20 34 st %g1, [ %i4 + 0x34 ]
the_thread->Wait.option = *set;
2008888: c2 07 40 00 ld [ %i5 ], %g1
the_thread->Wait.return_argument = the_info;
200888c: f2 27 20 28 st %i1, [ %i4 + 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;
2008890: c2 27 20 30 st %g1, [ %i4 + 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;
2008894: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
2008898: 21 00 80 89 sethi %hi(0x2022400), %l0
200889c: a0 14 21 bc or %l0, 0x1bc, %l0 ! 20225bc <_POSIX_signals_Wait_queue>
20088a0: e0 27 20 44 st %l0, [ %i4 + 0x44 ]
20088a4: e2 24 20 30 st %l1, [ %l0 + 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 );
20088a8: 7f ff e9 24 call 2002d38 <sparc_enable_interrupts>
20088ac: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
20088b0: 90 10 00 10 mov %l0, %o0
20088b4: 92 10 00 18 mov %i0, %o1
20088b8: 15 00 80 31 sethi %hi(0x200c400), %o2
20088bc: 40 00 0e 59 call 200c220 <_Thread_queue_Enqueue_with_handler>
20088c0: 94 12 a2 00 or %o2, 0x200, %o2 ! 200c600 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
20088c4: 40 00 0d 06 call 200bcdc <_Thread_Enable_dispatch>
20088c8: 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 );
20088cc: d2 06 40 00 ld [ %i1 ], %o1
20088d0: 90 10 00 1b mov %i3, %o0
20088d4: 94 10 00 19 mov %i1, %o2
20088d8: 96 10 20 00 clr %o3
20088dc: 40 00 19 54 call 200ee2c <_POSIX_signals_Clear_signals>
20088e0: 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)
20088e4: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
20088e8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20088ec: 80 a0 60 04 cmp %g1, 4
20088f0: 12 80 00 3b bne 20089dc <sigtimedwait+0x1f8>
20088f4: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
20088f8: f0 06 40 00 ld [ %i1 ], %i0
20088fc: c2 07 40 00 ld [ %i5 ], %g1
2008900: 84 06 3f ff add %i0, -1, %g2
2008904: a3 2c 40 02 sll %l1, %g2, %l1
2008908: 80 8c 40 01 btst %l1, %g1
200890c: 02 80 00 34 be 20089dc <sigtimedwait+0x1f8>
2008910: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
2008914: 81 c7 e0 08 ret
2008918: 81 e8 00 00 restore
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
200891c: 7f ff ff 9a call 2008784 <_POSIX_signals_Get_lowest>
2008920: 90 10 00 02 mov %g2, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
2008924: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008928: b0 10 00 08 mov %o0, %i0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
200892c: 96 10 20 01 mov 1, %o3
2008930: 90 10 00 1b mov %i3, %o0
2008934: 92 10 00 18 mov %i0, %o1
2008938: 40 00 19 3d call 200ee2c <_POSIX_signals_Clear_signals>
200893c: 98 10 20 00 clr %o4
_ISR_Enable( level );
2008940: 7f ff e8 fe call 2002d38 <sparc_enable_interrupts>
2008944: 90 10 00 10 mov %l0, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
2008948: 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;
200894c: f0 26 40 00 st %i0, [ %i1 ]
the_info->si_code = SI_USER;
2008950: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
2008954: c0 26 60 08 clr [ %i1 + 8 ]
2008958: 81 c7 e0 08 ret
200895c: 81 e8 00 00 restore
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
2008960: 12 bf ff b3 bne 200882c <sigtimedwait+0x48>
2008964: b0 10 20 00 clr %i0
the_thread = _Thread_Executing;
2008968: 35 00 80 88 sethi %hi(0x2022000), %i2
200896c: b4 16 a3 d0 or %i2, 0x3d0, %i2 ! 20223d0 <_Per_CPU_Information>
2008970: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
2008974: b2 07 bf f4 add %fp, -12, %i1
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
2008978: 7f ff e8 ec call 2002d28 <sparc_disable_interrupts>
200897c: f6 07 21 5c ld [ %i4 + 0x15c ], %i3
2008980: a0 10 00 08 mov %o0, %l0
if ( *set & api->signals_pending ) {
2008984: c2 07 40 00 ld [ %i5 ], %g1
2008988: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2
200898c: 80 88 40 02 btst %g1, %g2
2008990: 22 bf ff b3 be,a 200885c <sigtimedwait+0x78>
2008994: 05 00 80 89 sethi %hi(0x2022400), %g2
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
2008998: 7f ff ff 7b call 2008784 <_POSIX_signals_Get_lowest>
200899c: 90 10 00 02 mov %g2, %o0
_POSIX_signals_Clear_signals(
20089a0: 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 );
20089a4: 92 10 00 08 mov %o0, %o1
20089a8: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
20089ac: 96 10 20 00 clr %o3
20089b0: 90 10 00 1b mov %i3, %o0
20089b4: 40 00 19 1e call 200ee2c <_POSIX_signals_Clear_signals>
20089b8: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
20089bc: 7f ff e8 df call 2002d38 <sparc_enable_interrupts>
20089c0: 90 10 00 10 mov %l0, %o0
the_info->si_code = SI_USER;
20089c4: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
20089c8: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
20089cc: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
20089d0: f0 06 40 00 ld [ %i1 ], %i0
20089d4: 81 c7 e0 08 ret
20089d8: 81 e8 00 00 restore
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
20089dc: 40 00 24 e9 call 2011d80 <__errno>
20089e0: b0 10 3f ff mov -1, %i0
20089e4: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
20089e8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20089ec: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
return the_info->si_signo;
}
20089f0: 81 c7 e0 08 ret
20089f4: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
20089f8: 40 00 24 e2 call 2011d80 <__errno>
20089fc: b0 10 3f ff mov -1, %i0
2008a00: 82 10 20 16 mov 0x16, %g1
2008a04: c2 22 00 00 st %g1, [ %o0 ]
2008a08: 81 c7 e0 08 ret
2008a0c: 81 e8 00 00 restore
0200a610 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
200a610: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
200a614: 92 10 20 00 clr %o1
200a618: 90 10 00 18 mov %i0, %o0
200a61c: 7f ff ff 6e call 200a3d4 <sigtimedwait>
200a620: 94 10 20 00 clr %o2
if ( status != -1 ) {
200a624: 80 a2 3f ff cmp %o0, -1
200a628: 02 80 00 07 be 200a644 <sigwait+0x34>
200a62c: 80 a6 60 00 cmp %i1, 0
if ( sig )
200a630: 02 80 00 0a be 200a658 <sigwait+0x48> <== NEVER TAKEN
200a634: 01 00 00 00 nop
*sig = status;
200a638: d0 26 40 00 st %o0, [ %i1 ]
return 0;
200a63c: 81 c7 e0 08 ret
200a640: 91 e8 20 00 restore %g0, 0, %o0
}
return errno;
200a644: 40 00 24 02 call 201364c <__errno>
200a648: 01 00 00 00 nop
200a64c: f0 02 00 00 ld [ %o0 ], %i0
200a650: 81 c7 e0 08 ret
200a654: 81 e8 00 00 restore
}
200a658: 81 c7 e0 08 ret <== NOT EXECUTED
200a65c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02006634 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
2006634: 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)) {
2006638: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
200663c: 80 88 6e 78 btst 0xe78, %g1
2006640: 32 80 00 04 bne,a 2006650 <siproc+0x1c> <== ALWAYS TAKEN
2006644: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
2006648: 7f ff ff 64 call 20063d8 <iproc> <== NOT EXECUTED
200664c: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2006650: 94 10 20 00 clr %o2
2006654: 40 00 05 43 call 2007b60 <rtems_semaphore_obtain>
2006658: 92 10 20 00 clr %o1
i = iproc (c, tty);
200665c: 90 10 00 18 mov %i0, %o0
2006660: 7f ff ff 5e call 20063d8 <iproc>
2006664: 92 10 00 19 mov %i1, %o1
2006668: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
200666c: 40 00 05 8c call 2007c9c <rtems_semaphore_release>
2006670: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
2006674: 81 c7 e0 08 ret
2006678: 81 e8 00 00 restore
0200f6c4 <sparse_disk_ioctl>:
/*
* ioctl handler to be passed to the block device handler
*/
static int sparse_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
{
200f6c4: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
200f6c8: 03 30 06 10 sethi %hi(0xc0184000), %g1
200f6cc: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
200f6d0: 80 a6 40 01 cmp %i1, %g1
200f6d4: 02 80 00 23 be 200f760 <sparse_disk_ioctl+0x9c>
200f6d8: f6 06 20 3c ld [ %i0 + 0x3c ], %i3
case RTEMS_BLKDEV_REQ_WRITE:
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
200f6dc: 03 08 00 10 sethi %hi(0x20004000), %g1
200f6e0: 82 10 62 07 or %g1, 0x207, %g1 ! 20004207 <RAM_END+0x1dc04207>
200f6e4: 80 a6 40 01 cmp %i1, %g1
200f6e8: 02 80 00 07 be 200f704 <sparse_disk_ioctl+0x40>
200f6ec: 90 10 00 18 mov %i0, %o0
if ( NULL != sd->delete_handler )
( *sd->delete_handler )( sd );
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
200f6f0: 92 10 00 19 mov %i1, %o1
200f6f4: 40 00 0c ab call 20129a0 <rtems_blkdev_ioctl>
200f6f8: 94 10 00 1a mov %i2, %o2
200f6fc: 81 c7 e0 08 ret
200f700: 91 e8 00 08 restore %g0, %o0, %o0
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
sc = rtems_semaphore_delete( sd->mutex );
200f704: 7f ff e9 64 call 2009c94 <rtems_semaphore_delete>
200f708: d0 06 c0 00 ld [ %i3 ], %o0
if ( RTEMS_SUCCESSFUL != sc )
200f70c: 80 a2 20 00 cmp %o0, 0
200f710: 12 80 00 a0 bne 200f990 <sparse_disk_ioctl+0x2cc> <== NEVER TAKEN
200f714: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
200f718: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
200f71c: c0 26 c0 00 clr [ %i3 ]
if ( NULL != sd->delete_handler )
200f720: 80 a0 60 00 cmp %g1, 0
200f724: 02 80 00 04 be 200f734 <sparse_disk_ioctl+0x70> <== NEVER TAKEN
200f728: b0 10 20 00 clr %i0
( *sd->delete_handler )( sd );
200f72c: 9f c0 40 00 call %g1
200f730: 90 10 00 1b mov %i3, %o0
200f734: 81 c7 e0 08 ret
200f738: 81 e8 00 00 restore
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
200f73c: d0 06 c0 00 ld [ %i3 ], %o0
200f740: 7f ff e9 db call 2009eac <rtems_semaphore_release>
200f744: b0 10 20 00 clr %i0
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
200f748: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200f74c: 90 10 00 1a mov %i2, %o0
200f750: 9f c0 40 00 call %g1
200f754: 92 10 20 00 clr %o1
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
return -1;
}
200f758: 81 c7 e0 08 ret
200f75c: 81 e8 00 00 restore
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
rtems_blkdev_request *r = argp;
switch ( r->req ) {
200f760: e6 06 80 00 ld [ %i2 ], %l3
200f764: 80 a4 e0 01 cmp %l3, 1
200f768: 18 80 00 84 bgu 200f978 <sparse_disk_ioctl+0x2b4> <== NEVER TAKEN
200f76c: 92 10 20 00 clr %o1
rtems_blkdev_bnum block;
uint8_t *buff;
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200f770: d0 06 c0 00 ld [ %i3 ], %o0
200f774: 7f ff e9 7f call 2009d70 <rtems_semaphore_obtain>
200f778: 94 10 20 00 clr %o2
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
200f77c: 25 00 80 3d sethi %hi(0x200f400), %l2
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
200f780: a8 10 20 00 clr %l4
static int sparse_disk_read_write(
rtems_sparse_disk *sparse_disk,
rtems_blkdev_request *req,
const bool read )
{
int rv = 0;
200f784: 84 10 20 00 clr %g2
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
200f788: a4 14 a2 9c or %l2, 0x29c, %l2
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
200f78c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
200f790: 80 a0 40 14 cmp %g1, %l4
200f794: 08 bf ff ea bleu 200f73c <sparse_disk_ioctl+0x78>
200f798: 87 2d 20 04 sll %l4, 4, %g3
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
200f79c: 80 a0 a0 00 cmp %g2, 0
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
200f7a0: 86 00 e0 18 add %g3, 0x18, %g3
200f7a4: 82 06 80 03 add %i2, %g3, %g1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
200f7a8: f2 06 80 03 ld [ %i2 + %g3 ], %i1
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
200f7ac: e2 00 60 08 ld [ %g1 + 8 ], %l1
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
200f7b0: 06 80 00 40 bl 200f8b0 <sparse_disk_ioctl+0x1ec> <== NEVER TAKEN
200f7b4: f8 00 60 04 ld [ %g1 + 4 ], %i4
200f7b8: 80 a7 20 00 cmp %i4, 0
200f7bc: 02 80 00 3d be 200f8b0 <sparse_disk_ioctl+0x1ec> <== NEVER TAKEN
200f7c0: b0 10 20 00 clr %i0
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
200f7c4: 10 80 00 1d b 200f838 <sparse_disk_ioctl+0x174>
200f7c8: f2 27 bf f8 st %i1, [ %fp + -8 ]
200f7cc: 80 a7 00 01 cmp %i4, %g1
200f7d0: 38 80 00 02 bgu,a 200f7d8 <sparse_disk_ioctl+0x114>
200f7d4: ba 10 00 01 mov %g1, %i5
size_t bytes_to_copy = sparse_disk->media_block_size;
if ( buffer_size < bytes_to_copy )
bytes_to_copy = buffer_size;
key = bsearch(
200f7d8: d2 06 e0 18 ld [ %i3 + 0x18 ], %o1
200f7dc: d4 06 e0 08 ld [ %i3 + 8 ], %o2
200f7e0: 90 07 bf f8 add %fp, -8, %o0
200f7e4: 96 10 20 08 mov 8, %o3
200f7e8: 40 00 36 17 call 201d044 <bsearch>
200f7ec: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
200f7f0: 80 a2 20 00 cmp %o0, 0
200f7f4: 02 80 00 29 be 200f898 <sparse_disk_ioctl+0x1d4>
200f7f8: 94 10 00 1d mov %i5, %o2
memcpy( buffer, key->data, bytes_to_copy );
200f7fc: d2 02 20 04 ld [ %o0 + 4 ], %o1
200f800: 40 00 38 f2 call 201dbc8 <memcpy>
200f804: 90 10 00 10 mov %l0, %o0
200f808: b8 27 00 1d sub %i4, %i5, %i4
200f80c: 82 38 00 1d xnor %g0, %i5, %g1
200f810: 80 a0 00 1c cmp %g0, %i4
200f814: 83 30 60 1f srl %g1, 0x1f, %g1
200f818: 86 40 20 00 addx %g0, 0, %g3
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
else if ( block_needs_writing )
return -1;
return bytes_to_copy;
200f81c: 84 10 00 1d mov %i5, %g2
200f820: 82 08 c0 01 and %g3, %g1, %g1
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
200f824: b2 06 60 01 inc %i1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
200f828: 80 88 60 ff btst 0xff, %g1
200f82c: 02 80 00 21 be 200f8b0 <sparse_disk_ioctl+0x1ec>
200f830: b0 06 00 1d add %i0, %i5, %i0
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
200f834: f2 27 bf f8 st %i1, [ %fp + -8 ]
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
200f838: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
200f83c: c0 27 bf fc clr [ %fp + -4 ]
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
rv = sparse_disk_read_block( sparse_disk,
200f840: a0 04 40 18 add %l1, %i0, %l0
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
200f844: 80 a4 e0 00 cmp %l3, 0
200f848: 02 bf ff e1 be 200f7cc <sparse_disk_ioctl+0x108>
200f84c: ba 10 00 1c mov %i4, %i5
200f850: 80 a7 00 01 cmp %i4, %g1
200f854: 38 80 00 02 bgu,a 200f85c <sparse_disk_ioctl+0x198>
200f858: ba 10 00 01 mov %g1, %i5
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
200f85c: d2 06 e0 18 ld [ %i3 + 0x18 ], %o1
200f860: d4 06 e0 08 ld [ %i3 + 8 ], %o2
200f864: 90 07 bf f8 add %fp, -8, %o0
200f868: 96 10 20 08 mov 8, %o3
200f86c: 40 00 35 f6 call 201d044 <bsearch>
200f870: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
200f874: aa 92 20 00 orcc %o0, 0, %l5
200f878: 02 80 00 1a be 200f8e0 <sparse_disk_ioctl+0x21c>
200f87c: 80 a7 60 00 cmp %i5, 0
key = sparse_disk_get_new_block( sparse_disk, block );
}
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
200f880: d0 05 60 04 ld [ %l5 + 4 ], %o0
200f884: 92 10 00 10 mov %l0, %o1
200f888: 40 00 38 d0 call 201dbc8 <memcpy>
200f88c: 94 10 00 1d mov %i5, %o2
200f890: 10 bf ff df b 200f80c <sparse_disk_ioctl+0x148>
200f894: b8 27 00 1d sub %i4, %i5, %i4
);
if ( NULL != key )
memcpy( buffer, key->data, bytes_to_copy );
else
memset( buffer, sparse_disk->fill_pattern, buffer_size );
200f898: d2 0e e0 14 ldub [ %i3 + 0x14 ], %o1
200f89c: 90 10 00 10 mov %l0, %o0
200f8a0: 40 00 39 07 call 201dcbc <memset>
200f8a4: 94 10 00 1c mov %i4, %o2
200f8a8: 10 bf ff d9 b 200f80c <sparse_disk_ioctl+0x148>
200f8ac: b8 27 00 1d sub %i4, %i5, %i4
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
200f8b0: 80 a0 a0 00 cmp %g2, 0
200f8b4: 16 bf ff b6 bge 200f78c <sparse_disk_ioctl+0xc8> <== ALWAYS TAKEN
200f8b8: a8 05 20 01 inc %l4
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
200f8bc: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
200f8c0: 7f ff e9 7b call 2009eac <rtems_semaphore_release> <== NOT EXECUTED
200f8c4: b0 10 20 00 clr %i0 <== NOT EXECUTED
200f8c8: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
200f8cc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
200f8d0: 9f c0 40 00 call %g1 <== NOT EXECUTED
200f8d4: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
200f8d8: 81 c7 e0 08 ret <== NOT EXECUTED
200f8dc: 81 e8 00 00 restore <== NOT EXECUTED
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
200f8e0: 02 bf ff ca be 200f808 <sparse_disk_ioctl+0x144> <== NEVER TAKEN
200f8e4: 82 10 20 00 clr %g1
200f8e8: 10 80 00 05 b 200f8fc <sparse_disk_ioctl+0x238>
200f8ec: c8 0e e0 14 ldub [ %i3 + 0x14 ], %g4
200f8f0: 80 a0 40 1d cmp %g1, %i5
200f8f4: 1a 80 00 0b bcc 200f920 <sparse_disk_ioctl+0x25c>
200f8f8: 80 88 e0 ff btst 0xff, %g3
if ( buffer[i] != sparse_disk->fill_pattern )
200f8fc: c4 0c 00 01 ldub [ %l0 + %g1 ], %g2
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
200f900: 82 00 60 01 inc %g1
if ( buffer[i] != sparse_disk->fill_pattern )
200f904: 84 18 80 04 xor %g2, %g4, %g2
200f908: 80 a0 00 02 cmp %g0, %g2
200f90c: 84 40 20 00 addx %g0, 0, %g2
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
200f910: 80 a0 a0 00 cmp %g2, 0
200f914: 02 bf ff f7 be 200f8f0 <sparse_disk_ioctl+0x22c>
200f918: 86 10 00 02 mov %g2, %g3
if ( buffer[i] != sparse_disk->fill_pattern )
block_needs_writing = true;
}
if ( block_needs_writing ) {
200f91c: 80 88 e0 ff btst 0xff, %g3
200f920: 22 bf ff bb be,a 200f80c <sparse_disk_ioctl+0x148>
200f924: b8 27 00 1d sub %i4, %i5, %i4
rtems_sparse_disk *sparse_disk,
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
200f928: c2 06 e0 08 ld [ %i3 + 8 ], %g1
200f92c: c4 06 e0 04 ld [ %i3 + 4 ], %g2
200f930: 80 a0 40 02 cmp %g1, %g2
200f934: 1a 80 00 0c bcc 200f964 <sparse_disk_ioctl+0x2a0> <== NEVER TAKEN
200f938: ab 28 60 03 sll %g1, 3, %l5
key = &sparse_disk->key_table[sparse_disk->used_count];
200f93c: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0
key->block = block;
200f940: f2 22 00 15 st %i1, [ %o0 + %l5 ]
++sparse_disk->used_count;
200f944: 92 00 60 01 add %g1, 1, %o1
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
key = &sparse_disk->key_table[sparse_disk->used_count];
200f948: aa 02 00 15 add %o0, %l5, %l5
key->block = block;
++sparse_disk->used_count;
200f94c: d2 26 e0 08 st %o1, [ %i3 + 8 ]
qsort( sparse_disk->key_table, sparse_disk->used_count,
200f950: 94 10 20 08 mov 8, %o2
200f954: 40 00 39 20 call 201ddd4 <qsort>
200f958: 96 10 00 12 mov %l2, %o3
key = sparse_disk_get_new_block( sparse_disk, block );
}
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
200f95c: 10 bf ff ca b 200f884 <sparse_disk_ioctl+0x1c0>
200f960: d0 05 60 04 ld [ %l5 + 4 ], %o0
200f964: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_sparse_disk *sparse_disk,
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
200f968: 82 10 20 00 clr %g1 <== NOT EXECUTED
200f96c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
else if ( block_needs_writing )
return -1;
200f970: 10 bf ff ad b 200f824 <sparse_disk_ioctl+0x160> <== NOT EXECUTED
200f974: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
200f978: 40 00 35 d5 call 201d0cc <__errno> <== NOT EXECUTED
200f97c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200f980: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200f984: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
200f988: 81 c7 e0 08 ret <== NOT EXECUTED
200f98c: 81 e8 00 00 restore <== NOT EXECUTED
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
200f990: 7f ff ea eb call 200a53c <rtems_fatal_error_occurred> <== NOT EXECUTED
200f994: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
02005ff8 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
2005ff8: 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;
2005ffc: c2 06 21 54 ld [ %i0 + 0x154 ], %g1
if ( this_reent ) {
2006000: 80 a0 60 00 cmp %g1, 0
2006004: 02 80 00 0c be 2006034 <sync_per_thread+0x3c> <== NEVER TAKEN
2006008: 3b 00 80 80 sethi %hi(0x2020000), %i5
current_reent = _Thread_Executing->libc_reent;
200600c: ba 17 62 50 or %i5, 0x250, %i5 ! 2020250 <_Per_CPU_Information>
2006010: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
2006014: 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;
2006018: f8 00 a1 54 ld [ %g2 + 0x154 ], %i4
_Thread_Executing->libc_reent = this_reent;
200601c: c2 20 a1 54 st %g1, [ %g2 + 0x154 ]
_fwalk (t->libc_reent, sync_wrapper);
2006020: d0 06 21 54 ld [ %i0 + 0x154 ], %o0
2006024: 40 00 30 91 call 2012268 <_fwalk>
2006028: 92 12 60 3c or %o1, 0x3c, %o1
_Thread_Executing->libc_reent = current_reent;
200602c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2006030: f8 20 61 54 st %i4, [ %g1 + 0x154 ]
2006034: 81 c7 e0 08 ret
2006038: 81 e8 00 00 restore
0200748c <sysconf>:
*/
long sysconf(
int name
)
{
200748c: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
2007490: 80 a6 20 02 cmp %i0, 2
2007494: 02 80 00 12 be 20074dc <sysconf+0x50>
2007498: 82 10 00 18 mov %i0, %g1
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
200749c: 80 a6 20 04 cmp %i0, 4
20074a0: 02 80 00 16 be 20074f8 <sysconf+0x6c>
20074a4: 80 a0 60 33 cmp %g1, 0x33
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
20074a8: 02 80 00 0b be 20074d4 <sysconf+0x48>
20074ac: b0 10 24 00 mov 0x400, %i0
return 1024;
if ( name == _SC_PAGESIZE )
20074b0: 80 a0 60 08 cmp %g1, 8
20074b4: 02 80 00 08 be 20074d4 <sysconf+0x48>
20074b8: 31 00 00 04 sethi %hi(0x1000), %i0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
20074bc: 80 a0 60 4f cmp %g1, 0x4f
20074c0: 02 80 00 05 be 20074d4 <sysconf+0x48> <== NEVER TAKEN
20074c4: b0 10 20 20 mov 0x20, %i0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
20074c8: 80 a0 62 03 cmp %g1, 0x203
20074cc: 12 80 00 0f bne 2007508 <sysconf+0x7c> <== ALWAYS TAKEN
20074d0: b0 10 20 00 clr %i0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
20074d4: 81 c7 e0 08 ret
20074d8: 81 e8 00 00 restore
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
20074dc: 03 00 80 6e sethi %hi(0x201b800), %g1
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
20074e0: d2 00 61 b4 ld [ %g1 + 0x1b4 ], %o1 ! 201b9b4 <Configuration+0xc>
20074e4: 11 00 03 d0 sethi %hi(0xf4000), %o0
20074e8: 40 00 48 24 call 2019578 <.udiv>
20074ec: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
20074f0: 81 c7 e0 08 ret
20074f4: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
20074f8: 03 00 80 76 sethi %hi(0x201d800), %g1
20074fc: f0 00 63 58 ld [ %g1 + 0x358 ], %i0 ! 201db58 <rtems_libio_number_iops>
2007500: 81 c7 e0 08 ret
2007504: 81 e8 00 00 restore
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
2007508: 40 00 24 9f call 2010784 <__errno>
200750c: b0 10 3f ff mov -1, %i0
2007510: 82 10 20 16 mov 0x16, %g1
2007514: c2 22 00 00 st %g1, [ %o0 ]
}
2007518: 81 c7 e0 08 ret
200751c: 81 e8 00 00 restore
020164f4 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
20164f4: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
20164f8: 80 a6 60 00 cmp %i1, 0
20164fc: 02 80 00 10 be 201653c <tcsetattr+0x48>
2016500: 80 a6 60 01 cmp %i1, 1
2016504: 02 80 00 08 be 2016524 <tcsetattr+0x30>
2016508: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
201650c: 40 00 12 37 call 201ade8 <__errno>
2016510: 01 00 00 00 nop
2016514: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
2016518: c2 22 00 00 st %g1, [ %o0 ]
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
201651c: 81 c7 e0 08 ret
2016520: 91 e8 3f ff restore %g0, -1, %o0
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
2016524: 92 10 20 03 mov 3, %o1
2016528: 40 00 0e f7 call 201a104 <ioctl>
201652c: 94 10 20 00 clr %o2
2016530: 80 a2 20 00 cmp %o0, 0
2016534: 06 bf ff fa bl 201651c <tcsetattr+0x28> <== NEVER TAKEN
2016538: 01 00 00 00 nop
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
201653c: 40 00 0e f2 call 201a104 <ioctl>
2016540: 93 e8 20 02 restore %g0, 2, %o1
02008a24 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
2008a24: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
2008a28: 80 a6 20 01 cmp %i0, 1
2008a2c: 12 80 00 3d bne 2008b20 <timer_create+0xfc>
2008a30: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
2008a34: 02 80 00 3b be 2008b20 <timer_create+0xfc>
2008a38: 80 a6 60 00 cmp %i1, 0
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
2008a3c: 02 80 00 0e be 2008a74 <timer_create+0x50>
2008a40: 03 00 80 8b sethi %hi(0x2022c00), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
2008a44: c2 06 40 00 ld [ %i1 ], %g1
2008a48: 82 00 7f ff add %g1, -1, %g1
2008a4c: 80 a0 60 01 cmp %g1, 1
2008a50: 18 80 00 34 bgu 2008b20 <timer_create+0xfc> <== NEVER TAKEN
2008a54: 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 )
2008a58: c2 06 60 04 ld [ %i1 + 4 ], %g1
2008a5c: 80 a0 60 00 cmp %g1, 0
2008a60: 02 80 00 30 be 2008b20 <timer_create+0xfc> <== NEVER TAKEN
2008a64: 82 00 7f ff add %g1, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
2008a68: 80 a0 60 1f cmp %g1, 0x1f
2008a6c: 18 80 00 2d bgu 2008b20 <timer_create+0xfc> <== NEVER TAKEN
2008a70: 03 00 80 8b sethi %hi(0x2022c00), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2008a74: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 2022dd0 <_Thread_Dispatch_disable_level>
++level;
2008a78: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2008a7c: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
* 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 );
2008a80: 3b 00 80 8c sethi %hi(0x2023000), %i5
2008a84: 40 00 08 e0 call 200ae04 <_Objects_Allocate>
2008a88: 90 17 60 e4 or %i5, 0xe4, %o0 ! 20230e4 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
2008a8c: 80 a2 20 00 cmp %o0, 0
2008a90: 02 80 00 2a be 2008b38 <timer_create+0x114>
2008a94: 82 10 20 02 mov 2, %g1
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
2008a98: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
2008a9c: 03 00 80 8c sethi %hi(0x2023000), %g1
2008aa0: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 2023340 <_Per_CPU_Information+0x10>
if ( evp != NULL ) {
2008aa4: 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;
2008aa8: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
2008aac: 02 80 00 08 be 2008acc <timer_create+0xa8>
2008ab0: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
2008ab4: c6 06 40 00 ld [ %i1 ], %g3
ptimer->inf.sigev_signo = evp->sigev_signo;
2008ab8: c4 06 60 04 ld [ %i1 + 4 ], %g2
ptimer->inf.sigev_value = evp->sigev_value;
2008abc: c2 06 60 08 ld [ %i1 + 8 ], %g1
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
if ( evp != NULL ) {
ptimer->inf.sigev_notify = evp->sigev_notify;
2008ac0: c6 22 20 40 st %g3, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
2008ac4: c4 22 20 44 st %g2, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
2008ac8: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008acc: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008ad0: ba 17 60 e4 or %i5, 0xe4, %i5
2008ad4: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
}
ptimer->overrun = 0;
2008ad8: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
2008adc: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
2008ae0: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
2008ae4: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
2008ae8: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2008aec: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
2008af0: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
2008af4: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
2008af8: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008afc: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008b00: 85 28 a0 02 sll %g2, 2, %g2
2008b04: 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;
2008b08: 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;
2008b0c: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
2008b10: 40 00 0e 40 call 200c410 <_Thread_Enable_dispatch>
2008b14: b0 10 20 00 clr %i0
return 0;
}
2008b18: 81 c7 e0 08 ret
2008b1c: 81 e8 00 00 restore
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
2008b20: 40 00 25 f5 call 20122f4 <__errno>
2008b24: b0 10 3f ff mov -1, %i0
2008b28: 82 10 20 16 mov 0x16, %g1
2008b2c: c2 22 00 00 st %g1, [ %o0 ]
2008b30: 81 c7 e0 08 ret
2008b34: 81 e8 00 00 restore
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
2008b38: 40 00 0e 36 call 200c410 <_Thread_Enable_dispatch>
2008b3c: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EAGAIN );
2008b40: 40 00 25 ed call 20122f4 <__errno>
2008b44: 01 00 00 00 nop
2008b48: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
2008b4c: c2 22 00 00 st %g1, [ %o0 ]
2008b50: 81 c7 e0 08 ret
2008b54: 81 e8 00 00 restore
0200767c <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
200767c: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
2007680: 80 a6 a0 00 cmp %i2, 0
2007684: 02 80 00 86 be 200789c <timer_settime+0x220> <== NEVER TAKEN
2007688: 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) ) ) {
200768c: 40 00 10 84 call 200b89c <_Timespec_Is_valid>
2007690: 90 06 a0 08 add %i2, 8, %o0
2007694: 80 8a 20 ff btst 0xff, %o0
2007698: 02 80 00 81 be 200789c <timer_settime+0x220>
200769c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
20076a0: 40 00 10 7f call 200b89c <_Timespec_Is_valid>
20076a4: 90 10 00 1a mov %i2, %o0
20076a8: 80 8a 20 ff btst 0xff, %o0
20076ac: 02 80 00 7c be 200789c <timer_settime+0x220> <== NEVER TAKEN
20076b0: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
20076b4: 12 80 00 7a bne 200789c <timer_settime+0x220>
20076b8: 80 a6 60 04 cmp %i1, 4
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
20076bc: c8 06 80 00 ld [ %i2 ], %g4
20076c0: c6 06 a0 04 ld [ %i2 + 4 ], %g3
20076c4: c4 06 a0 08 ld [ %i2 + 8 ], %g2
20076c8: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
20076cc: c8 27 bf f0 st %g4, [ %fp + -16 ]
20076d0: c6 27 bf f4 st %g3, [ %fp + -12 ]
20076d4: c4 27 bf f8 st %g2, [ %fp + -8 ]
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
20076d8: 02 80 00 4c be 2007808 <timer_settime+0x18c>
20076dc: c2 27 bf fc st %g1, [ %fp + -4 ]
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
20076e0: 92 10 00 18 mov %i0, %o1
20076e4: 11 00 80 7c sethi %hi(0x201f000), %o0
20076e8: 94 07 bf dc add %fp, -36, %o2
20076ec: 40 00 09 ba call 2009dd4 <_Objects_Get>
20076f0: 90 12 21 24 or %o0, 0x124, %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 ) {
20076f4: c2 07 bf dc ld [ %fp + -36 ], %g1
20076f8: 80 a0 60 00 cmp %g1, 0
20076fc: 12 80 00 68 bne 200789c <timer_settime+0x220> <== NEVER TAKEN
2007700: b2 10 00 08 mov %o0, %i1
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
2007704: c2 07 bf f8 ld [ %fp + -8 ], %g1
2007708: 80 a0 60 00 cmp %g1, 0
200770c: 12 80 00 05 bne 2007720 <timer_settime+0xa4>
2007710: c2 07 bf fc ld [ %fp + -4 ], %g1
2007714: 80 a0 60 00 cmp %g1, 0
2007718: 02 80 00 67 be 20078b4 <timer_settime+0x238>
200771c: 01 00 00 00 nop
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
2007720: 40 00 10 98 call 200b980 <_Timespec_To_ticks>
2007724: 90 10 00 1a mov %i2, %o0
2007728: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
200772c: 40 00 10 95 call 200b980 <_Timespec_To_ticks>
2007730: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
2007734: d4 06 60 08 ld [ %i1 + 8 ], %o2
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
initial_period = _Timespec_To_ticks( &normalize.it_value );
2007738: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
200773c: 98 10 00 19 mov %i1, %o4
2007740: 90 06 60 10 add %i1, 0x10, %o0
2007744: 17 00 80 1e sethi %hi(0x2007800), %o3
2007748: 40 00 1a 5d call 200e0bc <_POSIX_Timer_Insert_helper>
200774c: 96 12 e1 20 or %o3, 0x120, %o3 ! 2007920 <_POSIX_Timer_TSR>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
2007750: 80 8a 20 ff btst 0xff, %o0
2007754: 02 80 00 29 be 20077f8 <timer_settime+0x17c>
2007758: 80 a6 e0 00 cmp %i3, 0
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
200775c: 02 80 00 0b be 2007788 <timer_settime+0x10c>
2007760: c2 07 bf f0 ld [ %fp + -16 ], %g1
*ovalue = ptimer->timer_data;
2007764: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
2007768: c2 26 c0 00 st %g1, [ %i3 ]
200776c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
2007770: c2 26 e0 04 st %g1, [ %i3 + 4 ]
2007774: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
2007778: c2 26 e0 08 st %g1, [ %i3 + 8 ]
200777c: c2 06 60 60 ld [ %i1 + 0x60 ], %g1
2007780: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
ptimer->timer_data = normalize;
2007784: c2 07 bf f0 ld [ %fp + -16 ], %g1
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
2007788: 90 07 bf e0 add %fp, -32, %o0
200778c: c2 26 60 54 st %g1, [ %i1 + 0x54 ]
2007790: c2 07 bf f4 ld [ %fp + -12 ], %g1
2007794: 13 00 80 7b sethi %hi(0x201ec00), %o1
2007798: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
200779c: c2 07 bf f8 ld [ %fp + -8 ], %g1
20077a0: 92 12 61 98 or %o1, 0x198, %o1
20077a4: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
20077a8: c2 07 bf fc ld [ %fp + -4 ], %g1
20077ac: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
20077b0: 82 10 20 03 mov 3, %g1
20077b4: 40 00 06 b4 call 2009284 <_TOD_Get_with_nanoseconds>
20077b8: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
20077bc: f8 1a 00 00 ldd [ %o0 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
20077c0: 94 10 20 00 clr %o2
20077c4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20077c8: 90 10 00 1c mov %i4, %o0
20077cc: 96 12 e2 00 or %o3, 0x200, %o3
20077d0: 40 00 4b 0e call 201a408 <__divdi3>
20077d4: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20077d8: 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);
20077dc: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20077e0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20077e4: 90 10 00 1c mov %i4, %o0
20077e8: 96 12 e2 00 or %o3, 0x200, %o3
20077ec: 40 00 4b f2 call 201a7b4 <__moddi3>
20077f0: 92 10 00 1d mov %i5, %o1
20077f4: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
ptimer->timer_data = normalize;
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
_TOD_Get( &ptimer->time );
_Thread_Enable_dispatch();
20077f8: 40 00 0d 65 call 200ad8c <_Thread_Enable_dispatch>
20077fc: b0 10 20 00 clr %i0
2007800: 81 c7 e0 08 ret
2007804: 81 e8 00 00 restore
2007808: 90 07 bf e0 add %fp, -32, %o0
200780c: 13 00 80 7b sethi %hi(0x201ec00), %o1
2007810: 40 00 06 9d call 2009284 <_TOD_Get_with_nanoseconds>
2007814: 92 12 61 98 or %o1, 0x198, %o1 ! 201ed98 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
2007818: f8 1a 00 00 ldd [ %o0 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
200781c: 94 10 20 00 clr %o2
2007820: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007824: 90 10 00 1c mov %i4, %o0
2007828: 96 12 e2 00 or %o3, 0x200, %o3
200782c: 40 00 4a f7 call 201a408 <__divdi3>
2007830: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007834: 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);
2007838: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
200783c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007840: 90 10 00 1c mov %i4, %o0
2007844: 96 12 e2 00 or %o3, 0x200, %o3
2007848: 40 00 4b db call 201a7b4 <__moddi3>
200784c: 92 10 00 1d mov %i5, %o1
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
2007850: 90 07 bf f8 add %fp, -8, %o0
2007854: d2 27 bf ec st %o1, [ %fp + -20 ]
2007858: 40 00 10 24 call 200b8e8 <_Timespec_Less_than>
200785c: 92 07 bf e8 add %fp, -24, %o1
2007860: 80 8a 20 ff btst 0xff, %o0
2007864: 12 80 00 0e bne 200789c <timer_settime+0x220>
2007868: 92 07 bf f8 add %fp, -8, %o1
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
200786c: 90 07 bf e8 add %fp, -24, %o0
2007870: 40 00 10 30 call 200b930 <_Timespec_Subtract>
2007874: 94 10 00 09 mov %o1, %o2
2007878: 92 10 00 18 mov %i0, %o1
200787c: 11 00 80 7c sethi %hi(0x201f000), %o0
2007880: 94 07 bf dc add %fp, -36, %o2
2007884: 40 00 09 54 call 2009dd4 <_Objects_Get>
2007888: 90 12 21 24 or %o0, 0x124, %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 ) {
200788c: c2 07 bf dc ld [ %fp + -36 ], %g1
2007890: 80 a0 60 00 cmp %g1, 0
2007894: 02 bf ff 9c be 2007704 <timer_settime+0x88>
2007898: b2 10 00 08 mov %o0, %i1
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
200789c: 40 00 25 42 call 2010da4 <__errno>
20078a0: b0 10 3f ff mov -1, %i0
20078a4: 82 10 20 16 mov 0x16, %g1
20078a8: c2 22 00 00 st %g1, [ %o0 ]
}
20078ac: 81 c7 e0 08 ret
20078b0: 81 e8 00 00 restore
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
20078b4: 40 00 11 3c call 200bda4 <_Watchdog_Remove>
20078b8: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
20078bc: 80 a6 e0 00 cmp %i3, 0
20078c0: 02 80 00 0b be 20078ec <timer_settime+0x270>
20078c4: c2 07 bf f0 ld [ %fp + -16 ], %g1
*ovalue = ptimer->timer_data;
20078c8: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
20078cc: c2 26 c0 00 st %g1, [ %i3 ]
20078d0: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
20078d4: c2 26 e0 04 st %g1, [ %i3 + 4 ]
20078d8: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
20078dc: c2 26 e0 08 st %g1, [ %i3 + 8 ]
20078e0: c2 06 60 60 ld [ %i1 + 0x60 ], %g1
20078e4: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
/* The new data are set */
ptimer->timer_data = normalize;
20078e8: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
/* Returns with success */
_Thread_Enable_dispatch();
return 0;
20078ec: b0 10 20 00 clr %i0
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
/* The new data are set */
ptimer->timer_data = normalize;
20078f0: c2 26 60 54 st %g1, [ %i1 + 0x54 ]
20078f4: c2 07 bf f4 ld [ %fp + -12 ], %g1
20078f8: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
20078fc: c2 07 bf f8 ld [ %fp + -8 ], %g1
2007900: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
2007904: c2 07 bf fc ld [ %fp + -4 ], %g1
2007908: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
200790c: 82 10 20 04 mov 4, %g1
/* Returns with success */
_Thread_Enable_dispatch();
2007910: 40 00 0d 1f call 200ad8c <_Thread_Enable_dispatch>
2007914: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
2007918: 81 c7 e0 08 ret
200791c: 81 e8 00 00 restore
020078b8 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
20078b8: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
20078bc: 3b 00 80 82 sethi %hi(0x2020800), %i5
20078c0: ba 17 61 18 or %i5, 0x118, %i5 ! 2020918 <_POSIX_signals_Ualarm_timer>
20078c4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
20078c8: 80 a0 60 00 cmp %g1, 0
20078cc: 02 80 00 24 be 200795c <ualarm+0xa4>
20078d0: b8 10 00 18 mov %i0, %i4
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
20078d4: 40 00 10 ed call 200bc88 <_Watchdog_Remove>
20078d8: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
20078dc: 90 02 3f fe add %o0, -2, %o0
20078e0: 80 a2 20 01 cmp %o0, 1
20078e4: 08 80 00 26 bleu 200797c <ualarm+0xc4> <== ALWAYS TAKEN
20078e8: b0 10 20 00 clr %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 ) {
20078ec: 80 a7 20 00 cmp %i4, 0
20078f0: 02 80 00 19 be 2007954 <ualarm+0x9c>
20078f4: 37 00 03 d0 sethi %hi(0xf4000), %i3
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
20078f8: 90 10 00 1c mov %i4, %o0
20078fc: 40 00 4e 61 call 201b280 <.udiv>
2007900: 92 16 e2 40 or %i3, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007904: 92 16 e2 40 or %i3, 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;
2007908: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
200790c: 40 00 4f 09 call 201b530 <.urem>
2007910: 90 10 00 1c mov %i4, %o0
2007914: 87 2a 20 07 sll %o0, 7, %g3
2007918: 82 10 00 08 mov %o0, %g1
200791c: 85 2a 20 02 sll %o0, 2, %g2
2007920: 84 20 c0 02 sub %g3, %g2, %g2
2007924: 82 00 80 01 add %g2, %g1, %g1
2007928: 83 28 60 03 sll %g1, 3, %g1
ticks = _Timespec_To_ticks( &tp );
200792c: 90 07 bf f8 add %fp, -8, %o0
2007930: 40 00 0f 9d call 200b7a4 <_Timespec_To_ticks>
2007934: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
2007938: 40 00 0f 9b call 200b7a4 <_Timespec_To_ticks>
200793c: 90 07 bf f8 add %fp, -8, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007940: 92 10 00 1d mov %i5, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2007944: d0 27 60 0c st %o0, [ %i5 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007948: 11 00 80 80 sethi %hi(0x2020000), %o0
200794c: 40 00 10 70 call 200bb0c <_Watchdog_Insert>
2007950: 90 12 20 bc or %o0, 0xbc, %o0 ! 20200bc <_Watchdog_Ticks_chain>
}
return remaining;
}
2007954: 81 c7 e0 08 ret
2007958: 81 e8 00 00 restore
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
200795c: 03 00 80 1e sethi %hi(0x2007800), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2007960: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
2007964: 82 10 60 88 or %g1, 0x88, %g1
the_watchdog->id = id;
2007968: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
200796c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
2007970: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
2007974: 10 bf ff de b 20078ec <ualarm+0x34>
2007978: 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);
200797c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
2007980: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2007984: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
2007988: 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);
200798c: 90 02 00 02 add %o0, %g2, %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
2007990: 40 00 0f 70 call 200b750 <_Timespec_From_ticks>
2007994: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
2007998: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
200799c: 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;
20079a0: 85 28 60 03 sll %g1, 3, %g2
20079a4: 87 28 60 08 sll %g1, 8, %g3
20079a8: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
20079ac: 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;
20079b0: b1 28 a0 06 sll %g2, 6, %i0
20079b4: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
20079b8: 40 00 4e 34 call 201b288 <.div>
20079bc: 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;
20079c0: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
20079c4: 10 bf ff ca b 20078ec <ualarm+0x34>
20079c8: b0 02 00 18 add %o0, %i0, %i0
02007350 <unmount>:
* in some form is supported on most UNIX and POSIX systems. This
* routine is necessary to mount instantiations of a file system
* into the file system name space.
*/
int unmount( const char *path )
{
2007350: 9d e3 bf 60 save %sp, -160, %sp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
2007354: 94 10 20 18 mov 0x18, %o2
2007358: 92 10 00 18 mov %i0, %o1
200735c: 7f ff f6 96 call 2004db4 <rtems_filesystem_eval_path_start>
2007360: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
2007364: fa 02 20 14 ld [ %o0 + 0x14 ], %i5
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
return (*mt_entry->ops->are_nodes_equal_h)(
2007368: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200736c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2007370: 9f c0 40 00 call %g1
2007374: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
2007378: 80 8a 20 ff btst 0xff, %o0
200737c: 02 80 00 33 be 2007448 <unmount+0xf8>
2007380: 03 00 80 77 sethi %hi(0x201dc00), %g1
static bool contains_root_or_current_directory(
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
2007384: c2 00 62 38 ld [ %g1 + 0x238 ], %g1 ! 201de38 <rtems_current_user_env>
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
2007388: c4 00 60 04 ld [ %g1 + 4 ], %g2
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
200738c: c6 00 40 00 ld [ %g1 ], %g3
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
2007390: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
2007394: 80 a7 40 01 cmp %i5, %g1
2007398: 02 80 00 27 be 2007434 <unmount+0xe4>
200739c: 01 00 00 00 nop
20073a0: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1
20073a4: 80 a7 40 01 cmp %i5, %g1
20073a8: 02 80 00 23 be 2007434 <unmount+0xe4>
20073ac: 01 00 00 00 nop
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
20073b0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
20073b4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
20073b8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20073bc: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
20073c0: 9f c0 40 00 call %g1
20073c4: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
20073c8: b0 92 20 00 orcc %o0, 0, %i0
20073cc: 02 80 00 06 be 20073e4 <unmount+0x94>
20073d0: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
20073d4: 7f ff f6 b8 call 2004eb4 <rtems_filesystem_eval_path_cleanup>
20073d8: 90 07 bf c8 add %fp, -56, %o0
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
20073dc: 81 c7 e0 08 ret
20073e0: 81 e8 00 00 restore
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
rv = (*mt_point_ops->unmount_h)( mt_entry );
if ( rv == 0 ) {
rtems_id self_task_id = rtems_task_self();
20073e4: 40 00 04 48 call 2008504 <rtems_task_self>
20073e8: 01 00 00 00 nop
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
20073ec: 7f ff ec 72 call 20025b4 <sparc_disable_interrupts>
20073f0: b8 10 00 08 mov %o0, %i4
mt_entry->unmount_task = self_task_id;
20073f4: f8 27 60 3c st %i4, [ %i5 + 0x3c ]
mt_entry->mounted = false;
20073f8: c0 2f 60 28 clrb [ %i5 + 0x28 ]
rtems_filesystem_mt_entry_unlock( lock_context );
20073fc: 7f ff ec 72 call 20025c4 <sparc_enable_interrupts>
2007400: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2007404: 7f ff f6 ac call 2004eb4 <rtems_filesystem_eval_path_cleanup>
2007408: 90 07 bf c8 add %fp, -56, %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
200740c: 11 20 00 00 sethi %hi(0x80000000), %o0
2007410: 92 10 20 00 clr %o1
2007414: 94 10 20 00 clr %o2
2007418: 40 00 03 78 call 20081f8 <rtems_event_system_receive>
200741c: 96 07 bf c4 add %fp, -60, %o3
rtems_status_code sc = rtems_event_transient_receive(
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( sc != RTEMS_SUCCESSFUL ) {
2007420: 80 a2 20 00 cmp %o0, 0
2007424: 02 bf ff ee be 20073dc <unmount+0x8c> <== ALWAYS TAKEN
2007428: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
200742c: 40 00 04 ec call 20087dc <rtems_fatal_error_occurred> <== NOT EXECUTED
2007430: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
mt_entry->unmount_task = self_task_id;
mt_entry->mounted = false;
rtems_filesystem_mt_entry_unlock( lock_context );
}
} else {
errno = EBUSY;
2007434: 40 00 25 2c call 20108e4 <__errno>
2007438: b0 10 3f ff mov -1, %i0
200743c: 82 10 20 10 mov 0x10, %g1
2007440: 10 bf ff e5 b 20073d4 <unmount+0x84>
2007444: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
} else {
errno = EACCES;
2007448: 40 00 25 27 call 20108e4 <__errno>
200744c: b0 10 3f ff mov -1, %i0
2007450: 82 10 20 0d mov 0xd, %g1
2007454: 10 bf ff e0 b 20073d4 <unmount+0x84>
2007458: c2 22 00 00 st %g1, [ %o0 ]
0200703c <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
200703c: 9d e3 bf 88 save %sp, -120, %sp
for (; *fmt != '\0'; fmt++) {
2007040: d0 0e 00 00 ldub [ %i0 ], %o0
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
2007044: a0 07 bf e8 add %fp, -24, %l0
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
2007048: 91 2a 20 18 sll %o0, 0x18, %o0
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
200704c: a2 07 bf e7 add %fp, -25, %l1
2007050: 25 00 80 70 sethi %hi(0x201c000), %l2
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
2007054: 80 a2 20 00 cmp %o0, 0
2007058: 02 80 00 74 be 2007228 <vprintk+0x1ec> <== NEVER TAKEN
200705c: 27 00 80 6e sethi %hi(0x201b800), %l3
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
2007060: 91 3a 20 18 sra %o0, 0x18, %o0
2007064: 80 a2 20 25 cmp %o0, 0x25
2007068: 12 80 00 7a bne 2007250 <vprintk+0x214>
200706c: 01 00 00 00 nop
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
2007070: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
2007074: 85 28 60 18 sll %g1, 0x18, %g2
2007078: 87 38 a0 18 sra %g2, 0x18, %g3
200707c: 80 a0 e0 30 cmp %g3, 0x30
2007080: 22 80 00 a9 be,a 2007324 <vprintk+0x2e8>
2007084: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
if (*fmt != '%') {
rtems_putc(*fmt);
continue;
}
fmt++;
2007088: b0 06 20 01 inc %i0
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
200708c: a8 10 20 20 mov 0x20, %l4
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
2007090: 87 38 a0 18 sra %g2, 0x18, %g3
2007094: 80 a0 e0 2d cmp %g3, 0x2d
2007098: 02 80 00 9e be 2007310 <vprintk+0x2d4>
200709c: 88 10 20 00 clr %g4
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
20070a0: 86 00 7f d0 add %g1, -48, %g3
20070a4: 86 08 e0 ff and %g3, 0xff, %g3
20070a8: 80 a0 e0 09 cmp %g3, 9
20070ac: 18 80 00 0f bgu 20070e8 <vprintk+0xac>
20070b0: ba 10 20 00 clr %i5
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
20070b4: b0 06 20 01 inc %i0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
20070b8: c2 0e 00 00 ldub [ %i0 ], %g1
width *= 10;
20070bc: 87 2f 60 01 sll %i5, 1, %g3
width += ((unsigned) *fmt - '0');
20070c0: 85 38 a0 18 sra %g2, 0x18, %g2
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
20070c4: bb 2f 60 03 sll %i5, 3, %i5
20070c8: ba 00 c0 1d add %g3, %i5, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
20070cc: 86 00 7f d0 add %g1, -48, %g3
width *= 10;
width += ((unsigned) *fmt - '0');
20070d0: ba 07 40 02 add %i5, %g2, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
20070d4: 86 08 e0 ff and %g3, 0xff, %g3
width *= 10;
width += ((unsigned) *fmt - '0');
20070d8: ba 07 7f d0 add %i5, -48, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
20070dc: 80 a0 e0 09 cmp %g3, 9
20070e0: 08 bf ff f5 bleu 20070b4 <vprintk+0x78>
20070e4: 85 28 60 18 sll %g1, 0x18, %g2
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
20070e8: 87 38 a0 18 sra %g2, 0x18, %g3
20070ec: 80 a0 e0 6c cmp %g3, 0x6c
20070f0: 02 80 00 77 be 20072cc <vprintk+0x290>
20070f4: 91 38 a0 18 sra %g2, 0x18, %o0
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
20070f8: 80 a2 20 63 cmp %o0, 0x63
20070fc: 22 80 00 7b be,a 20072e8 <vprintk+0x2ac>
2007100: d0 06 40 00 ld [ %i1 ], %o0
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
rtems_putc(chr);
continue;
}
if ( c == 's' ) {
2007104: 80 a2 20 73 cmp %o0, 0x73
2007108: 02 80 00 8b be 2007334 <vprintk+0x2f8>
200710c: 82 08 7f df and %g1, -33, %g1
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
2007110: 83 28 60 18 sll %g1, 0x18, %g1
2007114: 83 38 60 18 sra %g1, 0x18, %g1
2007118: 80 a0 60 4f cmp %g1, 0x4f
200711c: 22 80 00 55 be,a 2007270 <vprintk+0x234>
2007120: f4 06 40 00 ld [ %i1 ], %i2
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
2007124: 80 a0 60 49 cmp %g1, 0x49
2007128: 22 80 00 06 be,a 2007140 <vprintk+0x104>
200712c: 82 10 20 01 mov 1, %g1
c == 'd' || c == 'D' ) {
2007130: 80 a0 60 44 cmp %g1, 0x44
2007134: 12 80 00 3f bne 2007230 <vprintk+0x1f4>
2007138: 80 a0 60 55 cmp %g1, 0x55
base = 10; sign = true;
200713c: 82 10 20 01 mov 1, %g1
2007140: aa 10 20 0a mov 0xa, %l5
} else {
rtems_putc(c);
continue;
}
printNum(
2007144: f4 06 40 00 ld [ %i1 ], %i2
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
2007148: 80 a6 a0 00 cmp %i2, 0
200714c: 06 80 00 4e bl 2007284 <vprintk+0x248>
2007150: b2 06 60 04 add %i1, 4, %i1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
2007154: 90 10 00 1a mov %i2, %o0
2007158: 40 00 48 1d call 20191cc <.udiv>
200715c: 92 10 00 15 mov %l5, %o1
2007160: b8 92 20 00 orcc %o0, 0, %i4
2007164: 22 80 00 57 be,a 20072c0 <vprintk+0x284>
2007168: b8 10 00 1a mov %i2, %i4
200716c: ac 10 00 15 mov %l5, %l6
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
2007170: 10 80 00 03 b 200717c <vprintk+0x140>
2007174: b6 10 20 00 clr %i3
while ((n = unsigned_num / base) > 0) {
2007178: b8 10 00 08 mov %o0, %i4
toPrint[count++] = (char) (unsigned_num - (n * base));
200717c: 92 10 00 1c mov %i4, %o1
2007180: 40 00 47 d9 call 20190e4 <.umul>
2007184: 90 10 00 16 mov %l6, %o0
2007188: b4 26 80 08 sub %i2, %o0, %i2
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
200718c: 92 10 00 15 mov %l5, %o1
toPrint[count++] = (char) (unsigned_num - (n * base));
2007190: f4 2c 00 1b stb %i2, [ %l0 + %i3 ]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
2007194: 90 10 00 1c mov %i4, %o0
2007198: 40 00 48 0d call 20191cc <.udiv>
200719c: b4 10 00 1c mov %i4, %i2
20071a0: 80 a2 20 00 cmp %o0, 0
20071a4: 12 bf ff f5 bne 2007178 <vprintk+0x13c>
20071a8: b6 06 e0 01 inc %i3
20071ac: b4 06 e0 01 add %i3, 1, %i2
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
20071b0: b6 07 80 1b add %fp, %i3, %i3
20071b4: f8 2e ff e8 stb %i4, [ %i3 + -24 ]
20071b8: a9 2d 20 18 sll %l4, 0x18, %l4
for (n=maxwidth ; n > count; n-- )
20071bc: 80 a6 80 1d cmp %i2, %i5
20071c0: 1a 80 00 08 bcc 20071e0 <vprintk+0x1a4>
20071c4: a9 3d 20 18 sra %l4, 0x18, %l4
rtems_putc(lead);
20071c8: 40 00 16 a0 call 200cc48 <rtems_putc>
20071cc: 90 10 00 14 mov %l4, %o0
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
20071d0: ba 07 7f ff add %i5, -1, %i5
20071d4: 80 a6 80 1d cmp %i2, %i5
20071d8: 0a bf ff fc bcs 20071c8 <vprintk+0x18c>
20071dc: 01 00 00 00 nop
rtems_putc(lead);
for (n = 0; n < count; n++) {
20071e0: 80 a6 a0 00 cmp %i2, 0
20071e4: 22 80 00 0d be,a 2007218 <vprintk+0x1dc> <== NEVER TAKEN
20071e8: d0 0e 20 01 ldub [ %i0 + 1 ], %o0 <== NOT EXECUTED
rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
20071ec: ba 06 bf ff add %i2, -1, %i5
20071f0: b8 14 a1 90 or %l2, 0x190, %i4
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
20071f4: ba 04 00 1d add %l0, %i5, %i5
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
20071f8: c2 4f 40 00 ldsb [ %i5 ], %g1
20071fc: ba 07 7f ff add %i5, -1, %i5
2007200: 40 00 16 92 call 200cc48 <rtems_putc>
2007204: d0 4f 00 01 ldsb [ %i4 + %g1 ], %o0
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
2007208: 80 a7 40 11 cmp %i5, %l1
200720c: 32 bf ff fc bne,a 20071fc <vprintk+0x1c0>
2007210: c2 4f 40 00 ldsb [ %i5 ], %g1
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
2007214: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
2007218: 91 2a 20 18 sll %o0, 0x18, %o0
200721c: 80 a2 20 00 cmp %o0, 0
2007220: 12 bf ff 90 bne 2007060 <vprintk+0x24>
2007224: b0 06 20 01 inc %i0
2007228: 81 c7 e0 08 ret
200722c: 81 e8 00 00 restore
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
2007230: 22 80 00 7e be,a 2007428 <vprintk+0x3ec>
2007234: 82 10 20 00 clr %g1
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
2007238: 80 a0 60 58 cmp %g1, 0x58
200723c: 02 80 00 7d be 2007430 <vprintk+0x3f4>
2007240: 82 10 20 00 clr %g1
base = 16; sign = false;
} else if ( c == 'p' ) {
2007244: 80 a2 20 70 cmp %o0, 0x70
2007248: 02 bf ff bf be 2007144 <vprintk+0x108>
200724c: aa 10 20 10 mov 0x10, %l5
base = 16; sign = false; lflag = true;
} else {
rtems_putc(c);
2007250: 40 00 16 7e call 200cc48 <rtems_putc>
2007254: 01 00 00 00 nop
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
2007258: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
200725c: 91 2a 20 18 sll %o0, 0x18, %o0
2007260: 80 a2 20 00 cmp %o0, 0
2007264: 12 bf ff 7f bne 2007060 <vprintk+0x24>
2007268: b0 06 20 01 inc %i0
200726c: 30 80 00 6d b,a 2007420 <vprintk+0x3e4>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
2007270: 82 10 20 00 clr %g1
2007274: aa 10 20 08 mov 8, %l5
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
2007278: 80 a6 a0 00 cmp %i2, 0
200727c: 16 bf ff b6 bge 2007154 <vprintk+0x118> <== ALWAYS TAKEN
2007280: b2 06 60 04 add %i1, 4, %i1
2007284: 80 88 60 ff btst 0xff, %g1
2007288: 02 bf ff b4 be 2007158 <vprintk+0x11c>
200728c: 90 10 00 1a mov %i2, %o0
rtems_putc('-');
2007290: 40 00 16 6e call 200cc48 <rtems_putc>
2007294: 90 10 20 2d mov 0x2d, %o0
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
2007298: 80 a0 00 1d cmp %g0, %i5
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
rtems_putc('-');
unsigned_num = (unsigned long) -num;
200729c: b4 20 00 1a neg %i2
if (maxwidth) maxwidth--;
20072a0: ba 67 60 00 subx %i5, 0, %i5
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
20072a4: 90 10 00 1a mov %i2, %o0
20072a8: 40 00 47 c9 call 20191cc <.udiv>
20072ac: 92 10 00 15 mov %l5, %o1
20072b0: b8 92 20 00 orcc %o0, 0, %i4
20072b4: 32 bf ff af bne,a 2007170 <vprintk+0x134> <== ALWAYS TAKEN
20072b8: ac 10 00 15 mov %l5, %l6
20072bc: b8 10 00 1a mov %i2, %i4 <== NOT EXECUTED
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
20072c0: b6 10 20 00 clr %i3
while ((n = unsigned_num / base) > 0) {
20072c4: 10 bf ff bb b 20071b0 <vprintk+0x174>
20072c8: b4 10 20 01 mov 1, %i2
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
c = *++fmt;
20072cc: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
20072d0: 85 28 60 18 sll %g1, 0x18, %g2
}
if ( c == 'c' ) {
20072d4: 91 38 a0 18 sra %g2, 0x18, %o0
20072d8: 80 a2 20 63 cmp %o0, 0x63
20072dc: 12 bf ff 8a bne 2007104 <vprintk+0xc8> <== ALWAYS TAKEN
20072e0: b0 06 20 01 inc %i0
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
20072e4: d0 06 40 00 ld [ %i1 ], %o0 <== NOT EXECUTED
20072e8: b2 06 60 04 add %i1, 4, %i1
rtems_putc(chr);
20072ec: 91 2a 20 18 sll %o0, 0x18, %o0
20072f0: 40 00 16 56 call 200cc48 <rtems_putc>
20072f4: 91 3a 20 18 sra %o0, 0x18, %o0
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
20072f8: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
20072fc: 91 2a 20 18 sll %o0, 0x18, %o0
2007300: 80 a2 20 00 cmp %o0, 0
2007304: 12 bf ff 57 bne 2007060 <vprintk+0x24>
2007308: b0 06 20 01 inc %i0
200730c: 30 80 00 45 b,a 2007420 <vprintk+0x3e4>
2007310: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
2007314: 88 10 20 01 mov 1, %g4
fmt++;
2007318: b0 06 20 01 inc %i0
200731c: 10 bf ff 61 b 20070a0 <vprintk+0x64>
2007320: 85 28 60 18 sll %g1, 0x18, %g2
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
2007324: a8 10 20 30 mov 0x30, %l4
fmt++;
2007328: b0 06 20 02 add %i0, 2, %i0
200732c: 10 bf ff 59 b 2007090 <vprintk+0x54>
2007330: 85 28 60 18 sll %g1, 0x18, %g2
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
2007334: f6 06 40 00 ld [ %i1 ], %i3
if ( str == NULL ) {
2007338: 80 a6 e0 00 cmp %i3, 0
200733c: 02 80 00 3f be 2007438 <vprintk+0x3fc>
2007340: b2 06 60 04 add %i1, 4, %i1
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
2007344: c2 4e c0 00 ldsb [ %i3 ], %g1
2007348: 80 a0 60 00 cmp %g1, 0
200734c: 02 80 00 07 be 2007368 <vprintk+0x32c>
2007350: b8 10 20 00 clr %i4
2007354: b8 07 20 01 inc %i4
2007358: c2 4e c0 1c ldsb [ %i3 + %i4 ], %g1
200735c: 80 a0 60 00 cmp %g1, 0
2007360: 32 bf ff fe bne,a 2007358 <vprintk+0x31c>
2007364: b8 07 20 01 inc %i4
;
/* leading spaces */
if ( !minus )
2007368: a8 89 20 ff andcc %g4, 0xff, %l4
200736c: 12 80 00 0c bne 200739c <vprintk+0x360>
2007370: 80 a7 60 00 cmp %i5, 0
for ( i=len ; i<width ; i++ )
2007374: 80 a7 40 1c cmp %i5, %i4
2007378: 08 80 00 09 bleu 200739c <vprintk+0x360>
200737c: 80 a7 60 00 cmp %i5, 0
2007380: b4 10 00 1c mov %i4, %i2
rtems_putc(' ');
2007384: 40 00 16 31 call 200cc48 <rtems_putc>
2007388: 90 10 20 20 mov 0x20, %o0
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
200738c: b4 06 a0 01 inc %i2
2007390: 80 a6 80 1d cmp %i2, %i5
2007394: 0a bf ff fc bcs 2007384 <vprintk+0x348>
2007398: 80 a7 60 00 cmp %i5, 0
rtems_putc(' ');
/* no width option */
if (width == 0) {
200739c: 32 80 00 07 bne,a 20073b8 <vprintk+0x37c>
20073a0: d0 4e c0 00 ldsb [ %i3 ], %o0
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
20073a4: 80 a7 20 00 cmp %i4, 0
20073a8: 22 bf ff 9c be,a 2007218 <vprintk+0x1dc>
20073ac: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
20073b0: ba 10 00 1c mov %i4, %i5
20073b4: d0 4e c0 00 ldsb [ %i3 ], %o0
20073b8: 80 a2 20 00 cmp %o0, 0
20073bc: 02 80 00 08 be 20073dc <vprintk+0x3a0> <== NEVER TAKEN
20073c0: b6 06 e0 01 inc %i3
rtems_putc(*str);
20073c4: 40 00 16 21 call 200cc48 <rtems_putc>
20073c8: 01 00 00 00 nop
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
20073cc: d0 4e c0 00 ldsb [ %i3 ], %o0
20073d0: 80 a2 20 00 cmp %o0, 0
20073d4: 12 bf ff fc bne 20073c4 <vprintk+0x388>
20073d8: b6 06 e0 01 inc %i3
rtems_putc(*str);
/* trailing spaces */
if ( minus )
20073dc: 80 a5 20 00 cmp %l4, 0
20073e0: 22 bf ff 8e be,a 2007218 <vprintk+0x1dc>
20073e4: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
for ( i=len ; i<width ; i++ )
20073e8: 80 a7 40 1c cmp %i5, %i4
20073ec: 28 bf ff 8b bleu,a 2007218 <vprintk+0x1dc>
20073f0: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
rtems_putc(' ');
20073f4: 40 00 16 15 call 200cc48 <rtems_putc>
20073f8: 90 10 20 20 mov 0x20, %o0
for ( i=0 ; i<width && *str ; str++ )
rtems_putc(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
20073fc: b8 07 20 01 inc %i4
2007400: 80 a7 00 1d cmp %i4, %i5
2007404: 0a bf ff fc bcs 20073f4 <vprintk+0x3b8>
2007408: 01 00 00 00 nop
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
200740c: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
2007410: 91 2a 20 18 sll %o0, 0x18, %o0
2007414: 80 a2 20 00 cmp %o0, 0
2007418: 12 bf ff 12 bne 2007060 <vprintk+0x24> <== ALWAYS TAKEN
200741c: b0 06 20 01 inc %i0
2007420: 81 c7 e0 08 ret
2007424: 81 e8 00 00 restore
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
2007428: 10 bf ff 47 b 2007144 <vprintk+0x108>
200742c: aa 10 20 0a mov 0xa, %l5
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
2007430: 10 bf ff 45 b 2007144 <vprintk+0x108>
2007434: aa 10 20 10 mov 0x10, %l5
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
2007438: 10 bf ff c3 b 2007344 <vprintk+0x308>
200743c: b6 14 e2 78 or %l3, 0x278, %i3
0201abf4 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
201abf4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201abf8: 03 00 80 75 sethi %hi(0x201d400), %g1
201abfc: c2 00 63 44 ld [ %g1 + 0x344 ], %g1 ! 201d744 <rtems_libio_number_iops>
201ac00: 80 a6 00 01 cmp %i0, %g1
201ac04: 1a 80 00 18 bcc 201ac64 <write+0x70>
201ac08: 03 00 80 78 sethi %hi(0x201e000), %g1
iop = rtems_libio_iop( fd );
201ac0c: d0 00 61 94 ld [ %g1 + 0x194 ], %o0 ! 201e194 <rtems_libio_iops>
201ac10: 83 2e 20 03 sll %i0, 3, %g1
201ac14: b1 2e 20 06 sll %i0, 6, %i0
201ac18: b0 26 00 01 sub %i0, %g1, %i0
201ac1c: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
201ac20: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
201ac24: 80 88 61 00 btst 0x100, %g1
201ac28: 02 80 00 0f be 201ac64 <write+0x70>
201ac2c: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
201ac30: 02 80 00 13 be 201ac7c <write+0x88> <== NEVER TAKEN
201ac34: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
201ac38: 02 80 00 0f be 201ac74 <write+0x80>
201ac3c: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
201ac40: 80 88 60 04 btst 4, %g1
201ac44: 02 80 00 08 be 201ac64 <write+0x70>
201ac48: 92 10 00 19 mov %i1, %o1
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
201ac4c: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
201ac50: c2 00 60 0c ld [ %g1 + 0xc ], %g1
201ac54: 9f c0 40 00 call %g1
201ac58: 94 10 00 1a mov %i2, %o2
}
201ac5c: 81 c7 e0 08 ret
201ac60: 91 e8 00 08 restore %g0, %o0, %o0
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
201ac64: 7f ff d5 dd call 20103d8 <__errno>
201ac68: b0 10 3f ff mov -1, %i0
201ac6c: 82 10 20 09 mov 9, %g1
201ac70: c2 22 00 00 st %g1, [ %o0 ]
201ac74: 81 c7 e0 08 ret
201ac78: 81 e8 00 00 restore
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
201ac7c: 7f ff d5 d7 call 20103d8 <__errno> <== NOT EXECUTED
201ac80: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201ac84: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201ac88: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201ac8c: 81 c7 e0 08 ret <== NOT EXECUTED
201ac90: 81 e8 00 00 restore <== NOT EXECUTED
02008318 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
2008318: 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 );
200831c: 03 00 80 78 sethi %hi(0x201e000), %g1
2008320: c2 00 62 44 ld [ %g1 + 0x244 ], %g1 ! 201e244 <rtems_libio_number_iops>
2008324: 80 a6 00 01 cmp %i0, %g1
2008328: 1a 80 00 4d bcc 200845c <writev+0x144>
200832c: 03 00 80 7b sethi %hi(0x201ec00), %g1
iop = rtems_libio_iop( fd );
2008330: f6 00 60 94 ld [ %g1 + 0x94 ], %i3 ! 201ec94 <rtems_libio_iops>
2008334: 83 2e 20 03 sll %i0, 3, %g1
2008338: b1 2e 20 06 sll %i0, 6, %i0
200833c: b0 26 00 01 sub %i0, %g1, %i0
2008340: b6 06 c0 18 add %i3, %i0, %i3
rtems_libio_check_is_open( iop );
2008344: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
2008348: 80 88 61 00 btst 0x100, %g1
200834c: 02 80 00 44 be 200845c <writev+0x144>
2008350: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
2008354: 02 80 00 42 be 200845c <writev+0x144> <== NEVER TAKEN
2008358: 80 a6 60 00 cmp %i1, 0
/*
* Argument validation on IO vector
*/
if ( !iov )
200835c: 02 80 00 3a be 2008444 <writev+0x12c>
2008360: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
2008364: 04 80 00 38 ble 2008444 <writev+0x12c>
2008368: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
200836c: 14 80 00 36 bg 2008444 <writev+0x12c> <== NEVER TAKEN
2008370: b5 2e a0 03 sll %i2, 3, %i2
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
2008374: 82 10 20 00 clr %g1
2008378: ba 10 20 01 mov 1, %i5
200837c: 84 10 20 00 clr %g2
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
2008380: c6 06 40 01 ld [ %i1 + %g1 ], %g3
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
2008384: b8 06 40 01 add %i1, %g1, %i4
/*
* 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 )
2008388: 80 a0 e0 00 cmp %g3, 0
200838c: 02 80 00 2e be 2008444 <writev+0x12c>
2008390: 88 10 20 01 mov 1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
2008394: c6 07 20 04 ld [ %i4 + 4 ], %g3
2008398: 82 00 60 08 add %g1, 8, %g1
all_zeros = false;
200839c: 80 a0 00 03 cmp %g0, %g3
20083a0: b8 40 3f ff addx %g0, -1, %i4
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
20083a4: 86 80 c0 02 addcc %g3, %g2, %g3
20083a8: 0c 80 00 27 bneg 2008444 <writev+0x12c>
20083ac: ba 0f 40 1c and %i5, %i4, %i5
20083b0: 80 a0 80 03 cmp %g2, %g3
20083b4: 24 80 00 02 ble,a 20083bc <writev+0xa4>
20083b8: 88 10 20 00 clr %g4
20083bc: 80 89 20 ff btst 0xff, %g4
20083c0: 12 80 00 21 bne 2008444 <writev+0x12c>
20083c4: 80 a0 40 1a cmp %g1, %i2
* 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++ ) {
20083c8: 12 bf ff ee bne 2008380 <writev+0x68>
20083cc: 84 10 00 03 mov %g3, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
20083d0: 80 8f 60 ff btst 0xff, %i5
20083d4: 12 80 00 1a bne 200843c <writev+0x124>
20083d8: b0 10 20 00 clr %i0
20083dc: 10 80 00 05 b 20083f0 <writev+0xd8>
20083e0: ba 10 20 00 clr %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
20083e4: 80 a7 40 1a cmp %i5, %i2
20083e8: 02 80 00 21 be 200846c <writev+0x154>
20083ec: 01 00 00 00 nop
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
20083f0: b8 06 40 1d add %i1, %i5, %i4
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
20083f4: d4 07 20 04 ld [ %i4 + 4 ], %o2
20083f8: 80 a2 a0 00 cmp %o2, 0
20083fc: 22 bf ff fa be,a 20083e4 <writev+0xcc> <== NEVER TAKEN
2008400: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
2008404: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
2008408: d2 06 40 1d ld [ %i1 + %i5 ], %o1
200840c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2008410: 9f c0 40 00 call %g1
2008414: 90 10 00 1b mov %i3, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
2008418: 80 a2 20 00 cmp %o0, 0
200841c: 06 80 00 16 bl 2008474 <writev+0x15c> <== NEVER TAKEN
2008420: 01 00 00 00 nop
return -1;
if ( bytes > 0 ) {
2008424: 32 80 00 02 bne,a 200842c <writev+0x114> <== ALWAYS TAKEN
2008428: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
200842c: c2 07 20 04 ld [ %i4 + 4 ], %g1
2008430: 80 a2 00 01 cmp %o0, %g1
2008434: 02 bf ff ec be 20083e4 <writev+0xcc> <== ALWAYS TAKEN
2008438: ba 07 60 08 add %i5, 8, %i5
break;
}
return total;
}
200843c: 81 c7 e0 08 ret
2008440: 81 e8 00 00 restore
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
2008444: 40 00 23 3d call 2011138 <__errno>
2008448: b0 10 3f ff mov -1, %i0
200844c: 82 10 20 16 mov 0x16, %g1
2008450: c2 22 00 00 st %g1, [ %o0 ]
2008454: 81 c7 e0 08 ret
2008458: 81 e8 00 00 restore
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
200845c: 40 00 23 37 call 2011138 <__errno>
2008460: b0 10 3f ff mov -1, %i0
2008464: 82 10 20 09 mov 9, %g1
2008468: c2 22 00 00 st %g1, [ %o0 ]
200846c: 81 c7 e0 08 ret
2008470: 81 e8 00 00 restore
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
2008474: 81 c7 e0 08 ret <== NOT EXECUTED
2008478: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED